Google Summer Of Code 2011

From Gephi:Wiki
Revision as of 22:22, 14 April 2011 by Admin (Talk | contribs)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search
Google Summer of Code 2010 Logo

This document compiles official Gephi Google Summer of Code 2011 proposals. One can propose other ideas by going on the forum and start the discussion.

The Google Summer of Code 2011 is open!

Students, read this page to know how to start.

The GSoC timeline can be found at: http://www.google-melange.com/gsoc/events/google/gsoc2011

Students, you have until April 8 to submit your application.

Official proposals

Timeline player and movie creation

This proposal focus on the Timeline component in Gephi and how to interact with a dynamic graph.

 Difficulty: Easy
 Required skills: Java, Swing
 Assigned Mentor: Cezary Bartosiak (co-mentored by Sébastien Heymann)

Since it's 0.7 version, Gephi can explore dynamic networks through its Timeline (see screenshot) component. Users can see how a network changes over time by selecting the range in the timeline. Several new features could be added to the timeline component to dramatically improve the user experience:

  • A play feature, configure the speed and click on 'Play' to animate the network
  • A better support of dates and visual graduation.
  • A manual set of the timeline, for precision.
  • A better tooltip.

The second part of this project proposes to develop animation creation (e.g. movies) from Gephi. It's a highly awaited feature from our users. The use case is simple: load a dynamic network, configure the timeline player and the movie settings (format and compression) and Play. The result is a movie file of the animated network with a a date label.

Using the OpenGL rendering engine in Gephi, movie frames can certainly be created. Then, a solution needs to be found to create a standard and compressed movie with a decent resolution. The possibility to set up a title to the video would be a nice plus. Although the primary use of this feature is dynamic networks, it should be available for other modules.

Finally, the possibility of movie creation without an active OpenGL windows, for instance when using the Gephi Toolkit will be evaluated.

Resources:

Web-based network visualization with WebGL

This proposal offers to start a new and exciting project, a network visualization library entirely based on WebGL.

See the forum thread.

 Difficulty: Medium
 Required skills: Javascript, Open-source, Webdesign
 Assigned Mentor: Julian Bilcke

Communication about (large) graphs is currently limited because it’s not easy to put them on the web. Graph visualization is like other types of visualization (charts, Google Maps or Google Visualization API) and need powerful web support. Creating an efficient, interactive and portable library for doing that is a great challenge.

The idea is simple. People uses desktop software or scripts to visualize, manipulate and analyze large networks. Then, they would like to communicate about their findings and export the visualization on the web. There is currently no standard library that would do this job with graph larger than couple of thousands elements. Minimum interactivity should also be provided: zoom, pan, and mouse over events.

One possible good solution would be to use the new PhiloGL library, which seems a perfect fit. Data should be loaded as a standard JSON format.

An important aspect of this project is to deliver a final version with little features but with materials and documentation to make this a real open-source project. The amount of interest and possible support is very high, we just need to get started, create the project and start gathering the community.

This project would let the student get experience in Javascript and WebGL, high-level optimization and data visualization. Good communication skills are required to promote the project, write documentation and blog posts.

We suggest the following roadmap:

  • Get started with WebGL and the development environment
  • Draw a graph in a 2d space. Draw nodes as sphere, edges and labels.
  • Add interaction layer with displacement and mouse movement.
  • Create API to define a graph structure and all visual attributes that can be touched.
  • Build a simple website and start advertising the project

Resources

Preview Refactoring

This proposal focuses on simplify and modularize the Preview architecture.

See the forum thread.

 Difficulty: Hard
 Required skills: Java, Software Design, Processing
 Assigned Mentor: Christian Tominski

The Preview module is a major brick in Gephi, it has a customizable Processing-based graph rendererand supports the vectorial formats (SVG, PDF) exports. It has been originally developed for GSoC 2009 and is now in a version 1.0. The architecture is complex and make it difficult to extend with plug-ins.

A modular architecture

The aim for Preview is flexibility', not performance. Its architecture should allow developers to easily display and customize a graph, and code plug-ins. Some new and exciting features, like Edge-Bundling, could be developed much more easily when this project is complete.

What kind of plug-ins one would like to code on top of the Preview?

  • Add a new type of shape, for instance Convex hulls
  • Add new properties, for example 'node opacity'
  • Override how anything is rendered by providing a new implementation, for example nodes, adding opacity
  • Add new exporters, PNG or EPS
  • Provide complex UI for configuring properties, like current Edge Color panel
  • Execute complex algorithms before rendering

Preview API

The new preview API will be developed, to create and customize graphs easily from the developer side. The default use case is a third-party application willing to display networks in a Java Swing application using the Preview component. The Preview API should have at least the following features:

  • Read/Write graph data
  • Modify properties values
  • Get a Processing JPanel, SVG or PDF

Suggested Roadmap

The team will help the student to get started with modular architecture concepts.

  1. With the help of the mentor, start from scratch a new Processing-based renderer
  2. Develop the API and connect the module to current Gephi
  3. Add properties to the new module, these are all the options (edge thickness, colors, ...)
  4. Migrate exports
  5. Adapt UI with the new property system

Resources

New Visualization Engine

This proposal continues the work on the new visualization engine using GPU, and aims to release a feature-complete version.

See the forum thread.

 Difficulty: Medium
 Required skills: Java, Swing
 Assigned Mentor: Antonio Patriarca (co-mentored by Sébastien Heymann)

This project has been started last year during GSoC by Antonio Patriarca. He worked on a new OpenGL visualization engine using JOGL2 and the GPU. He completed a simple and efficient engine architecture design and started to implement some of the renderers. The visualization part is implemented but much more needs to be done regarding interaction and integration. Mouse events like select, click or drag must be added. In addition, new developments started in a standalone application and need to be integrated to Gephi. That requires to modify the settings management and update dependencies.

A new Visualization API will be designed, and implemented.

Antonio Patriarca is the mentor for this project and besides helping the student, will continue to work on improving the renderers during the summer.

Visualization API

This is an important part of the work, and defines how the visualization engines interact with other modules. The most essential element is events, as other modules like Tools needs to receive events when elements are selected or clicked.

  • Easy way to add event listeners (selection, click, drag)
  • Retrieve selected elements
  • Modify all settings (background color, edge thickness, fonts etc.)

Additionally, some elements should be modular, with possible other implementations:

  • Context menu actions
  • Data Provider, the module responsible for loading the data

We suggest this draft roadmap:

  • Get started with discussing with Antonio and review project current status
  • Implement interactivity (select, drag, click...)
  • Design new Visualization API and implement it
  • Integrate new visualization engine within Gephi, wire settings and event system

Resources

Indexed Attributes API using Lucene

This proposal aims to add index support to Gephi attributes system.

See the forum thread.

 Difficulty: Medium
 Required skills: Java, Lucene
 Assigned Mentor: Eduardo Ramos

Attributes are all the data related to nodes and edges and are organized in a row-column system. Columns could be any type like String or Double and rows are elements (nodes or edges). The current system is entirely loaded into memory and obviously becomes very large when manipulating large graphs with many attributes.

The aim is to use Lucene to store attributes on the disk and index them in order to be searchable. The system should have a well-designed cache system to handle heavy read access on some elements. Though the need is not as critical as the graph structure, several features in Gephi need in-memory attributes to work properly. For instance, the edge weight is an attribute read very often due to the visualization and is called a 'Property', a sub-category of Attributes. On the contrary, custom data are not constantly used, only on modules like Filters or Data Laboratory. In addition, attributes data in other workspaces than the current one should not remain in memory.

The ability to return the nodes or edges matching a particular query would be extremely useful. Gephi doesn't currently have an efficient way to search elements.

Another essential element of the desired system is the support of sets, the list of unique values for a particular column. That is what the Partition modules does, but it is very expensive to compute and refresh. The AttributesAPI would support returning all different values and the elements matching this values, for a particular column.

The AttributesAPI implementation should be modified, and the API extended if necessary. Previous work from Martin Škurla, GSoC student in 2010 can be reused. He started to work on specifications for such a system, check the wiki page below.

Gephi will sponsor the purchrase of a Lucene book if necessary.

Resources

Scripting Gephi - Porting of Gython

This is a joint proposal with the GUESS project focusing on the porting of the Gython language as a console plug-in to Gephi:

See the forum thread.

 Difficulty: Medium to Hard
 Required skills: Java, Python, Language design
 Assigned Mentor: Mathieu Bastian (co-mentored by Eytan Adar)

The GUESS project was originally created to support the interactive manipulation of graph structures. This was achieved through a visualization framework as well as a Domain Specific Language known as Gython, a backwards-compatible Python extension (implemented using Jython). A number of key features distinguish Gython from simply using Jython or Jruby:

  • Nodes and edges are treated as first class objects and instantiated in the interpreter on load. Properties of these objects can be directly accessed (e.g., node1.color)
  • Special operators support selecting edges (e.g., node1->node2 finds all directed edges from node1 to node2)
  • A SQL-like query language is inlined with the language to support the selection of node and edge sets (e.g., dept == 'human resources' grabs all nodes representing people in the human resources department)
  • Special map operations speed work with sets (e.g., (dept == 'IT').size = 20 sets all nodes in the IT department to 20 pixels)
  • Functions are available to sort and group sets (e.g., groupBy(dept) generates sets of sets)
  • Various functions (shortest path, clustering, layout, coloring, etc.) are provided as direct functions
  • Graph states to support different graph snapshots (and an animation framework to transition between them)
  • Through the use of Jython the application itself could be modified (new/custom menus, additional task specific toolbars, etc.)

Additional modifications to the console window support a coupling between the visualization and the text (e.g., brushing over node names in the console highlights them in the visual display). While GUESS is still popular due to the ability be interactively manipulate these structures, it is no longer being actively developed.

Porting

A simple port of these features would be a direct transfer of code from GUESS to an independent plug-in module that would reference Gephi objects. Specifically:

  • The GraphAPI to retrieve nodes and edges
  • The FilterAPI or custom expression builder to support the query functionality
  • Loading through the ImportAPI
  • Views to support something similar to states
  • Features such as colorizeLinear and groupBy implementing Ranking and Partition
  • Other Gephi-specific features can be folded into Gython during the implementation process

While a perfect port might not be possible due to differences in features, we believe that enough can be transferred to support most present GUESS users and enable a new interaction mechanism for Gephi users. As Gython is based on a Jython 2.1 core, a more ambitious option is to "upgrade" to a more modern version of Jython. However, this would require a more significant effort as the parsing infrastructure has changed.

Furthermore, we believe that the lessons learned from this port might enable other DSLs to be constructed (e.g., a JRuby-based DSL).

The ability to script more easily Gephi is a key-feature for the Gephi Toolkit and this porting directly address this issue.

Resources

Automated build & Maven

This proposal focuses on architecture, building and packaging. The goal is to develop automated build and fasten the release process.

See the forum thread.

 Difficulty: Easy
 Required skills: Java, Maven
 Assigned Mentor: Julian Bilcke

Gephi is a Java Desktop tool built on top of Netbeans Platform. Netbeans Platform hides a lot of complexity and can build in one step Windows executable, Mac OS X application and archives. Several more manual steps need to be done manually to achieve a complete release. We have to deal with different platforms and installers, localization and update center.

Netbeans Platform uses various Ant target to compile, build and package. A variant of NBP using Maven now exists. One goal of this project is to evaluate the benefits and drawbacks of a move to Maven and do it if its a good thing.

In addition, the Gephi Toolkit is the core of Gephi packaged as a single JAR, and is built using a custom ANT target. A more robust way to release the Toolkit would be a nice plus.

There is a big number of automated build solutions available for Java. This project will indentify the best lightweight solution to achieve an automated build of the application and the creation of installers.

Prerequisite for the student:

  • Interest in open-source environment, tools, software architecture
  • Willing to dive into the Gephi platform, and learn from the community

Suggested roadmap

  • Convert the current Netbeans Platform to Maven if necessary, and setup the repository
  • Look for the best automated build solution
  • Deploy the automated build solution and port existing steps to it
  • Explain to members of the community how to use the new system, by updating the documentation

Ressources:

Related resources

Previous GSoC