Examples with BendFactory org.cytoscape.view.presentation.property.values.BendFactory used on opensource projects

Example 1 with BendFactory

use of org.cytoscape.view.presentation.property.values.BendFactory in project cytoscape-impl by cytoscape.

the class CyActivator method startPresentationImpl.

private void startPresentationImpl(final BundleContext bc, final CyServiceRegistrar serviceRegistrar) {
    DVisualLexicon dVisualLexicon = new DVisualLexicon(cgManager);
    NVLTFActionSupport nvltfActionSupport = new NVLTFActionSupport(serviceRegistrar);
    ViewTaskFactoryListener vtfListener = new ViewTaskFactoryListener(nvltfActionSupport);
    AnnotationFactoryManager annotationFactoryManager = new AnnotationFactoryManager();
    AnnotationManager annotationManager = new AnnotationManagerImpl(serviceRegistrar);
    DingGraphLOD dingGraphLOD = new DingGraphLOD(serviceRegistrar);
    registerService(bc, dingGraphLOD, PropertyUpdatedListener.class, new Properties());
    DingGraphLODAll dingGraphLODAll = new DingGraphLODAll();
    HandleFactory handleFactory = new HandleFactoryImpl();
    registerService(bc, handleFactory, HandleFactory.class, new Properties());
    DingRenderingEngineFactory dingRenderingEngineFactory = new DingRenderingEngineFactory(dVisualLexicon, vtfListener, annotationFactoryManager, dingGraphLOD, handleFactory, serviceRegistrar);
    DingNavigationRenderingEngineFactory dingNavigationRenderingEngineFactory = new DingNavigationRenderingEngineFactory(serviceRegistrar, dVisualLexicon);
    DingRenderingEngineFactory dingVisualStyleRenderingEngineFactory = new DingVisualStyleRenderingEngineFactory(dVisualLexicon, vtfListener, annotationFactoryManager, dingGraphLOD, handleFactory, serviceRegistrar);
    DingThumbnailRenderingEngineFactory dingThumbnailRenderingEngineFactory = new DingThumbnailRenderingEngineFactory(dVisualLexicon, serviceRegistrar);
    AddEdgeNodeViewTaskFactoryImpl addEdgeNodeViewTaskFactory = new AddEdgeNodeViewTaskFactoryImpl(serviceRegistrar);
    ContinuousMappingCellRendererFactory continuousMappingCellRendererFactory = getService(bc, ContinuousMappingCellRendererFactory.class);
    // Object Position Editor
    ObjectPositionValueEditor objectPositionValueEditor = new ObjectPositionValueEditor();
    ObjectPositionEditor objectPositionEditor = new ObjectPositionEditor(objectPositionValueEditor, continuousMappingCellRendererFactory, serviceRegistrar);
    DingViewModelFactory dingNetworkViewFactory = new DingViewModelFactory(dVisualLexicon, vtfListener, annotationFactoryManager, dingGraphLOD, handleFactory, serviceRegistrar);
    DingRenderer renderer = DingRenderer.getInstance();
    renderer.registerNetworkViewFactory(dingNetworkViewFactory);
    renderer.registerRenderingEngineFactory(NetworkViewRenderer.DEFAULT_CONTEXT, dingRenderingEngineFactory);
    renderer.registerRenderingEngineFactory(NetworkViewRenderer.BIRDS_EYE_CONTEXT, dingNavigationRenderingEngineFactory);
    renderer.registerRenderingEngineFactory(NetworkViewRenderer.VISUAL_STYLE_PREVIEW_CONTEXT, dingVisualStyleRenderingEngineFactory);
    renderer.registerRenderingEngineFactory(NetworkViewRenderer.THUMBNAIL_CONTEXT, dingThumbnailRenderingEngineFactory);
    registerService(bc, renderer, NetworkViewRenderer.class, new Properties());
    // Edge Bend editor
    EdgeBendValueEditor edgeBendValueEditor = new EdgeBendValueEditor(dingNetworkViewFactory, dingRenderingEngineFactory, serviceRegistrar);
    EdgeBendEditor edgeBendEditor = new EdgeBendEditor(edgeBendValueEditor, continuousMappingCellRendererFactory, serviceRegistrar);
    Properties dingRenderingEngineFactoryProps = new Properties();
    dingRenderingEngineFactoryProps.setProperty(ID, "ding");
    registerAllServices(bc, dingRenderingEngineFactory, dingRenderingEngineFactoryProps);
    Properties dingNavigationRenderingEngineFactoryProps = new Properties();
    dingNavigationRenderingEngineFactoryProps.setProperty(ID, "dingNavigation");
    registerAllServices(bc, dingNavigationRenderingEngineFactory, dingNavigationRenderingEngineFactoryProps);
    Properties addEdgeNodeViewTaskFactoryProps = new Properties();
    addEdgeNodeViewTaskFactoryProps.setProperty(PREFERRED_ACTION, "Edge");
    addEdgeNodeViewTaskFactoryProps.setProperty(PREFERRED_MENU, NODE_ADD_MENU);
    addEdgeNodeViewTaskFactoryProps.setProperty(TITLE, "Edge");
    addEdgeNodeViewTaskFactoryProps.setProperty(MENU_GRAVITY, "0.1");
    registerService(bc, addEdgeNodeViewTaskFactory, NodeViewTaskFactory.class, addEdgeNodeViewTaskFactoryProps);
    Properties dVisualLexiconProps = new Properties();
    dVisualLexiconProps.setProperty(ID, "ding");
    registerService(bc, dVisualLexicon, VisualLexicon.class, dVisualLexiconProps);
    final Properties positionEditorProp = new Properties();
    positionEditorProp.setProperty(ID, "objectPositionValueEditor");
    registerService(bc, objectPositionValueEditor, ValueEditor.class, positionEditorProp);
    final Properties objectPositionEditorProp = new Properties();
    objectPositionEditorProp.setProperty(ID, "objectPositionEditor");
    registerService(bc, objectPositionEditor, VisualPropertyEditor.class, objectPositionEditorProp);
    registerAllServices(bc, edgeBendValueEditor, new Properties());
    registerService(bc, edgeBendEditor, VisualPropertyEditor.class, new Properties());
    Properties dingNetworkViewFactoryServiceProps = new Properties();
    registerService(bc, dingNetworkViewFactory, CyNetworkViewFactory.class, dingNetworkViewFactoryServiceProps);
    // Annotations
    registerServiceListener(bc, annotationFactoryManager::addAnnotationFactory, annotationFactoryManager::removeAnnotationFactory, AnnotationFactory.class);
    registerService(bc, annotationManager, AnnotationManager.class, new Properties());
    // Arrow
    AnnotationFactory<?> arrowAnnotationFactory = new ArrowAnnotationFactory(serviceRegistrar);
    Properties arrowFactory = new Properties();
    arrowFactory.setProperty("type", "ArrowAnnotation.class");
    registerService(bc, arrowAnnotationFactory, AnnotationFactory.class, arrowFactory);
    AddArrowTaskFactory addArrowTaskFactory = new AddArrowTaskFactory(arrowAnnotationFactory);
    Properties addArrowTaskFactoryProps = new Properties();
    addArrowTaskFactoryProps.setProperty(PREFERRED_ACTION, "NEW");
    addArrowTaskFactoryProps.setProperty(PREFERRED_MENU, NETWORK_ADD_MENU);
    addArrowTaskFactoryProps.setProperty(MENU_GRAVITY, "1.2");
    addArrowTaskFactoryProps.setProperty(TITLE, "Arrow Annotation");
    registerService(bc, addArrowTaskFactory, NetworkViewLocationTaskFactory.class, addArrowTaskFactoryProps);
    // Image annotation
    AnnotationFactory<?> imageAnnotationFactory = new ImageAnnotationFactory(serviceRegistrar);
    Properties imageFactory = new Properties();
    imageFactory.setProperty("type", "ImageAnnotation.class");
    registerService(bc, imageAnnotationFactory, AnnotationFactory.class, imageFactory);
    AddAnnotationTaskFactory addImageTaskFactory = new AddAnnotationTaskFactory(imageAnnotationFactory);
    Properties addImageTaskFactoryProps = new Properties();
    addImageTaskFactoryProps.setProperty(PREFERRED_ACTION, "NEW");
    addImageTaskFactoryProps.setProperty(PREFERRED_MENU, NETWORK_ADD_MENU);
    addImageTaskFactoryProps.setProperty(MENU_GRAVITY, "1.3");
    addImageTaskFactoryProps.setProperty(TITLE, "Image Annotation");
    registerService(bc, addImageTaskFactory, NetworkViewLocationTaskFactory.class, addImageTaskFactoryProps);
    // Shape annotation
    AnnotationFactory<?> shapeAnnotationFactory = new ShapeAnnotationFactory(serviceRegistrar);
    Properties shapeFactory = new Properties();
    shapeFactory.setProperty("type", "ShapeAnnotation.class");
    registerService(bc, shapeAnnotationFactory, AnnotationFactory.class, shapeFactory);
    AddAnnotationTaskFactory addShapeTaskFactory = new AddAnnotationTaskFactory(shapeAnnotationFactory);
    Properties addShapeTaskFactoryProps = new Properties();
    addShapeTaskFactoryProps.setProperty(PREFERRED_ACTION, "NEW");
    addShapeTaskFactoryProps.setProperty(PREFERRED_MENU, NETWORK_ADD_MENU);
    addShapeTaskFactoryProps.setProperty(MENU_GRAVITY, "1.4");
    addShapeTaskFactoryProps.setProperty(TITLE, "Shape Annotation");
    registerService(bc, addShapeTaskFactory, NetworkViewLocationTaskFactory.class, addShapeTaskFactoryProps);
    // Text annotation
    AnnotationFactory<?> textAnnotationFactory = new TextAnnotationFactory(serviceRegistrar);
    Properties textFactory = new Properties();
    textFactory.setProperty("type", "TextAnnotation.class");
    registerService(bc, textAnnotationFactory, AnnotationFactory.class, textFactory);
    AddAnnotationTaskFactory addTextTaskFactory = new AddAnnotationTaskFactory(textAnnotationFactory);
    Properties addTextTaskFactoryProps = new Properties();
    addTextTaskFactoryProps.setProperty(PREFERRED_ACTION, "NEW");
    addTextTaskFactoryProps.setProperty(MENU_GRAVITY, "1.5");
    addTextTaskFactoryProps.setProperty(PREFERRED_MENU, NETWORK_ADD_MENU);
    addTextTaskFactoryProps.setProperty(TITLE, "Text Annotation");
    registerService(bc, addTextTaskFactory, NetworkViewLocationTaskFactory.class, addTextTaskFactoryProps);
    // Bounded Text annotation
    AnnotationFactory<?> boundedAnnotationFactory = new BoundedTextAnnotationFactory(serviceRegistrar);
    Properties boundedFactory = new Properties();
    boundedFactory.setProperty("type", "BoundedTextAnnotation.class");
    registerService(bc, boundedAnnotationFactory, AnnotationFactory.class, boundedFactory);
    AddAnnotationTaskFactory addBoundedTextTaskFactory = new AddAnnotationTaskFactory(boundedAnnotationFactory);
    Properties addBoundedTextTaskFactoryProps = new Properties();
    addBoundedTextTaskFactoryProps.setProperty(PREFERRED_ACTION, "NEW");
    addBoundedTextTaskFactoryProps.setProperty(MENU_GRAVITY, "1.6");
    addBoundedTextTaskFactoryProps.setProperty(PREFERRED_MENU, NETWORK_ADD_MENU);
    addBoundedTextTaskFactoryProps.setProperty(TITLE, "Bounded Text Annotation");
    registerService(bc, addBoundedTextTaskFactory, NetworkViewLocationTaskFactory.class, addBoundedTextTaskFactoryProps);
    AnnotationFactory<?> groupAnnotationFactory = new GroupAnnotationFactory(serviceRegistrar);
    Properties groupFactory = new Properties();
    groupFactory.setProperty("type", "GroupAnnotation.class");
    registerService(bc, groupAnnotationFactory, AnnotationFactory.class, groupFactory);
    // Annotation edit
    EditAnnotationTaskFactory editAnnotationTaskFactory = new EditAnnotationTaskFactory();
    Properties editAnnotationTaskFactoryProps = new Properties();
    editAnnotationTaskFactoryProps.setProperty(PREFERRED_ACTION, "NEW");
    editAnnotationTaskFactoryProps.setProperty(MENU_GRAVITY, "2.0");
    editAnnotationTaskFactoryProps.setProperty(PREFERRED_MENU, NETWORK_EDIT_MENU);
    editAnnotationTaskFactoryProps.setProperty(TITLE, "Modify Annotation");
    registerService(bc, editAnnotationTaskFactory, NetworkViewLocationTaskFactory.class, editAnnotationTaskFactoryProps);
    MoveAnnotationTaskFactory moveAnnotationTaskFactory = new MoveAnnotationTaskFactory();
    Properties moveAnnotationTaskFactoryProps = new Properties();
    moveAnnotationTaskFactoryProps.setProperty(PREFERRED_ACTION, "NEW");
    moveAnnotationTaskFactoryProps.setProperty(MENU_GRAVITY, "2.1");
    moveAnnotationTaskFactoryProps.setProperty(PREFERRED_MENU, NETWORK_EDIT_MENU);
    moveAnnotationTaskFactoryProps.setProperty(TITLE, "Move Annotation");
    registerService(bc, moveAnnotationTaskFactory, NetworkViewLocationTaskFactory.class, moveAnnotationTaskFactoryProps);
    LayerAnnotationTaskFactory moveTFAnnotationTaskFactory = new LayerAnnotationTaskFactory(-10000);
    Properties moveTFAnnotationTaskFactoryProps = new Properties();
    moveTFAnnotationTaskFactoryProps.setProperty(PREFERRED_ACTION, "NEW");
    moveTFAnnotationTaskFactoryProps.setProperty(MENU_GRAVITY, "3.1");
    moveTFAnnotationTaskFactoryProps.setProperty(PREFERRED_MENU, NETWORK_EDIT_MENU + ".Reorder Annotations[2.2]");
    moveTFAnnotationTaskFactoryProps.setProperty(TITLE, "Move Annotation To Front");
    registerService(bc, moveTFAnnotationTaskFactory, NetworkViewLocationTaskFactory.class, moveTFAnnotationTaskFactoryProps);
    LayerAnnotationTaskFactory moveFAnnotationTaskFactory = new LayerAnnotationTaskFactory(-1);
    Properties moveFAnnotationTaskFactoryProps = new Properties();
    moveFAnnotationTaskFactoryProps.setProperty(PREFERRED_ACTION, "NEW");
    moveFAnnotationTaskFactoryProps.setProperty(MENU_GRAVITY, "3.2");
    moveFAnnotationTaskFactoryProps.setProperty(PREFERRED_MENU, NETWORK_EDIT_MENU + ".Reorder Annotations[2.2]");
    moveFAnnotationTaskFactoryProps.setProperty(TITLE, "Move Annotation Forwards");
    registerService(bc, moveFAnnotationTaskFactory, NetworkViewLocationTaskFactory.class, moveFAnnotationTaskFactoryProps);
    LayerAnnotationTaskFactory moveBAnnotationTaskFactory = new LayerAnnotationTaskFactory(1);
    Properties moveBAnnotationTaskFactoryProps = new Properties();
    moveBAnnotationTaskFactoryProps.setProperty(PREFERRED_ACTION, "NEW");
    moveBAnnotationTaskFactoryProps.setProperty(MENU_GRAVITY, "3.3");
    moveBAnnotationTaskFactoryProps.setProperty(PREFERRED_MENU, NETWORK_EDIT_MENU + ".Reorder Annotations[2.2]");
    moveBAnnotationTaskFactoryProps.setProperty(TITLE, "Move Annotation Backwards");
    registerService(bc, moveBAnnotationTaskFactory, NetworkViewLocationTaskFactory.class, moveBAnnotationTaskFactoryProps);
    LayerAnnotationTaskFactory moveTBAnnotationTaskFactory = new LayerAnnotationTaskFactory(10000);
    Properties moveTBAnnotationTaskFactoryProps = new Properties();
    moveTBAnnotationTaskFactoryProps.setProperty(PREFERRED_ACTION, "NEW");
    moveTBAnnotationTaskFactoryProps.setProperty(MENU_GRAVITY, "3.4");
    moveTBAnnotationTaskFactoryProps.setProperty(PREFERRED_MENU, NETWORK_EDIT_MENU + ".Reorder Annotations[2.2]");
    moveTBAnnotationTaskFactoryProps.setProperty(TITLE, "Move Annotation To Back");
    moveTBAnnotationTaskFactoryProps.setProperty(INSERT_SEPARATOR_AFTER, "true");
    registerService(bc, moveTBAnnotationTaskFactory, NetworkViewLocationTaskFactory.class, moveTBAnnotationTaskFactoryProps);
    ChangeAnnotationCanvasTaskFactory pullAnnotationTaskFactory = new ChangeAnnotationCanvasTaskFactory(Annotation.FOREGROUND);
    Properties pullAnnotationTaskFactoryProps = new Properties();
    pullAnnotationTaskFactoryProps.setProperty(PREFERRED_ACTION, "NEW");
    pullAnnotationTaskFactoryProps.setProperty(MENU_GRAVITY, "3.5");
    pullAnnotationTaskFactoryProps.setProperty(PREFERRED_MENU, NETWORK_EDIT_MENU + ".Reorder Annotations[2.2]");
    pullAnnotationTaskFactoryProps.setProperty(TITLE, "Pull Annotation to Foreground Canvas");
    registerService(bc, pullAnnotationTaskFactory, NetworkViewLocationTaskFactory.class, pullAnnotationTaskFactoryProps);
    ChangeAnnotationCanvasTaskFactory pushAnnotationTaskFactory = new ChangeAnnotationCanvasTaskFactory(Annotation.BACKGROUND);
    Properties pushAnnotationTaskFactoryProps = new Properties();
    pushAnnotationTaskFactoryProps.setProperty(PREFERRED_ACTION, "NEW");
    pushAnnotationTaskFactoryProps.setProperty(MENU_GRAVITY, "3.6");
    pushAnnotationTaskFactoryProps.setProperty(PREFERRED_MENU, NETWORK_EDIT_MENU + ".Reorder Annotations[2.2]");
    pushAnnotationTaskFactoryProps.setProperty(TITLE, "Push Annotation to Background Canvas");
    registerService(bc, pushAnnotationTaskFactory, NetworkViewLocationTaskFactory.class, pushAnnotationTaskFactoryProps);
    ResizeAnnotationTaskFactory resizeAnnotationTaskFactory = new ResizeAnnotationTaskFactory();
    Properties resizeAnnotationTaskFactoryProps = new Properties();
    resizeAnnotationTaskFactoryProps.setProperty(PREFERRED_ACTION, "NEW");
    resizeAnnotationTaskFactoryProps.setProperty(MENU_GRAVITY, "2.3");
    resizeAnnotationTaskFactoryProps.setProperty(PREFERRED_MENU, NETWORK_EDIT_MENU);
    resizeAnnotationTaskFactoryProps.setProperty(TITLE, "Resize Annotation");
    registerService(bc, resizeAnnotationTaskFactory, NetworkViewLocationTaskFactory.class, resizeAnnotationTaskFactoryProps);
    // Annotation delete
    RemoveAnnotationTaskFactory removeAnnotationTaskFactory = new RemoveAnnotationTaskFactory();
    Properties removeAnnotationTaskFactoryProps = new Properties();
    removeAnnotationTaskFactoryProps.setProperty(PREFERRED_ACTION, "NEW");
    removeAnnotationTaskFactoryProps.setProperty(MENU_GRAVITY, "1.1");
    removeAnnotationTaskFactoryProps.setProperty(PREFERRED_MENU, NETWORK_DELETE_MENU);
    removeAnnotationTaskFactoryProps.setProperty(TITLE, "Annotation");
    registerService(bc, removeAnnotationTaskFactory, NetworkViewLocationTaskFactory.class, removeAnnotationTaskFactoryProps);
    // Annotation select
    SelectAnnotationTaskFactory selectAnnotationTaskFactory = new SelectAnnotationTaskFactory();
    Properties selectAnnotationTaskFactoryProps = new Properties();
    selectAnnotationTaskFactoryProps.setProperty(PREFERRED_ACTION, "NEW");
    selectAnnotationTaskFactoryProps.setProperty(MENU_GRAVITY, "1.1");
    selectAnnotationTaskFactoryProps.setProperty(PREFERRED_MENU, NETWORK_SELECT_MENU);
    selectAnnotationTaskFactoryProps.setProperty(TITLE, "Select/Unselect Annotation");
    registerService(bc, selectAnnotationTaskFactory, NetworkViewLocationTaskFactory.class, selectAnnotationTaskFactoryProps);
    // Annotation group
    GroupAnnotationsTaskFactory groupAnnotationTaskFactory = new GroupAnnotationsTaskFactory();
    Properties groupAnnotationTaskFactoryProps = new Properties();
    groupAnnotationTaskFactoryProps.setProperty(PREFERRED_ACTION, "NEW");
    groupAnnotationTaskFactoryProps.setProperty(MENU_GRAVITY, "100");
    groupAnnotationTaskFactoryProps.setProperty(INSERT_SEPARATOR_BEFORE, "true");
    groupAnnotationTaskFactoryProps.setProperty(IN_MENU_BAR, "false");
    groupAnnotationTaskFactoryProps.setProperty(PREFERRED_MENU, NETWORK_GROUP_MENU);
    groupAnnotationTaskFactoryProps.setProperty(TITLE, "Group Annotations");
    registerService(bc, groupAnnotationTaskFactory, NetworkViewTaskFactory.class, groupAnnotationTaskFactoryProps);
    // Annotation ungroup
    UngroupAnnotationsTaskFactory ungroupAnnotationTaskFactory = new UngroupAnnotationsTaskFactory();
    Properties ungroupAnnotationTaskFactoryProps = new Properties();
    ungroupAnnotationTaskFactoryProps.setProperty(PREFERRED_ACTION, "NEW");
    ungroupAnnotationTaskFactoryProps.setProperty(MENU_GRAVITY, "100");
    ungroupAnnotationTaskFactoryProps.setProperty(INSERT_SEPARATOR_BEFORE, "true");
    ungroupAnnotationTaskFactoryProps.setProperty(PREFERRED_MENU, NETWORK_GROUP_MENU);
    ungroupAnnotationTaskFactoryProps.setProperty(TITLE, "Ungroup Annotations");
    registerService(bc, ungroupAnnotationTaskFactory, NetworkViewLocationTaskFactory.class, ungroupAnnotationTaskFactoryProps);
    // Set mouse drag selection modes
    SelectModeAction selectNodesOnlyAction = new SelectModeAction(SelectModeAction.NODES, 0.5f, serviceRegistrar);
    registerAllServices(bc, selectNodesOnlyAction, new Properties());
    SelectModeAction selectEdgesOnlyAction = new SelectModeAction(SelectModeAction.EDGES, 0.6f, serviceRegistrar);
    registerAllServices(bc, selectEdgesOnlyAction, new Properties());
    SelectModeAction selectNodesAndEdgesAction = new SelectModeAction(SelectModeAction.ALL, 0.7f, serviceRegistrar);
    registerAllServices(bc, selectNodesAndEdgesAction, new Properties());
    {
        // Toggle Graphics Details
        ShowGraphicsDetailsTaskFactory factory = new ShowGraphicsDetailsTaskFactory(dingGraphLOD, dingGraphLODAll);
        Properties props = new Properties();
        props.setProperty(ID, "showGraphicsDetailsTaskFactory");
        // Used at least by cyREST
        registerService(bc, factory, NetworkViewTaskFactory.class, props);
        // Main menu
        GraphicsDetailAction mainMenuAction = new GraphicsDetailAction(5.0f, "View", factory, serviceRegistrar);
        registerAllServices(bc, mainMenuAction);
        // Network tab's context menu
        GraphicsDetailAction networkMenuAction = new GraphicsDetailAction(11.0f, null, factory, serviceRegistrar);
        props = new Properties();
        props.setProperty(IN_NETWORK_PANEL_CONTEXT_MENU, "true");
        registerAllServices(bc, networkMenuAction, props);
    }
    // if IN_CONTEXT_MENU is not specified, default to true
    final String vtfFilter = String.format("(| (!(%s=*)) (%s=true))", IN_CONTEXT_MENU, IN_CONTEXT_MENU);
    registerServiceListener(bc, vtfListener::addNodeViewTaskFactory, vtfListener::removeNodeViewTaskFactory, NodeViewTaskFactory.class, vtfFilter);
    registerServiceListener(bc, vtfListener::addEdgeViewTaskFactory, vtfListener::removeEdgeViewTaskFactory, EdgeViewTaskFactory.class, vtfFilter);
    registerServiceListener(bc, vtfListener::addNetworkViewTaskFactory, vtfListener::removeNetworkViewTaskFactory, NetworkViewTaskFactory.class, vtfFilter);
    registerServiceListener(bc, vtfListener::addNetworkViewLocationTaskFactory, vtfListener::removeNetworkViewLocationTaskFactory, NetworkViewLocationTaskFactory.class);
    registerServiceListener(bc, vtfListener::addCyEdgeViewContextMenuFactory, vtfListener::removeCyEdgeViewContextMenuFactory, CyEdgeViewContextMenuFactory.class);
    registerServiceListener(bc, vtfListener::addCyNodeViewContextMenuFactory, vtfListener::removeCyNodeViewContextMenuFactory, CyNodeViewContextMenuFactory.class);
    registerServiceListener(bc, vtfListener::addCyNetworkViewContextMenuFactory, vtfListener::removeCyNetworkViewContextMenuFactory, CyNetworkViewContextMenuFactory.class);
    registerServiceListener(bc, annotationFactoryManager::addAnnotationFactory, annotationFactoryManager::removeAnnotationFactory, AnnotationFactory.class);
    BendFactory bendFactory = new BendFactoryImpl();
    registerService(bc, bendFactory, BendFactory.class, new Properties());
    // Register the factory
    dVisualLexicon.addBendFactory(bendFactory, new HashMap<Object, Object>());
    // Translators for Passthrough
    final CustomGraphicsTranslator cgTranslator = new CustomGraphicsTranslator(cgManager, cg2Manager);
    registerService(bc, cgTranslator, ValueTranslator.class, new Properties());
    // Factories for Visual Property Dependency
    final NodeSizeDependencyFactory nodeSizeDependencyFactory = new NodeSizeDependencyFactory(dVisualLexicon);
    registerService(bc, nodeSizeDependencyFactory, VisualPropertyDependencyFactory.class, new Properties());
    final EdgeColorDependencyFactory edgeColorDependencyFactory = new EdgeColorDependencyFactory(dVisualLexicon);
    registerService(bc, edgeColorDependencyFactory, VisualPropertyDependencyFactory.class, new Properties());
    final CustomGraphicsSizeDependencyFactory cgSizeDependencyFactory = new CustomGraphicsSizeDependencyFactory(dVisualLexicon);
    registerService(bc, cgSizeDependencyFactory, VisualPropertyDependencyFactory.class, new Properties());
    // Custom Graphics Editors
    final CyCustomGraphicsValueEditor cgValueEditor = new CyCustomGraphicsValueEditor(cgManager, cg2Manager, cgBrowser, serviceRegistrar);
    registerAllServices(bc, cgValueEditor, new Properties());
    final CustomGraphicsVisualPropertyEditor cgVisualPropertyEditor = new CustomGraphicsVisualPropertyEditor(CyCustomGraphics.class, cgValueEditor, continuousMappingCellRendererFactory, serviceRegistrar);
    registerService(bc, cgVisualPropertyEditor, VisualPropertyEditor.class, new Properties());
}

Example 2 with BendFactory

use of org.cytoscape.view.presentation.property.values.BendFactory in project cytoscape-impl by cytoscape.

the class LayerOrderNode method layout.

public void layout() {
    taskMonitor.setProgress(0.0);
    taskMonitor.setStatusMessage("Capturing snapshot of network and selected nodes");
    if (cancelled)
        return;
    /* construct node list with selected nodes first */
    int numLayoutNodes = nodesToLayOut.size();
    if (numLayoutNodes == 1) {
        // We were asked to do a hierchical layout of a single node -- done!
        return;
    }
    HashMap<Long, Integer> suid2Index = new HashMap<Long, Integer>(numLayoutNodes);
    List<View<CyNode>> nodeViews = new ArrayList<View<CyNode>>(nodesToLayOut);
    int index = 0;
    for (View<CyNode> view : nodeViews) {
        CyNode node = view.getModel();
        Long suid = node.getSUID();
        suid2Index.put(suid, index);
        index++;
    }
    if (cancelled)
        return;
    /* create edge list from edges between selected nodes */
    LinkedList<Edge> edges = new LinkedList();
    for (View<CyEdge> ev : networkView.getEdgeViews()) {
        // FIXME: much better would be to query adjacent edges of selected nodes...
        Integer edgeFrom = suid2Index.get(ev.getModel().getSource().getSUID());
        Integer edgeTo = suid2Index.get(ev.getModel().getTarget().getSUID());
        if ((edgeFrom == null) || (edgeTo == null)) {
            // Must be from an unselected node
            continue;
        }
        if (cancelled)
            return;
        if ((numLayoutNodes <= 1) || ((edgeFrom < numLayoutNodes) && (edgeTo < numLayoutNodes))) {
            /* add edge to graph */
            Edge theEdge = new Edge(edgeFrom, edgeTo);
            edges.add(theEdge);
        }
    }
    /* find horizontal and vertical coordinates of each node */
    Edge[] edge = new Edge[edges.size()];
    edges.toArray(edge);
    Graph graph = new Graph(numLayoutNodes, edge);
    /*
		int edgeIndex;
		for (edgeIndex = 0; edgeIndex<edge.length; edgeIndex++) {
		     System.out.println("Edge: " + edge[edgeIndex].getFrom() + " - " + edge[edgeIndex].getTo());
		}
		*/
    int[] cI = graph.componentIndex();
    int x;
    /*
		System.out.println("Node index:\n");
		for (x=0; x<graph.getNodecount(); x++) {
		    System.out.println(cI[x]);
		}
		System.out.println("Partitioning into components:\n");
		*/
    taskMonitor.setProgress(0.1);
    taskMonitor.setStatusMessage("Finding connected components");
    if (cancelled)
        return;
    int[] renumber = new int[cI.length];
    Graph[] component = graph.partition(cI, renumber);
    final int numComponents = component.length;
    int[][] layer = new int[numComponents][];
    int[][] horizontalPosition = new int[numComponents][];
    Graph[] reduced = new Graph[component.length];
    Graph[] reducedTmp = new Graph[component.length];
    HashMap<Integer, Edge>[] dummy2Edge = new HashMap[component.length];
    int[] dummyStartForComp = new int[component.length];
    HashMap<Edge, View<CyEdge>>[] myEdges2EdgeViews = new HashMap[component.length];
    for (x = 0; x < component.length; x++) {
        /*
			System.out.println("plain component:\n");
			System.out.println(component[x]);
			System.out.println("filtered component:\n");
			System.out.println(component[x].getGraphWithoutOneOrTwoCycles());
			System.out.println("nonmulti component:\n");
			System.out.println(component[x].getGraphWithoutMultipleEdges());
			int cycleEliminationPriority[] = component[x].getCycleEliminationVertexPriority();
			System.out.println("acyclic component:\n");
			System.out.println(component[x].getGraphWithoutCycles(cycleEliminationPriority));
			System.out.println("reduced component:\n");
			System.out.println(component[x].getReducedGraph());
			System.out.println("layer assignment:\n");
			*/
        taskMonitor.setProgress((20 + ((40 * (x * 3)) / numComponents / 3)) / 100.0);
        taskMonitor.setStatusMessage("making acyclic transitive reduction");
        Thread.yield();
        if (cancelled)
            return;
        reducedTmp[x] = component[x].getReducedGraph();
        taskMonitor.setProgress((20 + ((40 * ((x * 3) + 1)) / numComponents / 3)) / 100.0);
        taskMonitor.setStatusMessage("layering nodes vertically");
        Thread.yield();
        if (cancelled)
            return;
        layer[x] = reducedTmp[x].getVertexLayers();
        LinkedList<Integer> layerWithDummy = new LinkedList<Integer>();
        for (int i = 0; i < layer[x].length; i++) layerWithDummy.add(Integer.valueOf(layer[x][i]));
        /*
			int y;
			for (y=0;y<layer[x].length;y++) {
			    System.out.println("" + y + " : " + layer[x][y]);
			}
			System.out.println("horizontal position:\n");
			*/
        /* Insertion of the dummy nodes in the graph */
        Edge[] allEdges = component[x].GetEdges();
        LinkedList<Edge> edgesWithAdd = new LinkedList<Edge>();
        int dummyStart = component[x].getNodecount();
        dummyStartForComp[x] = dummyStart;
        dummy2Edge[x] = new HashMap<Integer, Edge>();
        for (int i = 0; i < allEdges.length; i++) {
            int from = allEdges[i].getFrom();
            int to = allEdges[i].getTo();
            if (layer[x][from] == (layer[x][to] + 1)) {
                edgesWithAdd.add(allEdges[i]);
            } else {
                if (layer[x][from] < layer[x][to]) {
                    int tmp = from;
                    from = to;
                    to = tmp;
                }
                layerWithDummy.add(Integer.valueOf(layer[x][to] + 1));
                dummy2Edge[x].put(Integer.valueOf(layerWithDummy.size() - 1), allEdges[i]);
                edgesWithAdd.add(new Edge(layerWithDummy.size() - 1, to));
                for (int j = layer[x][to] + 2; j < layer[x][from]; j++) {
                    layerWithDummy.add(Integer.valueOf(j));
                    dummy2Edge[x].put(Integer.valueOf(layerWithDummy.size() - 1), allEdges[i]);
                    edgesWithAdd.add(new Edge(layerWithDummy.size() - 1, layerWithDummy.size() - 2));
                }
                edgesWithAdd.add(new Edge(from, layerWithDummy.size() - 1));
            }
        }
        allEdges = new Edge[edgesWithAdd.size()];
        edgesWithAdd.toArray(allEdges);
        reduced[x] = new Graph(layerWithDummy.size(), allEdges);
        reduced[x].setDummyNodesStart(dummyStart);
        reduced[x].setReduced(true);
        int[] layerNew = new int[layerWithDummy.size()];
        Iterator<Integer> iter = layerWithDummy.iterator();
        for (int i = 0; i < layerNew.length; i++) layerNew[i] = iter.next();
        layer[x] = layerNew;
        taskMonitor.setProgress((20 + ((40 * ((x * 3) + 2)) / numComponents / 3)) / 100.0);
        taskMonitor.setStatusMessage("positioning nodes within layer");
        Thread.yield();
        if (cancelled)
            return;
        horizontalPosition[x] = reduced[x].getHorizontalPositionReverse(layer[x]);
    /*
			for (y=0;y<horizontalPosition[x].length;y++) {
			    System.out.println("" + y + " : " + horizontalPosition[x][y]);
			}
			*/
    }
    int resize = renumber.length;
    for (int i = 0; i < component.length; i++) resize += (layer[i].length - dummyStartForComp[i]);
    int[] newRenumber = new int[resize];
    int[] newcI = new int[resize];
    for (int i = 0; i < renumber.length; i++) {
        newRenumber[i] = renumber[i];
        newcI[i] = cI[i];
    }
    int t = renumber.length;
    for (int i = 0; i < reduced.length; i++) {
        for (int j = reduced[i].getDummyNodesStart(); j < reduced[i].getNodecount(); j++) {
            newRenumber[t] = j;
            newcI[t] = i;
            t++;
        }
    }
    renumber = newRenumber;
    cI = newcI;
    edges = new LinkedList<Edge>();
    for (int i = 0; i < reduced.length; i++) {
        edge = reduced[i].GetEdges();
        for (int j = 0; j < edge.length; j++) {
            // uzasna budzevina!!!!!! // FIXME: what does this mean?
            int from = -1;
            int to = -1;
            for (int k = 0; k < cI.length; k++) {
                if ((cI[k] == i) && (renumber[k] == edge[j].getFrom()))
                    from = k;
                if ((cI[k] == i) && (renumber[k] == edge[j].getTo()))
                    to = k;
                if ((from != -1) && (to != -1))
                    break;
            }
            // edges.add(new Edge(to, from));
            edges.add(new Edge(from, to));
        }
    }
    edge = new Edge[edges.size()];
    edges.toArray(edge);
    graph = new Graph(resize, edge);
    taskMonitor.setProgress(0.6);
    taskMonitor.setStatusMessage("Repositioning nodes in view");
    Thread.yield();
    if (cancelled)
        return;
    /* order nodeviews by layout order */
    HierarchyFlowLayoutOrderNode[] flowLayoutOrder = new HierarchyFlowLayoutOrderNode[resize];
    for (x = 0; x < resize; x++) {
        if (x < numLayoutNodes)
            flowLayoutOrder[x] = new HierarchyFlowLayoutOrderNode(nodeViews.get(x), cI[x], reduced[cI[x]].getNodecount(), layer[cI[x]][renumber[x]], horizontalPosition[cI[x]][renumber[x]], x);
        else
            flowLayoutOrder[x] = new HierarchyFlowLayoutOrderNode(null, cI[x], reduced[cI[x]].getNodecount(), layer[cI[x]][renumber[x]], horizontalPosition[cI[x]][renumber[x]], x);
        nodes2HFLON.put(x, flowLayoutOrder[x]);
    }
    Arrays.sort(flowLayoutOrder);
    int lastComponent = -1;
    int lastLayer = -1;
    int startBandY = context.topEdge;
    int cleanBandY = context.topEdge;
    int startComponentX = context.leftEdge;
    int cleanComponentX = context.leftEdge;
    int startLayerY = context.topEdge;
    int cleanLayerY = context.topEdge;
    int cleanLayerX = context.leftEdge;
    int[] layerStart = new int[numLayoutNodes + 1];
    /* layout nodes which are selected */
    int nodeIndex;
    /* layout nodes which are selected */
    int lastComponentEnd = -1;
    for (nodeIndex = 0; nodeIndex < resize; nodeIndex++) {
        HierarchyFlowLayoutOrderNode node = flowLayoutOrder[nodeIndex];
        int currentComponent = node.componentNumber;
        int currentLayer = node.layer;
        View<CyNode> currentView = node.nodeView;
        taskMonitor.setProgress((60 + ((40 * (nodeIndex + 1)) / resize)) / 100.0);
        taskMonitor.setStatusMessage("layering nodes vertically");
        Thread.yield();
        if (cancelled)
            return;
        if (lastComponent == -1) {
            /* this is the first component */
            lastComponent = currentComponent;
            lastLayer = currentLayer;
            layerStart[currentLayer] = -1;
        }
        if (lastComponent != currentComponent) {
            /* new component */
            // first call function for Horizontal Positioning of nodes in lastComponent
            int[] minXArray = new int[1];
            int maxX = HorizontalNodePositioning(nodeIndex - flowLayoutOrder[nodeIndex - 1].componentSize, nodeIndex - 1, flowLayoutOrder, graph, renumber, cI, dummyStartForComp, minXArray);
            int minX = minXArray[0];
            lastComponentEnd = nodeIndex - 1;
            for (int i = nodeIndex - flowLayoutOrder[nodeIndex - 1].componentSize; i <= (nodeIndex - 1); i++) flowLayoutOrder[i].xPos -= (minX - startComponentX);
            maxX -= (minX - startComponentX);
            layerStart[lastLayer] = startComponentX;
            /* initialize for new component */
            startComponentX = cleanComponentX + context.componentSpacing;
            if (maxX > startComponentX)
                startComponentX = maxX + context.componentSpacing;
            if (startComponentX > context.rightMargin) {
                /* new band */
                startBandY = cleanBandY + context.bandGap;
                cleanBandY = startBandY;
                startComponentX = context.leftEdge;
                cleanComponentX = context.leftEdge;
            }
            startLayerY = startBandY;
            cleanLayerY = startLayerY;
            cleanLayerX = startComponentX;
            layerStart[currentLayer] = -1;
        } else if (lastLayer != currentLayer) {
            /* new layer */
            layerStart[lastLayer] = startComponentX;
            startLayerY = cleanLayerY + context.nodeVerticalSpacing;
            cleanLayerY = startLayerY;
            cleanLayerX = startComponentX;
            layerStart[currentLayer] = -1;
        }
        node.setXPos(cleanLayerX);
        node.setYPos(startLayerY);
        cleanLayerX += context.nodeHorizontalSpacing;
        int currentBottom;
        int currentRight;
        if (currentView != null) {
            currentBottom = startLayerY + currentView.getVisualProperty(BasicVisualLexicon.NODE_HEIGHT).intValue();
            currentRight = cleanLayerX + currentView.getVisualProperty(BasicVisualLexicon.NODE_WIDTH).intValue();
        } else {
            currentBottom = startLayerY;
            currentRight = cleanLayerX;
        }
        if (currentBottom > cleanBandY)
            cleanBandY = currentBottom;
        if (currentRight > cleanComponentX)
            cleanComponentX = currentRight;
        if (currentBottom > cleanLayerY)
            cleanLayerY = currentBottom;
        if (currentRight > cleanLayerX)
            cleanLayerX = currentRight;
        lastComponent = currentComponent;
        lastLayer = currentLayer;
    }
    if (cancelled)
        return;
    /* Set horizontal positions of last component */
    int[] minXArray = new int[1];
    HorizontalNodePositioning(lastComponentEnd + 1, resize - 1, flowLayoutOrder, graph, renumber, cI, dummyStartForComp, minXArray);
    int minX = minXArray[0];
    for (int i = lastComponentEnd + 1; i < resize; i++) flowLayoutOrder[i].xPos -= (minX - startComponentX);
    /* Map edges to edge views in order to map dummy nodes to edge bends properly */
    for (View<CyEdge> ev : networkView.getEdgeViews()) {
        Integer edgeFrom = suid2Index.get(ev.getModel().getSource().getSUID());
        Integer edgeTo = suid2Index.get(ev.getModel().getTarget().getSUID());
        if ((edgeFrom == null) || (edgeTo == null)) {
            // Must be from an unselected node
            continue;
        }
        if ((numLayoutNodes <= 1) || ((edgeFrom < numLayoutNodes) && (edgeTo < numLayoutNodes))) {
            /* add edge to graph */
            Edge theEdge = component[cI[edgeFrom]].GetTheEdge(renumber[edgeFrom], renumber[edgeTo]);
            if (myEdges2EdgeViews[cI[edgeFrom]] == null)
                myEdges2EdgeViews[cI[edgeFrom]] = new HashMap<Edge, View<CyEdge>>();
            myEdges2EdgeViews[cI[edgeFrom]].put(theEdge, ev);
        }
    }
    for (nodeIndex = 0; nodeIndex < resize; nodeIndex++) {
        HierarchyFlowLayoutOrderNode node = flowLayoutOrder[nodeIndex];
        if (node.nodeView != null) {
            View<CyNode> currentView = node.nodeView;
            currentView.setVisualProperty(BasicVisualLexicon.NODE_X_LOCATION, Double.valueOf((double) node.getXPos()));
            currentView.setVisualProperty(BasicVisualLexicon.NODE_Y_LOCATION, Double.valueOf((double) node.getYPos()));
        }
    }
    final HandleFactory handleFactory = serviceRegistrar.getService(HandleFactory.class);
    final BendFactory bendFactory = serviceRegistrar.getService(BendFactory.class);
    for (nodeIndex = 0; nodeIndex < resize; nodeIndex++) {
        HierarchyFlowLayoutOrderNode node = flowLayoutOrder[nodeIndex];
        if (node.nodeView == null) {
            Edge theEdge = (Edge) dummy2Edge[cI[node.graphIndex]].get(Integer.valueOf(renumber[node.graphIndex]));
            View<CyEdge> ev = myEdges2EdgeViews[cI[node.graphIndex]].get(theEdge);
            if (ev != null) {
                View<CyNode> source = networkView.getNodeView(ev.getModel().getSource());
                View<CyNode> target = networkView.getNodeView(ev.getModel().getTarget());
                double k = (getYPositionOf(target) - getYPositionOf(source)) / (getXPositionOf(target) - getXPositionOf(source));
                double xPos = getXPositionOf(source);
                if (k != 0)
                    xPos += ((node.yPos - getYPositionOf(source)) / k);
                Bend b = bendFactory.createBend();
                Handle h = handleFactory.createHandle(networkView, ev, xPos, node.yPos);
                b.insertHandleAt(0, h);
                ev.setVisualProperty(BasicVisualLexicon.EDGE_BEND, b);
            }
        }
    }
    for (nodeIndex = 0; nodeIndex < resize; nodeIndex++) {
        HierarchyFlowLayoutOrderNode node = flowLayoutOrder[nodeIndex];
        if (node.nodeView == null) {
            Edge theEdge = dummy2Edge[cI[node.graphIndex]].get(Integer.valueOf(renumber[node.graphIndex]));
            View<CyEdge> ev = myEdges2EdgeViews[cI[node.graphIndex]].get(theEdge);
            if (ev != null) {
                List<Handle> handles = ev.getVisualProperty(BasicVisualLexicon.EDGE_BEND).getAllHandles();
                for (Handle h : handles) {
                    Point2D handelPt = h.calculateHandleLocation(networkView, ev);
                    if (handelPt.getY() == node.yPos) {
                        h.defineHandle(networkView, ev, (double) (node.xPos), (double) (node.yPos));
                        break;
                    }
                }
            }
        }
    }
    taskMonitor.setProgress(1.0);
    taskMonitor.setStatusMessage("hierarchical layout complete");
}

Example 3 with BendFactory

use of org.cytoscape.view.presentation.property.values.BendFactory in project cytoscape-impl by cytoscape.

the class ClearAllBendsForThisEdgeTask method run.

@Override
public void run(TaskMonitor taskMonitor) throws Exception {
    invokeOnEDT(() -> {
        final BendFactory bendFactory = servicesUtil.get(BendFactory.class);
        edgeView.setLockedValue(BasicVisualLexicon.EDGE_BEND, bendFactory.createBend());
        netView.updateView();
    });
}

Example 4 with BendFactory

use of org.cytoscape.view.presentation.property.values.BendFactory in project cytoscape-impl by cytoscape.

the class EdgeBundlerTask method run.

@Override
public void run(TaskMonitor tm) {
    // Check tunables
    if (numNubs < 1)
        numNubs = 1;
    if (numNubs > 50) {
        logger.warn("Maximum handles is 50.");
        numNubs = 50;
    }
    tm.setTitle("Edge Bundle Layout");
    // Pre-cache data structures
    tm.setStatusMessage("Caching network data");
    Collection<View<CyEdge>> edges = null;
    // Get selection
    if (// Use all edges
    selection == 0) {
        edges = this.view.getEdgeViews();
    } else if (// Use selected nodes only
    selection == 1) {
        Collection<View<CyEdge>> edgeView = this.view.getEdgeViews();
        edges = new ArrayList<View<CyEdge>>(edgeView.size());
        for (View<CyEdge> e : edgeView) {
            boolean n1 = view.getNodeView(e.getModel().getSource()).getVisualProperty(EDGE_SELECTED);
            boolean n2 = view.getNodeView(e.getModel().getTarget()).getVisualProperty(EDGE_SELECTED);
            if (n1 && n2)
                edges.add(e);
        }
    } else if (// Use selected edges only
    selection == 2) {
        Collection<View<CyEdge>> edgeView = this.view.getEdgeViews();
        edges = new ArrayList<View<CyEdge>>(edgeView.size());
        for (View<CyEdge> e : edgeView) if (e.getVisualProperty(EDGE_SELECTED))
            edges.add(e);
    }
    int ei = 0;
    for (View<CyEdge> e : edges) {
        View<CyNode> eSource = view.getNodeView(e.getModel().getSource());
        View<CyNode> eTarget = view.getNodeView(e.getModel().getTarget());
        if (eSource.getSUID().equals(eTarget.getSUID()))
            continue;
        ei++;
    }
    numEdges = ei;
    if (numEdges < 2) {
        logger.warn("Less than two edges found.");
        return;
    }
    edgePos = new double[2][2][numEdges];
    nubs = new double[numNubs][2][numEdges];
    edgeLength = new double[numEdges];
    ei = 0;
    for (final View<CyEdge> e : edges) {
        // System.out.println("SUID: "+e.getModel().getSUID());
        View<CyNode> eSource = view.getNodeView(e.getModel().getSource());
        View<CyNode> eTarget = view.getNodeView(e.getModel().getTarget());
        if (eSource.getSUID().equals(eTarget.getSUID()))
            continue;
        edgePos[0][0][ei] = eSource.getVisualProperty(NODE_X_LOCATION);
        edgePos[0][1][ei] = eSource.getVisualProperty(NODE_Y_LOCATION);
        edgePos[1][0][ei] = eTarget.getVisualProperty(NODE_X_LOCATION);
        edgePos[1][1][ei] = eTarget.getVisualProperty(NODE_Y_LOCATION);
        double diffx = edgePos[1][0][ei] - edgePos[0][0][ei];
        double diffy = edgePos[1][1][ei] - edgePos[0][1][ei];
        for (int ni = 0; ni < numNubs; ni++) {
            nubs[ni][0][ei] = (diffx) * (ni + 1) / (numNubs + 1) + edgePos[0][0][ei];
            nubs[ni][1][ei] = (diffy) * (ni + 1) / (numNubs + 1) + edgePos[0][1][ei];
        }
        edgeLength[ei] = Math.sqrt(diffx * diffx + diffy * diffy);
        ei++;
    }
    computeEdgeCompatability();
    // Simulating physics
    tm.setStatusMessage("Simulating physics");
    double time = System.nanoTime();
    final double maxItrDouble = Double.valueOf(maxIterations);
    // Nub, X/Y, edgeIndex
    final double[][][] forces = new double[numNubs][2][numEdges];
    final HandleFactory handleFactory = serviceRegistrar.getService(HandleFactory.class);
    final BendFactory bendFactory = serviceRegistrar.getService(BendFactory.class);
    final VisualMappingManager visualMappingManager = serviceRegistrar.getService(VisualMappingManager.class);
    final VisualMappingFunctionFactory discreteFactory = serviceRegistrar.getService(VisualMappingFunctionFactory.class, "(mapping.type=discrete)");
    // Repeat the simulation [maxIterations] times.
    for (int iteri = 0; iteri < maxIterations; iteri++) {
        if (this.cancelled) {
            logger.info("Edge bundling cancelled: iter=" + iteri);
            break;
        }
        tm.setProgress(iteri / maxItrDouble);
        updateForces(forces);
        updateNubs(forces);
        // Check convergence once in awhile
        if (iteri % 1000 == 0 && isConverged(forces, .01)) {
            logger.info("Edge bundling converged: iter=" + iteri);
            break;
        }
        if (iteri == maxIterations - 1) {
            logger.info("Edge bundling did not converge: iter=" + iteri);
            break;
        }
        if (animate && System.nanoTime() - time > 3) {
            render(edges, handleFactory, bendFactory, visualMappingManager, discreteFactory);
            time = System.nanoTime();
        }
    }
    render(edges, handleFactory, bendFactory, visualMappingManager, discreteFactory);
}