Talk on community management at Inria fOSSa 2012

The Gephi Consoritium will participate to the fourth edition of the fOSSa Conference taking place from December 4 to 6, 2012 in Lille (France).

The aim of the fOSSa (Free Open Source Academia Conference) is to reaffirm the underlying values of Open Source software: innovation & research in software development.

While the first edition aimed at providing valuable information on the Open Source model at large, the second edition focused specific key-aspects of FOSS such as tech innovation,upcoming issues & challenges in the open development context and how open activities, collaboration and knowledge sharing is beneficial to academia, education & industry. The third edition look at the future of Open Source (Eco system, Trends, new territories, etc).

The fourth edition will address in an open-minded style about:
Digital Geographic Strategies & the Native Generation,
– FLOSS History with the movie: “Revolution OS” followed by a debate,
Open Art, collaboration between art & science,
Licenses in the real life: no lawyers speeches, only facts & return experience,
– Workshops to learn how to develop code for debian, gnome, apache, robotics ROS …
And, of course the usual fOSSa topics (Education & Community management).

At this occasion, Sébastien Heymann will make a presentation about Motivations in Free Software communities, 6th Dec at 2pm in the Community Management track.

“What marks the difference between fOSSa and other events is the air that you breath there. An event organized by passionate people, with passionate attendees as well … and great speakers. Every year you can get some presentations of greater international events in advance (I remember the year of Arduino, to give you an example).” — Gabriele Ruffatti — SpagoWorld Blog 2012.

fOSSa days are open to everyone and registration is free!
more information @ http://fossa.inria.fr

EDIT: slides of the presentation
http://fr.slideshare.net/slideshow/embed_code/15531802

Beta Tester program starts

Hi all, today we are announcing a new program and it’s all about testing the latest versions of Gephi. Anyone can join the program and test the development version, send feedback and discuss features. We want to build a team of beta-testers who the developers can work with to detect issues before the software reaches the standard users.

So far, testing has been done by a small group of developers and users but we would like to extend it to a larger audience. There are many different versions of Windows, Mac OS X and Linux Gephi supports. Testers will help to detect compatibility issues specific on a single platform and overall participate in testing new features.

To make this effort successful, we’re making it super easy to test the latest development version without requiring to know about programming or how Gephi is built. We’re introducing a nightly build package which gets updated automatically every night with the latest version of the code. Once downloaded and installed, this version of Gephi will ask you to update itself every time a new version is available so you don’t have to download and install Gephi over and over again. If you’re already familiar with Gephi’s auto update capability, this is using the same system.

How to get started?

    1. Join the gephi-tests@lists.gephi.org mailing list

Developers and testers will discuss on this list.

    1. Fill this questionnaire online.

Cuple of questions on your hardware and software configurations.

Questions? Feel free to stop by on this forum thread.

GSoC: interconnect Gephi Graph Streaming API and GraphStream

My name is Min WU and during this Google Summer of Code I have worked on the project to interconnect Gephi Graph Streaming API and the GraphStream library. My mentors are Yoann Pigné and André Panisson.

This project aims at interconnecting the GraphStream’s dynamic graph event model with Gephi in order to have Gephi to visualize an ongoing graph evolution and measurement. Based on this project, users can model and simulate complex systems with GraphStream while observing the output with the visual tools offered by Gephi.

GraphStream is written in Java. In order to use streams of graph events in other languages, GraphStream provides the NetStream framework, i.e. a network interface, such that other projects written in other language can use GraphStream. The NetStream framework consists of three parts, receiver, sender and the NetStream Protocol. The receiver is responsible for receiving graph events from the network and dispatching them to pipes. It works within only one thread, listening at a given address and port while receiving graph events from several streams, actually several threads or clients. The sender encodes graph events into messages according to the NetStream protocol and send them to a defined receiver with given port, host and stream ID. Every message contains sourceId, timeId and event context, among which the combination of sourceId and timeId is dedicated to distinguish between several streams and solve the synchronization issue. Finally the NetStream protocol specifies the message format at byte level.

Gephi also supports the idea of “streams of graph events”. It has a framework for graph streaming in Gephi plugin built by André Panisson during the 2010 GSoC, through a multi-threaded socket server. Other applications can push graph data to the Gephi server through the network, and have it visualized. In this graph streaming project, operations (a concept similar to event) are invoked through HTTP requests made by the client to the server, based on a JSON format.

Work done

In my project, I interconnected Gephi and GraphStream based on André’s Graph Streaming plugin. Since NetStream on GraphStream side works on NetStream protocol while Graph Streaming API on Gephi side works on JSON protocol, we have to make them compatible with each other. Considering the flexible interoperability and language agnostic properties, I have chosen the JSON protocol to do the interconnection and implement a sender part and a receiver part.

The sender part (JSONSender) is responsible for sending events from GraphStream to Gephi. GrpahStream works as a client and Gephi works as a server. Every time the graph in GraphStream changes, a corresponding event is sent to Gephi. Gephi handles the event and changes its own graph. In this way, the sender part works as a sink of the GraphStream graph, so it must implement the sink interface which contains methods to deal with graph element events and attribute events. In each method, we first encode the event message into a JSON string, and then send it to Gephi. We connect to Gephi and use “updateGraph” operation to send events. The corresponding URL is “http://host:port/workspace?operation=updateGraph”. The host and port must match with the Gephi sever and the workspace is a destination workspace of Gephi, for example an URL can be “http://127.0.0.1:8080/workspace0?operation=updateGraph”. The Gephi server and client are built with the “Graph Streaming API ” in the Gephi-plugin.

The receiver part (JSONReceiver) is responsible for receiving events from Gephi. It listens to Gephi and waits for events. Every time the graph in the Gephi changes, a corresponding event will be send to GraphStream. Then the GraphStream handles the event and changes its graph object. In this way, the receiver part works as a source of the GraphStream graph. In order to listen to Gephi events, we use a URL within “getGraph” operation to connect to Gephi. The corresponding URL is “http://host:port/workspace0?operation=getGraph”.

With these two classes, we can interconnect GraphStream and Gephi in real-time. Two tutorials are given to show how to do real-time connection between GraphStream and Gephi, see the video below. If you are interested in the detail implementation, please refer to the manual page.

The first class is GraphSender, which aims at loading a graph in GraphStream and dynamically displays it on a Gephi workspace. We need to create a graph instance and a JSONSender instance, and plug the JSONSender instance as a sink of the graph instance. Since then, when we generate the graph, or load the graph from a file, Gephi will display it in real-time.

The other class is LinLogLayoutReceiver. The Lin-Log layout in GraphStream is dedicated to find communities in graphs. This tutorial shows the execution of a Lin-Log layout in GraphStream and the sending of the layout information to Gephi in real time. We first load a graph in Gephi, display it and apply some algorithms. Then we send the graph to GraphStream and apply the Lin-Log layout on the graph on the GraphStream side. Meanwhile we visualize the layout process on the Gephi side in real time. To achieve it, we create a graph instance and a JSONReceiver instance, and then get the ThreadProxyPipe instance and plug the graph instance as an ElementSink of the pipe instance. Then we apply the Lin-Log layout, and create a new thread in which to create a JSONSender instance and plugin it as a sink of the graph layout.

Distribution

This project is distributed under MIT license. You can refer to the code on Github. By the way, I feel very appreciative for my mentors’ supervision. Thank you very much!

GSoC: Legend module

My Name is Eduardo Gonzalo Espinoza Carreon and during this summer I developed the new Legend Module for Gephi, with the mentoring of Eduardo Ramos and Sébastien Heymann. This article will give you an overview of the work done.

Problem statement

Currently Gephi offers the possibility of visualizing graphs, but what about legends? Legends provide basic and extra information related to the graph and they are useful when interpreting any kind of network map. If a person is not familiar with the content of a graph, missing or wrong legends could lead to misleading interpretations and sometimes wrong decisions. When a visualization is used by multiple people for discussing, analyzing or communicating data, legends are of great importance.

For instance, the following graph represents the coappearance of characters in the novel Les Miserables. After performing a visual analysis we could only conclude that the graph has 9 groups. This is probably a little of the information the creator wanted to transmit. The graph has no information related to the number of nodes explored, or what the groups represent and how many elements each group has, etc.

A current workaround to solve this problem is to export the graph as an image, and then manually add the legends using Inkscape, Adobe Illustrator or another graphics editor. However this task is time-consuming and can be automated. The new Legend Module proposes a solution to this problem.

Solution

We propose an extension to the Preview module for generating legend items. The following legend items are available: Table, Text, Image, Groups and Description. They can be added using the Legend Manager, which is shown in a new tab under the Preview Settings:

After selecting a type of legend, the user chooses a sub-type builder, e.g. “Table” > “Partition interaction table”, or “Top 10 nodes with greatest degree”, as shown in the following figure:

When a new Legend item is added, it is displayed in the list of active legend items, where the user can edit its properties. The user can also edit its label and assign a user-friendly name to remember the content of the legend easily.

Every item has a set of common properties: label, position, width, height, background color and border, title, description; and also each type of item has its own properties and data. The values of those properties are editable through a Property Editor like the one used in the preview settings.

Some properties like scale and translation can be modified using the mouse like most of the graphic design applications. All legend items are designed with a smart way of autoresize. It’s not the common scale feature, e.g. if the text included in the Text Item is bigger than the size assigned, then the Text Renderer overrides the text font defined by the user and decreases the font size until the text is able to fit in the specified dimensions. The results of this feature are shown in the next figure:

Workflow

The legend builder retrieves the graph data (partitions, node labels, edge labels, etc) and creates a new Legend item for each of them. Then a legend renderer makes use of these information, plus the properties set by the user, to render the Legend item to the specified target: PNG, PDF or SVG.

For developers

The renderers can be extended. For instance, the default Group Renderer is:

Using external libraries like JFreeChart, we can extend it to create a Pie Chart Renderer like as follows:

Other types of items can be created by combining other available Legend Items or by extending Legend Item, Legend Item Builder and Legend Item Renderer.

The Legend Module also provides a save/load feature. So you can save your legends for future editing.

Limitations

Currently there are some limitations like selecting a specific renderer for each type of item, and also exporting legends to SVG format is not done automatically like PNG and PDF, e.g. Exporting an Image (they will be embedded in the SVG file).

Conclusions

I would like to thank Eduardo Ramos and Sébastien Heymann for their support and feedback, which was critical during the development of this new module. The Legend module will be available as core feature in next Gephi release.

This GSoC was a great opportunity to learn and it also represents my first important contribution to the open-source community.

Summer news

No rest for the community this summer! This is a digest of our activity.

New plugins:

New Web articles:

New research papers:

Monthly news

The monthly news give the important news to the people who don’t have a Twitter account or who don’t connect to it each regularly.

New plugins:

New Web articles:

New research papers:

Gexf4j, a new Java library to create GEXF files

francesco

Francesco Ficarola is a Computer Engineer and a Ph.D. student at the Sapienza University of Rome. In addition he is been working for an Italian company as R&D Engineer for one year. His main research interests are Wireless Sensor Networks, Social Networking and whatever concerns “Internet of Things”.

Gephi supports the 1.2draft of GEXF file format since version 0.8. Until now, if you are a Java developer, you couldn’t use any up-to-date Java library to manage this version of the format. The only available library for building GEXF graphs was gexf4j-core v.0.2.0-ALPHA by J. Campanini. Unfortunately that library implemented GEXF 1.1draft only, and is no longer maintained. So I have decided to update that library in order to work and build GEXF 1.2draft compliant graphs. This version introduced many improvements, see the changelog.

The latest version of gexf4j (currently 0.3.1) supports new XML attributes and data types to encode dynamic networks:

  • timeformat or spell
  • open intervals (startopen/endopen)
  • double
  • date
  • xsd:dateTime

In addition, the javadoc has been added and all methods have now meaningful names for their parameters.

Creating a GEXF file with gexf4j is very simple and requires very few lines of code: read the two examples in the project README file, or find them in the “it.uniroma1.dis.wiserver.gexf4j.examples” project package.

<!–If you have been a gexfj-core v.0.2.0-ALPHA user, you will be able to easily program with the new version. You only need to change the code a little for the dynamic features, in particular:

  • “TimeType” class has been renamed “TimeFormat”.
  • “Slice” components are renamed “Spell”, according to 1.2draft.
  • The methods “setStartDate(Date d)” and “setEndDate(d)” are changed in “setStartValue(Object o)” and “setEndValue(Object o)”, respectly, in order to support multiple timeformat type: double (default), date and xsd:dateTime.
  • The Methods “Date getStartDate()” and “Date getEndDate()” are changed in “Object getStartValue()” and “Object getEndValue()”, respectly.
  • The methods “setStartIntervalType(IntervalType startIntervalType)” and “setEndIntervalType(IntervalType endIntervalType)” have been added in order to allow the user to choose the interval type (open or close) of the “start/end” attribute.

Finally, if you would like to support this project, please let me know, you are welcome… and if you want to stay informed about the latest news on gexf4j, just follow me on Twitter: @f_ficarola

Checkout code

Run
git clone git://github.com/francesco-ficarola/gexf4j.git

Report issues

Simply go to the Issues tab.

Have a nice “GEXF graph”!

Francesco Ficarola