public NodeLabelAsShapeRenderer( VisualizationModel<N, E> visualizationModel, RenderContext<N, ?> rc) { this.layoutModel = visualizationModel.getLayoutModel(); this.renderContext = rc; }
public Nodes( VisualizationModel visualizationModel, BoundingRectangleCollector.Nodes<N> boundingRectangleCollector, SplitterContext<N> splitterContext) { super(visualizationModel.getLayoutModel(), splitterContext); this.boundingRectangleCollector = boundingRectangleCollector; rtree = RTree.create(); }
public Rectangle2D getForElement(N node) { Shape shape = new Rectangle2D.Double(); Point p = (Point) visualizationModel.getLayoutModel().apply(node); float x = (float) p.x; float y = (float) p.y; AffineTransform xform = AffineTransform.getTranslateInstance(x, y); Rectangle2D xfs = xform.createTransformedShape(shape).getBounds2D(); log.trace("node {} with shape bounds {} is at {}", node, xfs, p); return xfs; }
public Rectangle2D getForElement(N node) { Shape shape = (Shape) rc.getNodeShapeFunction().apply(node); Point p = (Point) visualizationModel.getLayoutModel().apply(node); float x = (float) p.x; float y = (float) p.y; AffineTransform xform = AffineTransform.getTranslateInstance(x, y); Rectangle2D xfs = xform.createTransformedShape(shape).getBounds2D(); log.trace("node {} with shape bounds {} is at {}", node, xfs, p); return xfs; }
public void compute(Collection nodes) { super.compute(); for (Object v : nodes) { Shape shape = (Shape) rc.getNodeShapeFunction().apply(v); Point2D p = (Point2D) visualizationModel.getLayoutModel().apply(v); // p = rc.getMultiLayerTransformer().transform(Layer.LAYOUT, p); float x = (float) p.getX(); float y = (float) p.getY(); AffineTransform xform = AffineTransform.getTranslateInstance(x, y); shape = xform.createTransformedShape(shape); rectangles.add(shape.getBounds2D()); } }
public void compute(Collection nodes) { super.compute(); for (Object v : nodes) { Shape shape = (Shape) rc.getNodeShapeFunction().apply(v); Point p = (Point) visualizationModel.getLayoutModel().apply(v); // p = rc.getMultiLayerTransformer().transform(Layer.LAYOUT, p); float x = (float) p.x; float y = (float) p.y; AffineTransform xform = AffineTransform.getTranslateInstance(x, y); shape = xform.createTransformedShape(shape); rectangles.add(shape.getBounds2D()); } }
public Edge(VisualizationModel<N, E> visualizationModel) { super(visualizationModel.getLayoutModel()); this.visualizationModel = visualizationModel; this.accessor = new RadiusNetworkElementAccessor<>(visualizationModel.getNetwork()); }
public void compute() { super.compute(); for (Object v : visualizationModel.getNetwork().nodes()) { Shape shape = (Shape) rc.getNodeShapeFunction().apply(v); Point2D p = (Point2D) visualizationModel.getLayoutModel().apply(v); // p = rc.getMultiLayerTransformer().transform(Layer.LAYOUT, p); float x = (float) p.getX(); float y = (float) p.getY(); AffineTransform xform = AffineTransform.getTranslateInstance(x, y); shape = xform.createTransformedShape(shape); rectangles.add(shape.getBounds2D()); } } }
public void compute() { super.compute(); for (Object v : visualizationModel.getNetwork().nodes()) { Shape shape = (Shape) rc.getNodeShapeFunction().apply(v); Point p = (Point) visualizationModel.getLayoutModel().apply(v); // p = rc.getMultiLayerTransformer().transform(Layer.LAYOUT, p); float x = (float) p.x; float y = (float) p.y; AffineTransform xform = AffineTransform.getTranslateInstance(x, y); shape = xform.createTransformedShape(shape); rectangles.add(shape.getBounds2D()); } } }
public void actionPerformed(ActionEvent e) { N newNode = nodeFactory.get(); graph.addNode(newNode); Point2D p2d = vv.getRenderContext().getMultiLayerTransformer().inverseTransform(p); vv.getModel().getLayoutModel().set(newNode, p2d.getX(), p2d.getY()); vv.repaint(); } });
/** * hook up events so that when the VisualizationModel gets an event from the LayoutModel and fires * it, the Spatial will get the same event and know to update or recalculate its space * * @param spatial */ private void connectListeners(Spatial<?> spatial) { if (model instanceof LayoutEventSupport && spatial instanceof LayoutChangeListener) { if (spatial instanceof LayoutChangeListener) { model.addLayoutChangeListener((LayoutChangeListener) spatial); } } // this one toggles active/inactive as the opposite of the LayoutModel's active/inactive state model.getLayoutModel().getLayoutStateChangeSupport().addLayoutStateChangeListener(spatial); }
public void startNodeCreate(BasicVisualizationServer<N, E> vv, Point2D point) { Preconditions.checkState( vv.getModel().getNetwork() instanceof MutableNetwork<?, ?>, "graph must be mutable"); N newNode = nodeFactory.get(); VisualizationModel<N, E> visualizationModel = vv.getModel(); MutableNetwork<N, E> graph = (MutableNetwork<N, E>) visualizationModel.getNetwork(); graph.addNode(newNode); Point2D p2d = vv.getRenderContext().getMultiLayerTransformer().inverseTransform(point); visualizationModel.getLayoutModel().set(newNode, p2d.getX(), p2d.getY()); vv.repaint(); }
public Edges( VisualizationModel visualizationModel, BoundingRectangleCollector.Edges<E> boundingRectangleCollector, SplitterContext<E> splitterContext) { super(visualizationModel.getLayoutModel(), splitterContext); this.visualizationModel = visualizationModel; this.boundingRectangleCollector = boundingRectangleCollector; networkElementAccessor = new RadiusNetworkElementAccessor(visualizationModel.getNetwork()); rtree = RTree.create(); recalculate(); }
public static <N, E> void animate( VisualizationServer<N, E> visualizationServer, LayoutAlgorithm<N> endLayoutAlgorithm) { fireLayoutStateChanged(visualizationServer.getModel().getLayoutModel(), true); LayoutAlgorithm<N> transitionLayoutAlgorithm = new AnimationLayoutAlgorithm<>(visualizationServer, endLayoutAlgorithm); visualizationServer.getModel().setLayoutAlgorithm(transitionLayoutAlgorithm); }
public void setEdgeSpatial(Spatial<E> spatial) { if (this.edgeSpatial != null) { disconnectListeners(this.edgeSpatial); } this.edgeSpatial = spatial; boolean layoutModelRelaxing = model.getLayoutModel().isRelaxing(); edgeSpatial.setActive(!layoutModelRelaxing); if (!layoutModelRelaxing) { edgeSpatial.recalculate(); } connectListeners(edgeSpatial); }
public void setNodeSpatial(Spatial<N> spatial) { if (this.nodeSpatial != null) { disconnectListeners(this.nodeSpatial); } this.nodeSpatial = spatial; boolean layoutModelRelaxing = model.getLayoutModel().isRelaxing(); nodeSpatial.setActive(!layoutModelRelaxing); if (!layoutModelRelaxing) { nodeSpatial.recalculate(); } connectListeners(spatial); }
public GradientEdgePaintFunction(Color c1, Color c2, VisualizationViewer<N, E> vv) { this.c1 = c1; this.c2 = c2; this.graph = vv.getModel().getNetwork(); this.layoutModel = vv.getModel().getLayoutModel(); this.transformer = vv.getRenderContext().getMultiLayerTransformer().getTransformer(Layer.LAYOUT); }
private Spatial<N> createNodeSpatial(VisualizationServer<N, E> visualizationServer) { switch (getNodeSpatialSupportPreference()) { case RTREE: return new SpatialRTree.Nodes<>( visualizationServer.getModel(), new BoundingRectangleCollector.Nodes<>( visualizationServer.getRenderContext(), visualizationServer.getModel()), SplitterContext.of(new RStarLeafSplitter<>(), new RStarSplitter<>())); case GRID: return new SpatialGrid<>(visualizationServer.getModel().getLayoutModel()); case QUADTREE: return new SpatialQuadTree<>(visualizationServer.getModel().getLayoutModel()); case NONE: default: return new Spatial.NoOp.Node<N>(visualizationServer.getModel().getLayoutModel()); } }
/** * Invoked when the component's size changes. * * @param e */ @Override public void componentResized(ComponentEvent e) { super.componentResized(e); VisualizationViewer vv = (VisualizationViewer) e.getComponent(); VisualizationModel model = vv.getModel(); LayoutModel layoutModel = model.getLayoutModel(); layoutModel.setSize(vv.getWidth(), vv.getHeight()); layoutModel.accept(model.getLayoutAlgorithm()); } });
public ViewLensSupport( VisualizationViewer<N, E> vv, LensTransformer lensTransformer, ModalGraphMouse lensGraphMouse) { super(vv, lensGraphMouse); this.renderContext = vv.getRenderContext(); this.pickSupport = renderContext.getPickSupport(); this.savedGraphicsDecorator = renderContext.getGraphicsContext(); this.lensTransformer = lensTransformer; LayoutModel layoutModel = vv.getModel().getLayoutModel(); Dimension d = new Dimension(layoutModel.getWidth(), layoutModel.getHeight()); lensTransformer.getLens().setSize(d); this.lensGraphicsDecorator = new TransformingFlatnessGraphics(lensTransformer); this.savedEdgeRenderer = vv.getRenderer().getEdgeRenderer(); }