See: Description
| Package | Description |
|---|---|
| org.gephi.appearance.api |
API for manipulating element appearance.
|
| org.gephi.appearance.spi |
Interfaces that define the different ways the appearance of elements can
be transformed.
|
| org.gephi.datalab.api |
Data Laboratory API, all capabilites are exposed through various controllers.
|
| org.gephi.datalab.api.datatables | |
| org.gephi.datalab.spi |
Interfaces for creating data laboratory plugins.
|
| org.gephi.datalab.spi.columns | |
| org.gephi.datalab.spi.columns.merge | |
| org.gephi.datalab.spi.edges | |
| org.gephi.datalab.spi.general | |
| org.gephi.datalab.spi.nodes | |
| org.gephi.datalab.spi.rows.merge | |
| org.gephi.datalab.spi.values | |
| org.gephi.filters.api |
API for graph filtering.
|
| org.gephi.filters.spi |
Interfaces for creating new filter classes.
|
| org.gephi.graph.api |
Complete API description, where
GraphModel is the entry point. |
| org.gephi.graph.api.types |
Custom types the API supports, in addition of primitive and arrays.
|
| org.gephi.graph.spi |
SPI interfaces clients can implement to extend the API.
|
| org.gephi.io.exporter.api |
API for exporting data to any support.
|
| org.gephi.io.exporter.spi |
Interfaces for creating new data exporters.
|
| org.gephi.io.generator.api |
API for executing graph generators in a backgorund thread.
|
| org.gephi.io.generator.spi |
Generator interfaces that plugins implement to add new generators.
|
| org.gephi.io.importer.api |
API for importing data from any support.
|
| org.gephi.io.importer.spi |
Interfaces for creating new data importers.
|
| org.gephi.io.processor.spi |
Interfaces that define the way data are unloaded from container and
appened to the workspace.
|
| org.gephi.layout.api |
API for real-time layout algorithm tasks and proper user control.
|
| org.gephi.layout.spi |
Interfaces for creating new layout algorithms.
|
| org.gephi.perspective.api |
API for perspective management.
|
| org.gephi.perspective.spi |
Interfaces for creating new perspectives and perspective members.
|
| org.gephi.preview.api |
API for Preview rendering.
|
| org.gephi.preview.spi |
Interfaces for creating new renderers, item builders and render targets.
|
| org.gephi.preview.types |
Additional property types.
|
| org.gephi.preview.types.editors |
Standard beans property editors for preview types.
|
| org.gephi.project.api |
API for project and workspace management.
|
| org.gephi.project.spi |
SPI for workspace capabilities and project managment UI.
|
| org.gephi.statistics.api |
API for statistics and metrics tasks execution.
|
| org.gephi.statistics.spi |
Interfaces for creating new statistics and metrics algorihms.
|
| org.gephi.timeline.api |
API which controls the Timeline, the UI component which allows network
exploration over time.
|
| org.gephi.tools.api |
API for selecting the current Tool.
|
| org.gephi.tools.spi |
Interfaces for creating new tools.
|
| org.gephi.utils.longtask.api |
API any module can use for providing long, asynchronous tasks execution.
|
| org.gephi.utils.longtask.spi |
LongTask adds functionalities to any class that wants to be progressable and
cancellable.
|
| org.gephi.utils.progress |
Progress support for long tasks execution.
|
This documents provides Gephi APIs documentation and gives details about current status of each API. Each API is categorized by it's stability: stable, under development or deprecated.
DynamicAPI have either been replaced by native GraphAPI support or added to the TimelineAPI, effectively removing DynamicAPI from the codebase. The TimeFormat can be set via setTimeFormat() on GraphModel. Estimators are now configurable per column and can directly be set from the Column. Obtaining the minimum time bounds can now be obtained from the TimeIndex directly from GraphModel.createQuery() method in FilterController now takes a FilterBuilder instead of a Filter. It allows to track down builders down to the query level.ImportAPI now supports importing multiple graphs at the time and supports graph slices through an additional parameter on ContainerLoader. The setTimestamp() and setInterval() allows to define a point or period of existence for the entire graph. The ImportController also allow multiple containers to be processed through a new process() method. In parallel, ImporterUI now takes multiple importers and so does the Processor interface that now takes multiple containes.NodeFilter and EdgeFilter interfaces now inherit from a new ElementFilter so it's easier to create filters that work at the element level.filter() method in Operator now takes an array of Subgraph instead of Graph. This gives access to operations such as union or not.ClusteringAPI from codebase. It needs a complete rewrite.setTimeZone() on ContainerLoader in ImportAPI.ContainerFactory class in ImportAPI and replace it with Container.Factory. Also add the ability to configure the TimeRepresentation in ContainerLoader. Finally, add color parsing utility in ImportUtils. It can be used to parse color names or codes.AttributeModel parameter in the execute() method of Statistics interface in StatisticsAPI has been removed as all features are now in GraphModel.ChangeListener in WorkspaceInformation has been replaced with a PropertyChangeListener.RankingAPI and PartitionAPI have been replaced by a new AppearanceAPI, which supports both concepts. The SPI allows to create Transformer services, which can support either ranking or partition transformations. Ranking and Partition instances are defined in the API and gives access to underlying data. The core concept in appearance are functions, which wrap the transformation entirely and can be accessed in AppearanceModel.PreviewAPI has been removed and replaced by regular Java2D. Therefore, the ProcessingTarget is now the G2DTarget. Also add a resize() method to facilitate integration.EdgeWeightMergeStrategy enum to control the way parallel edge weights are merged in ImportAPI.WorkspacePersistenceProvider with a new SPI interface: WorkspaceBytesPersistenceProvider. The XML-based interfce has being renamed into WorkspaceXMLPersistenceProvider.setValueString() method on ElementDraft. This will automatically parse the value based on the declared type reducing parsing code on the importer side. If the type is already in the right type, use the setValue() instead.ColumnDraft interface which represents a to-be-created column and the method to manipulate them in ContainerLoader. The NodeDraft and EdgeDraft classes now inherits from a new ElementDraft, centralizing a lot of the code. The EdgeDraftGetter and NodeDraftGetter have been removed and their methods moved directly to the node/edge draft. New elements are now created using the ElementDraft.Factory, which can be obtained with the factory() method on ContainerLoader. Previously the ContainerUnloader returned an AttributeModel. This has been replaced with iterables over column drafts. The EdgeDefault enum becomes EdgeDiretionDefault and represents a graph-level configuration. The EdgeDefault is now edge-level configuration and can be set by setEdgeDirection() on EdgeDraft. Finally, convenient setColor() methods have been added to ElementDraft.GraphAPI and add GraphStore as dependency. The new API is entirely defined in the GraphStore project and Gephi makes it available through the GraphAPI. The AttributesAPI functionalities have been consolidated into the new graph API and therefore has been removed. There is too many API changes to be listed all but notable ones are the following.GraphModel, and there's no more AttributeModel.AttributeColumn is renamed into Column, the AttributeTable is renamed into Table, AttributeOrigin is renamed into Origin and the AttributeType has been replaced by the direct usage of Class objects. Moreover, the AttributeUtils is now entirely static (i.e. no more needed to obtain an instance) and has multiple important additions such as full parse support.GraphModel.addEdgeType().getAttribute() methods. All properties such as color or position are also accessible directly on the Node/Edge interfaces.Configuration (must be done at initialization). The way elements' existence overtime has been greatly simplified with the addition of timestamp/interval management methods on Element, which both Node and Edge extends. See for instance addTimestamp(), addInterval(), getTimestamps() or getIntervals(). Similarly, each attribute getter or setter in Element is available with timestamps and intervals parameters so attribute values over time can be configured. Behind the scenes, the dynamic types used are defined in org.gephi.graph.api.types.Subgraph interface that extends Graph and is available from GraphModel.getGraph(GraphView). This subgraph interface has additional features such as union() or intersection().GraphListener has been entirely replaced with a pull-based system of observers. The system no longer sends events at each update but listeners can create observers, which periodically check if something has changed. There's multiple types of observers: GraphObserver for topology changes, TableObserver for new/removed columns and ColumnObserver for attribute value changes. These observers can obtain diff objects such as GraphDiff or TableDiff to exactly obtain what has changed.PreviewMouseListener and implement MouseResponsiveRenderer interface in the renderers that use the listener.
getShortDescription() method to the StatisticsUI API. It enables to get a short description of statistics (used to display tooltips).
needsItemBuilder method to Renderer in Preview API.
This helps to avoid building unnecessary items while refreshing preview.
getDisplayName method to Renderer and support for extending default preview renderers.PreviewModel and PreviewController.:RankingController.RangeFilter interface in Filters API to help create range filters. The filter system now automatically
manage the range values and bounds. The Range object now also supports exclusive intervals.AttributableFilter filter type. This is useful for filters manipulating Attributable
objects regardless whether they belong to a node or edge. Also note new useful abstract plugin implementations have been added to
the FiltersPlugin module. Use AbstractFilter for any filter and AbstractAttributeFilter for
filters based on attributes. Filter builders are also provided.PerspectiveMember SPI has to go
away and will break compatibility. Top components now directly declare the perspective they belong to in the
@TopComponent.Registration annotation, for instance roles = {"overview"} for the Overview perspective.REPLACE_COLUMN event type in AttributeEvent.
TIME_FORMAT event in DynamicModelEvent. The event is triggered when the time format
is initialized.PerspectiveAPI module and move API/SPI interfaces from the DesktopPerspective
module. Add a PerspectiveController to find and manage perspectives.getGraphTable() in the AttributeModel. The GraphView elements
can also have attributes using the same system as nodes and egdes. The data can be accessed through the Graph.getAttributes()
method.
DesktopPerspective SPI. Modules willing to declare a panel part of a perspective
should implement the PerspectiveMember interface. The interface now asks for the TopComponent's ID.
DynamicStatistics SPI in the StatisticsAPI module. The interface extends Statistics
and implement the calculation of metrics over time.
ADD_NODES and ADD_EDGES are merged
into a ADD_NODES_AND_EDGES event. Similarly REMOVE_NODES and REMOVE_EDGES are merged into a
REMOVE_NODES_AND_EDGES event. GraphEventData remains the same and still contains both added/removed nodes and
edges. Users may simply test if arrays returned by addedNodes(), addedEdges(), removedNodes() and
removedEdges() are null before using them.
executeLayout(numIterations) method in LayoutController.
StatisticsController now supports synchronous algorithm execution through the execute(Statistics)
method.startAutoTransform() and stopAutoTransform() in Ranking API to control auto transformations.
The model also allows to retrieve the ranking used in the auto transformation. An additional refreshRanking() method has been added
in the RankingBuilder SPI for a smoother auto transformation support.AttributeRowsMergeStrategy interface to Data Laboratory API. This is a type of manipulator that defines
and strategy for merging values of a row (node or edge) for an specific column. It should be used by other manipulators such as
NodesManipulator MergeNodesgetNodeRanking() and getEdgeRanking in the model, we
introduce the concept of element type and generalize methods to it. Use Ranking.NODE_ELEMENT to obtain a node
ranking and Ranking.EDGE_ELEMENT for an edge ranking. Same idea for transformers, which are now defined by a unique name.
Default transformers' name can be found in the Transformer interface. A RankingEvent has also been created.
API users have to update to their client code to be compatible.Attributable. That allows to manipulate objects with attributes
regardless if the object is a node or an edge. Node, Edge, NodeData and EdgeData now
now implements this interface, and a getAttributes() method has been added to Node and Edge to
make development easier.setCurrentQuery() method on FilterController.WorkspacePersistenceProvider interface
from ProjectAPI now uses StAX instead of DOM. The writeXML() method now uses XMLStreamWriter and readXML()
XMLStreamReader. Backward compatibility can't be assured, modules have to use switch to StAX.
NodesManipulator and EdgesManipulator). Also now Visualization API has an SPI for adding context menu actions
(GraphContextMenuItem) to nodes like DataLaboratory does with NodesManipulator. Note that they share the interface
ContextMenuItemManipulator from Data Laboratory API, so they are compatible, being able to reuse actions on nodes for Overview and Data Laboratory.
removeMetaEdge(Edge) to manually remove meta edges. Add getTotalEdgeCount() method
to globally count the number of edges, regardless if the edge is proper or meta.
getEdgesAndMetaEdges(Node) and
getTotalDegree(Node) methods, as well as their in and out variants for HierarchicalDirectedGraph.
flatten() method to HierarchicalGraph to flatten the hierarchical graph and transform
meta edges into regular edges.
destroy(Filter filter) in FilterBuilder to receive notification when a filter
query is removed and clean-up.
MetaEdgeBuilder in Graph SPI to allow custom builders. Add GraphSettings.setMetaEdgeBuilder()
in the graph model settings.
StatisticsModel to store reports directly instead of Statistics instance. As a
consequence, the model has now a getReport() and a getResult() method that UI can use. The currently
running statistics can now be get with a new getRunning() method.
AttributeModel instead of AttributeTable and will receive events for all tables. Refactoring of the
AttributeEvent class with AttributeTable as source and a new AttributeEventData object as data.
A new SET_VALUE has been implemented for getting events when attribute values are set.
AttributeRowFactory, the newNodeRow() method now takes the owner object
NodeData as a parameter. Similarly for newEdgeRow() and newRowForTable().
getEdge(Node, Node) in GraphAPI for consistency reasons.
Processor has now setters instead of a process() method
with parameters. How processors are created remains the same. Creation of a ProcessorUI interface for processors settings
configuration. A ProcessorUI implementation provides a panel, which is shown when the import report is closing. The
ProcessorUI also allows to disable a processor with some conditions.
getColor() method in NodeDraft and EdgeDraft.
TopComponent that belong to a perspective. Plugins can implement
PerspectiveMember to define the open and close behaviour.
AbstractList.
addAttributeValue() method in NodeDraft and EdgeDraft. For improving data
cleanup possibilities, NodeDraftGetter and EdgeDraftgetter now returns an AttributeRow
instead of a list of attribute values only. Finally to profit from latest improvements, draft elements returns directly a
TimeInterval type instead of the list of slices. Methods with 'Slice' have been renamed to 'Interval' for
consistency reasons.
DynamicType
GraphEvent has now precise events, including
ADD_NODES, REMOVE_NODES, ADD_EDGES, REMOVE_EDGES and
VISIBLE_VIEW. A new GraphEventData interface has been created to retrieve elements related to
the events.
ExporterBuilder interface for
exporter creation and different exporters: GraphExporter, VectorExporter, ByteExporter
and CharacterExporter that covers common cases. The way exporters write data has been rationalized by using either
java.io.Writer (text) or java.io.OutputStream (byte). The ExportController has been improved
to support all use-cases, including file, writer and stream export.
DatabaseImporter, the
SpigotImporter interface is a new type of Importers. Modifications have also be made to the
ImportController to support spigot import.
ImporterBuilder interface has been created and should be registered with the @ServiceProvider
annotation. The various importers types have been simplified and leave more choice to the implementations about how the
input is managed. XML and Text file importers has been merged in a FileImporter interface, working with the
java.io.Reader. Utility static methods, for instance get Document from Reader can now be found in a new
ImportUtils class. The ImportController has been simplified for File import and now accepts
java.io.Reader also. The main improvement on these modules in the support of UI components for importers.
The aim is to let importers define an ImporterUI implementation to manage settings of these importers.
Graph:
Graph.setId(Node, String)Graph.setId(Edge, String)Graph.getNode(String)Graph.getEdge(String)NodeData.setId() and EdgeData.setId() methods have been removed, compatibility can't be kept.
Factory has also be changed to allow to create elements with String ID directly, as it's not possible anymore to
do it from NodeData.
AttributeTable
has been replaced by a more traditional event management system, with new AttributeEvent and
AttributeListener interfaces. The dispatch implementation is also now on a separate thread.
ImportController is now
doing import task only and a new ImportControllerUI is displaying the user interface (Report Panel). The
ImportControllerUI interface is located in the DesktopProject module and should be user to properly
import file from Plugins. The ImportController methods could be used from the toolkit.
doImport() method in ImportController that accepts
InputStream. In ImportAPI also, add getWeight() in EdgeDraft to let importers
increment weight. New AttributeUtils methods. Progress in GraphAPI and ImportAPI documentation.
TimeIntervalMin
and TimeIntervalMax. Changes in GraphAPI about elements counting. Henceforth only enabled elements are counted,
in node and edge counting, but also in degree methods. This counting is more logical, as it match with the
number of elements returned by getNodes() and getEdges().
Copyright © 2007–2015 Gephi Consortium. All rights reserved.