public FastRenderingGraph(Graph<V,E> graph, Set<Rectangle2D> bounds, BasicVisualizationServer<V,E> vv) { this.graph = graph; this.bounds = bounds; this.vv = vv; this.rc = vv.getRenderContext(); }
public void scaleToLayout(ScalingControl scaler) { Dimension vd = getPreferredSize(); if(this.isShowing()) { vd = getSize(); } Dimension ld = getGraphLayout().getSize(); if(vd.equals(ld) == false) { scaler.scale(this, (float)(vd.getWidth()/ld.getWidth()), new Point2D.Double()); } }
/** * Override to request focus on mouse enter, if a key listener is added * @see java.awt.Component#addKeyListener(java.awt.event.KeyListener) */ @Override public synchronized void addKeyListener(KeyListener l) { super.addKeyListener(l); }
@Override protected void paintComponent(Graphics g) { super.paintComponent(g); Graphics2D g2d = (Graphics2D)g; if(doubleBuffered) { checkOffscreenImage(getSize()); renderGraph(offscreenG2d); g2d.drawImage(offscreen, null, 0, 0); } else { renderGraph(g2d); } }
public void setGraphLayout(Layout<V,E> layout) { Dimension viewSize = getPreferredSize(); if(this.isShowing()) { viewSize = getSize(); } model.setGraphLayout(layout, viewSize); }
@Override public void writeTo(Graph data, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> headers, OutputStream out) throws IOException { Integer width = Integer.parseInt(Optional.ofNullable(request.getParameter("width")).orElse(DEFAULT_WIDTH)); Integer height = Integer.parseInt(Optional.ofNullable(request.getParameter("height")).orElse(DEFAULT_HEIGHT)); String layoutName = Optional.ofNullable(request.getParameter("layout")).orElse(DEFAULT_LAYOUT); GraphJung<Graph> graph = new GraphJung<Graph>(data); AbstractLayout<Vertex, Edge> layout = getLayout(graph, layoutName); layout.setSize(new Dimension(width, height)); BasicVisualizationServer<Vertex, Edge> viz = new BasicVisualizationServer<>(layout); viz.setPreferredSize(new Dimension(width, height)); viz.getRenderContext().setEdgeLabelTransformer(edgeLabelTransformer); viz.getRenderContext().setVertexLabelTransformer(vertexLabelTransformer); viz.getRenderContext().setVertexFillPaintTransformer(vertexColorTransformer); BufferedImage bi = renderImage(viz); String imageType = null; if (mediaType.equals(CustomMediaTypes.IMAGE_JPEG_TYPE)) { imageType = "jpg"; } else if (mediaType.equals(CustomMediaTypes.IMAGE_PNG_TYPE)) { imageType = "png"; } ImageIO.write(bi, imageType, out); }
layout.setSize(new Dimension(900, 600)); BasicVisualizationServer<String, String> visualization = new BasicVisualizationServer<String, String>(layout); visualization.getRenderContext().setVertexLabelTransformer(new ToStringLabeller<String>()); Transformer<String, Paint> myVertexTransformer = new MyVertexTransformer(startMessage, stopMessages); visualization.getRenderContext().setVertexFillPaintTransformer(myVertexTransformer); Transformer<String, Paint> myEdgeTransformer = new MyEdgeTransformer(); visualization.getRenderContext().setEdgeDrawPaintTransformer(myEdgeTransformer); visualization.getRenderer().getVertexLabelRenderer().setPosition(Position.AUTO); visualization.setPreferredSize(new Dimension(900, 650)); visualization.setBackground(Color.WHITE); return visualization;
renderContext = new PluggableRenderContext<>(model.getNetwork()); renderer = new BasicRenderer<>(); createSpatialStuctures(model, renderContext); model.addChangeListener(this); model.addLayoutChangeListener(this); setDoubleBuffered(false); this.addComponentListener(new VisualizationListener(this)); setPickSupport(new ShapePickSupport<>(this)); setPickedNodeState(new MultiPickedState<>()); setPickedEdgeState(new MultiPickedState<>()); new PickableEdgePaintFunction<>(getPickedEdgeState(), Color.black, Color.cyan)); renderContext.setNodeFillPaintFunction( new PickableNodePaintFunction<>(getPickedNodeState(), Color.red, Color.yellow)); setPreferredSize(preferredSize); renderingHints.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
/** * Create an instance with the specified model and view dimension. * * @param model the model to use * @param preferredSize initial preferred size of the view */ public BasicVisualizationServer(VisualizationModel<V,E> model, Dimension preferredSize) { this.model = model; renderContext = new PluggableRenderContext<V,E>(model.getGraphLayout().getGraph()); model.addChangeListener(this); setDoubleBuffered(false); this.addComponentListener(new VisualizationListener(this)); setPickSupport(new ShapePickSupport<V,E>(this)); setPickedVertexState(new MultiPickedState<V>()); setPickedEdgeState(new MultiPickedState<E>()); renderContext.setEdgeDrawPaintTransformer(new PickableEdgePaintTransformer<E>(getPickedEdgeState(), Color.black, Color.cyan)); renderContext.setVertexFillPaintTransformer(new PickableVertexPaintTransformer<V>(getPickedVertexState(), Color.red, Color.yellow)); setPreferredSize(preferredSize); renderingHints.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); renderContext.getMultiLayerTransformer().addChangeListener(this); }
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(); }
@SuppressWarnings({ "rawtypes", "unchecked" }) public CachingEdgeRenderer(BasicVisualizationServer<V,E> vv) { vv.getRenderContext().getMultiLayerTransformer().addChangeListener(this); Layout<V,E> layout = vv.getGraphLayout(); if(layout instanceof LayoutEventSupport) { ((LayoutEventSupport)layout).addLayoutChangeListener(this); } } /**
public void startVertexCreate(BasicVisualizationServer<V, E> vv, Point2D point) { V newVertex = vertexFactory.get(); Layout<V,E> layout = vv.getGraphLayout(); Graph<V,E> graph = layout.getGraph(); graph.addVertex(newVertex); layout.setLocation(newVertex, vv.getRenderContext().getMultiLayerTransformer().inverseTransform(point)); vv.repaint(); }
Dimension d = getSize(); g2d.setColor(getBackground()); g2d.fillRect(0, 0, d.width, d.height); addSpatialAnnotations(this.nodeSpatial, Color.blue); addSpatialAnnotations(this.edgeSpatial, Color.green); } else { removeSpatialAnnotations(); this.removePreRenderPaintable(lowerAnnotationPaintable);
private static void graphToFile(BasicVisualizationServer<String, String> visualization, File file) throws IOException { Dimension size = visualization.getSize(); int width = (int) (size.getWidth() + 1); int height = (int) (size.getHeight() + 1); BufferedImage bufferedImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB); Graphics2D graphics = bufferedImage.createGraphics(); graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); graphics.setColor(Color.WHITE); graphics.fillRect(0, 0, 900, 650); visualization.setBounds(0, 0, 900, 650); visualization.paint(graphics); graphics.dispose(); ImageIO.write(bufferedImage, "png", file); }
@Override public void setVisible(boolean aFlag) { super.setVisible(aFlag); if(aFlag == true) { Dimension d = this.getSize(); if(d.width <= 0 || d.height <= 0) { d = this.getPreferredSize(); } model.getGraphLayout().setSize(d); } }
public Point2D getCenter() { Dimension d = getSize(); return new Point2D.Double(d.width / 2, d.height / 2); }
Dimension d = getSize(); g2d.setColor(getBackground()); g2d.fillRect(0,0,d.width,d.height);
public void startEdgeEffects(BasicVisualizationServer<V, E> vv, Point2D down, Point2D out) { transformEdgeShape(down, out); vv.addPostRenderPaintable(edgePaintable); }
BasicVisualizationServer<BoostedNode, String> vv = new BasicVisualizationServer<BoostedNode, String>( layout); vv.setPreferredSize(new Dimension(700, 700)); vv.getRenderContext().setVertexFillPaintTransformer( vertexFillPaintTransformer); vv.getRenderContext().setVertexLabelTransformer(vertexStringer);
@SuppressWarnings({ "rawtypes", "unchecked" }) public CachingVertexRenderer(BasicVisualizationServer<V,E> vv) { vv.getRenderContext().getMultiLayerTransformer().addChangeListener(this); Layout<V,E> layout = vv.getGraphLayout(); if(layout instanceof LayoutEventSupport) { ((LayoutEventSupport)layout).addLayoutChangeListener(this); } }