Example usage for org.apache.commons.collections15 Transformer Transformer

List of usage examples for org.apache.commons.collections15 Transformer Transformer

Introduction

In this page you can find the example usage for org.apache.commons.collections15 Transformer Transformer.

Prototype

Transformer

Source Link

Usage

From source file:eu.fbk.sonet.snatool.GraphVisualizer.java

/**
 * create an instance of a simple graph with controls to
 * demo the zoom features./* w w w .  j av  a2s  .  c  o m*/
 * @throws SAXException 
 * @throws ParserConfigurationException 
 * @throws IOException 
 * 
 */

public GraphVisualizer(String filename) throws ParserConfigurationException, SAXException, IOException {

    Factory<Number> vertexFactory = new Factory<Number>() {
        int n = 0;

        public Number create() {
            return n++;
        }
    };
    Factory<Number> edgeFactory = new Factory<Number>() {
        int n = 0;

        public Number create() {
            return n++;
        }
    };

    GraphMLReader<DirectedGraph<Number, Number>, Number, Number> gmlr = new GraphMLReader<DirectedGraph<Number, Number>, Number, Number>(
            vertexFactory, edgeFactory);
    final DirectedGraph<Number, Number> graph = new DirectedSparseMultigraph<Number, Number>();
    gmlr.load(filename, graph);

    // create a simple graph for the demo
    vv = new VisualizationViewer<Number, Number>(new FRLayout<Number, Number>(graph));

    //vv.addGraphMouseListener(new TestGraphMouseListener<Number>());
    vv.getRenderer().setVertexRenderer(new GradientVertexRenderer<Number, Number>(Color.white, Color.red,
            Color.white, Color.blue, vv.getPickedVertexState(), false));

    // add my listeners for ToolTips
    vv.setVertexToolTipTransformer(new ToStringLabeller<Number>());
    vv.setEdgeToolTipTransformer(new Transformer<Number, String>() {
        public String transform(Number edge) {
            return "E" + graph.getEndpoints(edge).toString();
        }
    });

    vv.getRenderContext().setVertexLabelTransformer(new ToStringLabeller<Number>());
    vv.getRenderer().getVertexLabelRenderer().setPositioner(new InsidePositioner());
    vv.getRenderer().getVertexLabelRenderer().setPosition(Renderer.VertexLabel.Position.AUTO);

    // create a frome to hold the graph
    final JFrame frame = new JFrame();
    Container content = frame.getContentPane();
    final GraphZoomScrollPane panel = new GraphZoomScrollPane(vv);
    content.add(panel);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    final AbstractModalGraphMouse graphMouse = new DefaultModalGraphMouse<Number, Number>();
    vv.setGraphMouse(graphMouse);
    vv.addKeyListener(graphMouse.getModeKeyListener());

    JMenuBar menubar = new JMenuBar();
    menubar.add(graphMouse.getModeMenu());
    panel.setCorner(menubar);

    vv.addKeyListener(graphMouse.getModeKeyListener());
    vv.setToolTipText("<html><center>Type 'p' for Pick mode<p>Type 't' for Transform mode");

    // Scaling graph image        
    final ScalingControl scaler = new CrossoverScalingControl();

    JButton plus = new JButton("+");
    plus.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            scaler.scale(vv, 1.1f, vv.getCenter());
        }
    });
    JButton minus = new JButton("-");
    minus.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            scaler.scale(vv, 1 / 1.1f, vv.getCenter());
        }
    });

    // Adding control to controls JPanel
    JPanel controls = new JPanel();
    controls.add(plus);
    controls.add(minus);
    content.add(controls, BorderLayout.SOUTH);

    frame.pack();
    frame.setVisible(true);
}

From source file:EdgeLabelDemo.java

/**
 * create an instance of a simple graph with controls to
 * demo the label positioning features// www  .j  a v  a 2 s .  c  o m
 * 
 */
@SuppressWarnings("serial")
public EdgeLabelDemo() {

    // create a simple graph for the demo
    graph = new SparseMultigraph<Integer, Number>();
    Integer[] v = createVertices(3);
    createEdges(v);

    Layout<Integer, Number> layout = new CircleLayout<Integer, Number>(graph);
    vv = new VisualizationViewer<Integer, Number>(layout, new Dimension(600, 400));
    vv.setBackground(Color.white);

    vertexLabelRenderer = vv.getRenderContext().getVertexLabelRenderer();
    edgeLabelRenderer = vv.getRenderContext().getEdgeLabelRenderer();

    Transformer<Number, String> stringer = new Transformer<Number, String>() {
        public String transform(Number e) {
            return "Edge:" + graph.getEndpoints(e).toString();
        }
    };
    vv.getRenderContext().setEdgeLabelTransformer(stringer);
    vv.getRenderContext().setEdgeDrawPaintTransformer(
            new PickableEdgePaintTransformer<Number>(vv.getPickedEdgeState(), Color.black, Color.cyan));
    vv.getRenderContext().setVertexFillPaintTransformer(
            new PickableVertexPaintTransformer<Integer>(vv.getPickedVertexState(), Color.red, Color.yellow));
    // add my listener for ToolTips
    vv.setVertexToolTipTransformer(new ToStringLabeller<Integer>());

    // create a frome to hold the graph
    final GraphZoomScrollPane panel = new GraphZoomScrollPane(vv);
    Container content = getContentPane();
    content.add(panel);

    final DefaultModalGraphMouse<Integer, Number> graphMouse = new DefaultModalGraphMouse<Integer, Number>();
    vv.setGraphMouse(graphMouse);

    JButton plus = new JButton("+");
    plus.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            scaler.scale(vv, 1.1f, vv.getCenter());
        }
    });
    JButton minus = new JButton("-");
    minus.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            scaler.scale(vv, 1 / 1.1f, vv.getCenter());
        }
    });

    ButtonGroup radio = new ButtonGroup();
    JRadioButton lineButton = new JRadioButton("Line");
    lineButton.addItemListener(new ItemListener() {
        public void itemStateChanged(ItemEvent e) {
            if (e.getStateChange() == ItemEvent.SELECTED) {
                vv.getRenderContext().setEdgeShapeTransformer(new EdgeShape.Line<Integer, Number>());
                vv.repaint();
            }
        }
    });

    JRadioButton quadButton = new JRadioButton("QuadCurve");
    quadButton.addItemListener(new ItemListener() {
        public void itemStateChanged(ItemEvent e) {
            if (e.getStateChange() == ItemEvent.SELECTED) {
                vv.getRenderContext().setEdgeShapeTransformer(new EdgeShape.QuadCurve<Integer, Number>());
                vv.repaint();
            }
        }
    });

    JRadioButton cubicButton = new JRadioButton("CubicCurve");
    cubicButton.addItemListener(new ItemListener() {
        public void itemStateChanged(ItemEvent e) {
            if (e.getStateChange() == ItemEvent.SELECTED) {
                vv.getRenderContext().setEdgeShapeTransformer(new EdgeShape.CubicCurve<Integer, Number>());
                vv.repaint();
            }
        }
    });
    radio.add(lineButton);
    radio.add(quadButton);
    radio.add(cubicButton);

    graphMouse.setMode(ModalGraphMouse.Mode.TRANSFORMING);

    JCheckBox rotate = new JCheckBox("<html><center>EdgeType<p>Parallel</center></html>");
    rotate.addItemListener(new ItemListener() {
        public void itemStateChanged(ItemEvent e) {
            AbstractButton b = (AbstractButton) e.getSource();
            edgeLabelRenderer.setRotateEdgeLabels(b.isSelected());
            vv.repaint();
        }
    });
    rotate.setSelected(true);
    MutableDirectionalEdgeValue mv = new MutableDirectionalEdgeValue(.5, .7);
    vv.getRenderContext().setEdgeLabelClosenessTransformer(mv);
    JSlider directedSlider = new JSlider(mv.getDirectedModel()) {
        public Dimension getPreferredSize() {
            Dimension d = super.getPreferredSize();
            d.width /= 2;
            return d;
        }
    };
    JSlider undirectedSlider = new JSlider(mv.getUndirectedModel()) {
        public Dimension getPreferredSize() {
            Dimension d = super.getPreferredSize();
            d.width /= 2;
            return d;
        }
    };

    JSlider edgeOffsetSlider = new JSlider(0, 50) {
        public Dimension getPreferredSize() {
            Dimension d = super.getPreferredSize();
            d.width /= 2;
            return d;
        }
    };
    edgeOffsetSlider.addChangeListener(new ChangeListener() {

        public void stateChanged(ChangeEvent e) {
            JSlider s = (JSlider) e.getSource();
            AbstractEdgeShapeTransformer<Integer, Number> aesf = (AbstractEdgeShapeTransformer<Integer, Number>) vv
                    .getRenderContext().getEdgeShapeTransformer();
            aesf.setControlOffsetIncrement(s.getValue());
            vv.repaint();
        }

    });

    Box controls = Box.createHorizontalBox();

    JPanel zoomPanel = new JPanel(new GridLayout(0, 1));
    zoomPanel.setBorder(BorderFactory.createTitledBorder("Scale"));
    zoomPanel.add(plus);
    zoomPanel.add(minus);

    JPanel edgePanel = new JPanel(new GridLayout(0, 1));
    edgePanel.setBorder(BorderFactory.createTitledBorder("EdgeType Type"));
    edgePanel.add(lineButton);
    edgePanel.add(quadButton);
    edgePanel.add(cubicButton);

    JPanel rotatePanel = new JPanel();
    rotatePanel.setBorder(BorderFactory.createTitledBorder("Alignment"));
    rotatePanel.add(rotate);

    JPanel labelPanel = new JPanel(new BorderLayout());
    JPanel sliderPanel = new JPanel(new GridLayout(3, 1));
    JPanel sliderLabelPanel = new JPanel(new GridLayout(3, 1));
    JPanel offsetPanel = new JPanel(new BorderLayout());
    offsetPanel.setBorder(BorderFactory.createTitledBorder("Offset"));
    sliderPanel.add(directedSlider);
    sliderPanel.add(undirectedSlider);
    sliderPanel.add(edgeOffsetSlider);
    sliderLabelPanel.add(new JLabel("Directed", JLabel.RIGHT));
    sliderLabelPanel.add(new JLabel("Undirected", JLabel.RIGHT));
    sliderLabelPanel.add(new JLabel("Edges", JLabel.RIGHT));
    offsetPanel.add(sliderLabelPanel, BorderLayout.WEST);
    offsetPanel.add(sliderPanel);
    labelPanel.add(offsetPanel);
    labelPanel.add(rotatePanel, BorderLayout.WEST);

    JPanel modePanel = new JPanel(new GridLayout(2, 1));
    modePanel.setBorder(BorderFactory.createTitledBorder("Mouse Mode"));
    modePanel.add(graphMouse.getModeComboBox());

    controls.add(zoomPanel);
    controls.add(edgePanel);
    controls.add(labelPanel);
    controls.add(modePanel);
    content.add(controls, BorderLayout.SOUTH);
    quadButton.setSelected(true);
}

From source file:fungus.JungObserver.java

public JungObserver(String name) {
    this.name = name;
    this.hyphadataPid = Configuration.getPid(name + "." + PAR_HYPHADATA_PROTO);
    this.hyphalinkPid = Configuration.getPid(name + "." + PAR_HYPHALINK_PROTO);
    this.mycocastPid = Configuration.getPid(name + "." + PAR_MYCOCAST_PROTO);
    self = this;// w ww  .  ja va 2 s  .  co  m
    mainThread = Thread.currentThread();

    graph = new DirectedSparseGraph<MycoNode, String>();
    edu.uci.ics.jung.algorithms.layout.SpringLayout<MycoNode, String> layout = new edu.uci.ics.jung.algorithms.layout.SpringLayout<MycoNode, String>(
            graph);
    layout.setSize(new Dimension(650, 650));
    layout.setRepulsionRange(75);
    //layout.setForceMultiplier(0.75);
    layout.setStretch(0.85);

    Dimension preferredSize = new Dimension(650, 650);
    VisualizationModel<MycoNode, String> visualizationModel = new DefaultVisualizationModel<MycoNode, String>(
            layout, preferredSize);
    visualizer = new VisualizationViewer<MycoNode, String>(visualizationModel, preferredSize);
    visualizer.addGraphMouseListener(new InfoFrameVertexListener());

    //visualizer = new BasicVisualizationServer<Node,String>(layout);
    //visualizer.setPreferredSize(new Dimension(650, 650));

    Transformer<MycoNode, String> nodeLabeller = new Transformer<MycoNode, String>() {
        public String transform(MycoNode n) {
            return Long.toString(n.getID());
        }
    };

    final Shape biomassCircle = new Ellipse2D.Float(-2.5f, -2.5f, 5.0f, 5.0f);
    final Shape hyphaCircle = new Ellipse2D.Float(-5.0f, -5.0f, 10.0f, 10.0f);
    Transformer<MycoNode, Shape> shapeTransformer = new Transformer<MycoNode, Shape>() {
        public Shape transform(MycoNode n) {
            HyphaData data = n.getHyphaData();
            if (data.isBiomass()) {
                return biomassCircle;
            } else {
                return hyphaCircle;
            }
        }

    };

    Transformer<MycoNode, Paint> nodeFillRenderer = new Transformer<MycoNode, Paint>() {
        public Paint transform(MycoNode n) {
            HyphaData data = (HyphaData) n.getProtocol(hyphadataPid);
            if (!n.isUp()) {
                return Color.BLACK;
            }
            if (data.isBiomass()) {
                return Color.BLUE;
            } else if (data.isExtending()) {
                return Color.RED;
            } else if (data.isBranching()) {
                return Color.YELLOW;
            } else {
                return Color.GREEN;
            }
        }
    };
    Transformer<MycoNode, Paint> nodeShapeRenderer = new Transformer<MycoNode, Paint>() {
        public Paint transform(MycoNode n) {
            HyphaData data = (HyphaData) n.getProtocol(hyphadataPid);
            if (data.isBiomass()) {
                return Color.BLUE;
            } else if (data.isExtending()) {
                return Color.RED;
            } else if (data.isBranching()) {
                return Color.YELLOW;
            } else {
                return Color.GREEN;
            }
        }
    };

    final Stroke biomassStroke = new BasicStroke(0.25f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10.0f);
    final Stroke hyphalStroke = new BasicStroke(1.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10.0f);

    Transformer<String, Stroke> edgeStrokeTransformer = new Transformer<String, Stroke>() {
        public Stroke transform(String s) {
            Pair<MycoNode> vertices = graph.getEndpoints(s);
            HyphaData firstData = vertices.getFirst().getHyphaData();
            HyphaData secondData = vertices.getSecond().getHyphaData();
            if (firstData.isHypha() && secondData.isHypha()) {
                return hyphalStroke;
            } else {
                return biomassStroke;
            }
        }
    };

    visualizer.getRenderContext().setVertexFillPaintTransformer(nodeFillRenderer);
    visualizer.getRenderContext().setVertexShapeTransformer(shapeTransformer);
    visualizer.getRenderContext().setVertexLabelTransformer(nodeLabeller);
    visualizer.setVertexToolTipTransformer(new ToStringLabeller<MycoNode>());
    visualizer.getRenderContext().setEdgeStrokeTransformer(edgeStrokeTransformer);
    frame = new JFrame();
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    Container c = frame.getContentPane();
    c.setLayout(new BoxLayout(c, BoxLayout.Y_AXIS));

    //JScrollPane scrollPane = new JScrollPane(visualizer);
    //c.add(scrollPane);
    c.add(visualizer);

    JPanel buttonPane = new JPanel();
    buttonPane.setLayout(new BoxLayout(buttonPane, BoxLayout.X_AXIS));

    JButton pauseButton = new JButton("pause");
    ActionListener pauser = new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            //e.consume();
            synchronized (self) {
                stepBlocked = true;
                noBlock = false;
                //self.notifyAll();
            }
        }
    };
    pauseButton.addActionListener(pauser);

    JButton stepButton = new JButton("step");
    ActionListener stepper = new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            System.out.println("Clicked!\n");
            //e.consume();
            synchronized (self) {
                stepBlocked = false;
                self.notifyAll();
            }
        }
    };
    stepButton.addActionListener(stepper);

    JButton runButton = new JButton("run");
    ActionListener runner = new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            //e.consume();
            synchronized (self) {
                stepBlocked = false;
                noBlock = true;
                self.notifyAll();
            }
        }
    };
    runButton.addActionListener(runner);

    buttonPane.add(pauseButton);
    buttonPane.add(stepButton);
    buttonPane.add(runButton);
    c.add(buttonPane);

    frame.pack();
    frame.setVisible(true);
}

From source file:com.imag.nespros.runtime.algoritms.CostListener.java

public boolean executeAfterSolution(Search<T> search, SelectChoicePoint<T> select) {
    boolean returnCode = super.executeAfterSolution(search, select);
    //System.out.println("Solution N " + this.solutionsNo() + ": ");
    double cost = 0;
    op2Computer.clear();//  w  w w.  java2 s . c  o m
    if (global != null) {
        op2Computer.putAll(global.getOp2Computer());
    } else {
        return false;
    }
    // there are operators that where already mapped, their initial mapping should be considered here

    //        for (Var v : this.getVariables()) {
    //            System.out.print(v + ", ");
    //        }
    //        System.out.println();
    if (_topo != null) {
        for (Var v : this.getVariables()) {
            int computer_index = v.dom().valueEnumeration().nextElement();
            for (EPUnit p : operators) {
                if (p.getName().equals(v.id())) {
                    op2Computer.put(p, computers.get(computer_index));
                    p.setDevice(computers.get(computer_index));
                    break;
                }
            }
        }
        // current solution
        Solution s = new Solution(op2Computer);
        for (EPUnit ope : operators) {
            if (!_topo.containsVertex(op2Computer.get(ope))) {
                continue;
            }
            // compute the cost due to cpu latency in the designated computer
            double op_cpu_time = ope.getExecutionTime();
            double comp_speed_rate = op2Computer.get(ope).getCpuSpeed();
            //double cpu_cost = (int) Math.ceil(new Double(op_cpu_time) / comp_speed_rate);//Math.max(1, op_cpu_time / comp_speed_rate);
            double cpu_cost = op_cpu_time / comp_speed_rate;
            int localLatency_cost = 0, maxLocalLatency_cost = 0;
            // compute the cost due to the latency.
            for (EventChannel ec : _epn.getInEdges(ope)) {
                EPUnit prev_ope = _epn.getSource(ec);
                localLatency_cost = 0;
                //System.out.println(op2Computer.get(ope)+", "+ op2Computer.get(next_ope));
                Transformer<ComLink, Integer> wtTransformer = new Transformer<ComLink, Integer>() {
                    @Override
                    public Integer transform(ComLink link) {
                        return link.getLatency();
                    }
                };

                DijkstraShortestPath<Device, ComLink> alg = new DijkstraShortestPath(_topo, wtTransformer);

                List<ComLink> path = alg.getPath(op2Computer.get(prev_ope), op2Computer.get(ope));
                //localLatency_cost=(int) alg.getDistance(op2Computer.get(prev_ope), op2Computer.get(ope));
                if (path != null) {
                    //System.out.println("Path between "+op2Computer.get(ope).getId() + " to" + op2Computer.get(next_ope).getId()+": ");
                    for (ComLink c : path) {
                        //System.out.print(c.getId()+", ");
                        localLatency_cost += c.getLatency();
                    }
                } else {
                    System.out.println(ope.getName() + "-> " + prev_ope.getName() + ", no path from "
                            + op2Computer.get(ope) + " to" + op2Computer.get(prev_ope));
                    localLatency_cost = Integer.MAX_VALUE;
                }
                if (localLatency_cost > maxLocalLatency_cost) {
                    maxLocalLatency_cost = localLatency_cost;
                }
            }
            cost += (maxLocalLatency_cost + cpu_cost);
            s.setCost(cost);
        }
        if (optimalSolution == null) {
            optimalSolution = s;
        } else {
            if (s.getCost() < optimalSolution.getCost()) {
                optimalSolution = s;
                // System.out.println(s.getCost()+ ", "+System.currentTimeMillis());
            }
        }
        //System.out.println("Cost= " + cost);
        CostValue = cost;
    }
    return returnCode;
}

From source file:GraphPanel.java

/**
 * create an instance of a simple graph in two views with controls to
 * demo the zoom features.//  ww w. jav  a  2 s. co  m
 * 
 */
@SuppressWarnings("unchecked")
public GraphPanel(Graph<V, E> graph) {

    super(new GridLayout(1, 0));
    this.graph = graph;
    //TestGraphs.getOneComponentGraph();

    // create one layout for the graph
    //ISOMLayout<AbstractAgent,Number> layout = new ISOMLayout<AbstractAgent,Number>(graph);
    CircleLayout<V, E> layout = new CircleLayout<V, E>(graph);
    // create one model that all 3 views will share
    DefaultVisualizationModel<V, E> visualizationModel = new DefaultVisualizationModel<V, E>(layout,
            preferredSize);

    // create 3 views that share the same model
    vv1 = new VisualizationViewer<V, E>(visualizationModel, preferredSize);

    vv1.getRenderContext().setVertexLabelTransformer(new ToStringLabeller());

    // this class will provide both label drawing and vertex shapes
    VertexLabelAsShapeRenderer<V, E> vlasr = new VertexLabelAsShapeRenderer<V, E>(vv1.getRenderContext());

    // customize the render context

    vv1.getRenderContext().setVertexLabelTransformer(
            // this chains together Transformers so that the html tags
            // are prepended to the toString method output
            new Transformer<V, String>() {
                public String transform(V input) {
                    return input.toString();
                }
            });

    vv1.getRenderContext().setVertexShapeTransformer(vlasr);
    vv1.getRenderer().setVertexLabelRenderer(vlasr);
    vv1.getRenderer().setVertexRenderer(new GradientVertexRenderer<V, E>(Color.gray, Color.white, true));
    vv1.setBackground(Color.white);
    final JPanel p1 = new JPanel(new BorderLayout());

    p1.add(new GraphZoomScrollPane(vv1));
    /*
     JButton h1 = new JButton("?");
     h1.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        textArea.setText(messageOne);
        JOptionPane.showMessageDialog(p1, scrollPane, 
                "View 1", JOptionPane.PLAIN_MESSAGE);
    }});
    */

    // create a GraphMouse for each view
    // each one has a different scaling plugin
    /*
    DefaultModalGraphMouse gm1 = new DefaultModalGraphMouse() {
    protected void loadPlugins() {
        pickingPlugin = new PickingGraphMousePlugin();
        animatedPickingPlugin = new AnimatedPickingGraphMousePlugin();
        translatingPlugin = new TranslatingGraphMousePlugin(InputEvent.BUTTON1_MASK);
        scalingPlugin = new ScalingGraphMousePlugin(new LayoutScalingControl(), 0);
        rotatingPlugin = new RotatingGraphMousePlugin();
        shearingPlugin = new ShearingGraphMousePlugin();
            
        add(scalingPlugin);
        setMode(Mode.TRANSFORMING);
    }
    };
            
            
    vv1.setGraphMouse(gm1);
            
            
    vv1.setToolTipText("<html><center>MouseWheel Scales Layout</center></html>");
            
    */

    this.add(p1);
    //content.add(panel);

}

From source file:com.robertolosanno.cdt_maven.Cdt.java

public Cdt() {
    //Ontologia//from  w  ww.ja  v a  2 s. c om
    OntModel m = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM);
    loadModel(m);
    ExtendedIterator<OntClass> iter = m.listHierarchyRootClasses();

    // create a simple graph
    graph = new DelegateTree<String, String>();

    createTree(iter);

    //Vincoli
    System.out.println("--- CONSTRAINTS ---");
    ExtendedIterator<ObjectProperty> iterProp = m.listObjectProperties();
    while (iterProp.hasNext()) {
        ObjectProperty objProp = iterProp.next();
        plotConstraint(objProp);
    }

    treeLayout = new TreeLayout<String, String>(graph);
    vv = new VisualizationViewer<String, String>(treeLayout, new Dimension(1200, 600));
    vv.setBackground(Color.white);
    vv.getRenderContext().setEdgeShapeTransformer(new EdgeShape.Line());
    vv.getRenderContext().setArrowFillPaintTransformer(new ConstantTransformer(Color.lightGray));

    //***************** MODIFICA COLORE VERTICE ************************
    Transformer<String, Paint> vertexColor = new Transformer<String, Paint>() {
        public Paint transform(String s) {
            String[] ss = s.split("#");
            String type = ss[1];
            if (type.equals("root"))
                return Color.lightGray;
            if (type.equals("dim"))
                return Color.BLACK;
            if (type.equals("val"))
                return Color.WHITE;
            if (type.equals("par_val"))
                return Color.WHITE;
            if (type.equals("par_dim"))
                return Color.WHITE;

            return Color.GREEN;
        }
    };
    vv.getRenderContext().setVertexFillPaintTransformer(vertexColor);

    //**************** MODIFICA FORMA VERTICE ***************************

    //Dati per creare un triangolo (lo creaiamo attraverso la classe Polygon)
    final int[] xShape = new int[4];
    final int[] yShape = new int[4];
    final int nShape; // count of points
    // Make a shape
    xShape[0] = -10;
    xShape[1] = 0;
    xShape[2] = 10;
    yShape[0] = 0;
    yShape[1] = 20;
    yShape[2] = 0;
    nShape = 3;

    Transformer<String, Shape> vertexShape = new Transformer<String, Shape>() {
        private final Shape[] styles = { new Rectangle(-10, -10, 20, 20),
                new Ellipse2D.Double(-10, -10, 20, 20), new Polygon(xShape, yShape, nShape) //Triangolo

        };

        @Override
        public Shape transform(String i) {
            String[] type = i.split("#");
            if (type[1].equals("par_val")) {
                return styles[0];
            } else if (type[1].equals("par_dim")) {
                return styles[2];
            } else {
                return styles[1];
            }
        }
    };
    vv.getRenderContext().setVertexShapeTransformer(vertexShape);

    //                          vv.getRenderer().setVertexRenderer(new MyRenderer());

    //**************** MODIFICA FONT LABEL ***************************
    vv.getRenderContext().setVertexFontTransformer(new Transformer<String, Font>() {

        @Override
        public Font transform(String arg0) {
            Font font = new Font("Arial Unicode MS", Font.PLAIN, 11);
            return font;
        }
    });

    // ********************** POSIZIONA LA LABEL SOTTO IL VERTICE ****************************
    vv.getRenderer().getVertexLabelRenderer().setPosition(Renderer.VertexLabel.Position.CNTR);
    vv.getRenderer().getVertexLabelRenderer().setPosition(Renderer.VertexLabel.Position.S);

    //******************** RIMUOVE DAL TESTO DELLA LABEL DEL VERTICE IL TIPO DI VERTICE ************************

    Transformer<String, String> transformer = new Transformer<String, String>() {
        @Override
        public String transform(String arg0) {
            String[] node = arg0.split("#");
            return node[0];
        }
    };

    vv.getRenderContext().setVertexLabelTransformer(transformer);

    Container content = getContentPane();
    final GraphZoomScrollPane panel = new GraphZoomScrollPane(vv);
    content.add(panel);

    final DefaultModalGraphMouse graphMouse = new DefaultModalGraphMouse();

    vv.setGraphMouse(graphMouse);

    JComboBox modeBox = graphMouse.getModeComboBox();
    modeBox.addItemListener(graphMouse.getModeListener());
    graphMouse.setMode(ModalGraphMouse.Mode.TRANSFORMING);

    final ScalingControl scaler = new CrossoverScalingControl();

    JButton plus = new JButton("+");
    plus.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            scaler.scale(vv, 1.1f, vv.getCenter());
        }
    });
    JButton minus = new JButton("-");
    minus.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            scaler.scale(vv, 1 / 1.1f, vv.getCenter());
        }
    });

    JPanel scaleGrid = new JPanel(new GridLayout(1, 0));
    scaleGrid.setBorder(BorderFactory.createTitledBorder("Zoom"));

    JPanel controls = new JPanel();
    scaleGrid.add(plus);
    scaleGrid.add(minus);
    controls.add(scaleGrid);
    controls.add(modeBox);

    content.add(controls, BorderLayout.SOUTH);
}

From source file:net.itransformers.topologyviewer.menu.handlers.graphFileMenuHandlers.SaveCurrentGraphMenuHandler.java

@Override
public void actionPerformed(ActionEvent e) {
    File path = frame.getPath();//from   www .j a v a 2  s.  c  o m

    if (path == null) {
        JOptionPane.showMessageDialog(frame, "Can not open graph before project has been opened.");
        return;
    }

    JTextField fileName = new JTextField();
    Object[] message = { "File name", fileName };
    String versionName = JOptionPane.showInputDialog("Enter output graph version");

    File networkPath = new File(path + File.separator + ProjectConstants.networkDirName);

    File versionPath = new File(networkPath, versionName);
    if (versionPath.exists()) {
        JOptionPane.showMessageDialog(frame, "Version already exists" + versionPath.getAbsolutePath());

        return;
    }

    if (!versionPath.mkdir()) {
        JOptionPane.showMessageDialog(frame, "Unable to create version path: " + versionPath.getAbsolutePath());
    }

    if ("undirected".equalsIgnoreCase(frame.getCurrentGraphViewerManager().getGraphType().toString())) {
        graphmlDir = new File(versionPath.getAbsolutePath(), ProjectConstants.undirectedGraphmlDirName);

    } else {
        graphmlDir = new File(versionPath.getAbsolutePath(), ProjectConstants.directedGraphmlDirName);

    }
    if (!graphmlDir.mkdir()) {
        JOptionPane.showMessageDialog(frame, "Unable to create version path:" + versionPath.getAbsolutePath(),
                "Error", JOptionPane.WARNING_MESSAGE);
        return;
    }

    Writer fileWriter;
    try {
        fileWriter = new FileWriter(new File(graphmlDir, ProjectConstants.networkGraphmlFileName));
    } catch (IOException e1) {
        JOptionPane.showMessageDialog(frame, "Unable to create network.graphml file:", "Error",
                JOptionPane.WARNING_MESSAGE);
        return;
    }
    GraphViewerPanel viewerPanel = (GraphViewerPanel) frame.getTabbedPane().getSelectedComponent();
    final Graph<String, String> currentGraph = viewerPanel.getCurrentGraph();
    MyGraphMLWriter writer = new MyGraphMLWriter();
    writer.setGraphData(viewerPanel.getGraphmlLoader().getGraphMetadatas());
    writer.setVertexData(viewerPanel.getGraphmlLoader().getVertexMetadatas());
    writer.setEdgeData(viewerPanel.getGraphmlLoader().getEdgeMetadatas());
    writer.setEdgeIDs(new Transformer<String, String>() {

        @Override
        public String transform(String s) {
            Pair<String> endpoints = currentGraph.getEndpoints(s);
            String[] endpointsArr = new String[] { endpoints.getFirst(), endpoints.getSecond() };
            Arrays.sort(endpointsArr);
            return endpointsArr[0] + "_" + endpointsArr[1];
        }
    });
    boolean flag;
    try {
        writer.save(currentGraph, fileWriter);
        flag = true;

    } catch (IOException e1) {
        flag = false;
        JOptionPane.showMessageDialog(frame, "Unable to write graph file:" + e1.getMessage(), "Error",
                JOptionPane.WARNING_MESSAGE);

    }

}

From source file:edu.uci.ics.jung.io.CustomPajekNetWriter.java

/**
 * Writes <code>graph</code> to <code>w</code>. Labels for vertices may be
 * supplied by <code>vs</code> (defaults to no labels if null), edge weights
 * may be specified by <code>nev</code> (defaults to weights of 1.0 if
 * null), and vertex locations may be specified by <code>vld</code>
 * (defaults to no locations if null)./*from   w ww . ja v  a2  s . c o m*/
 */
public void save(MyGraph<V, E> graph, Writer w, Transformer<V, String> vs, Transformer<E, Number> nev,
        Transformer<V, Point2D> vld) throws IOException {
    /*
     * TODO: Changes we might want to make:
     * - optionally writing out in list form
     */

    BufferedWriter writer = new BufferedWriter(w);
    if (nev == null) {
        nev = new Transformer<E, Number>() {
            public Number transform(E e) {
                return 1;
            }
        };
    }
    writer.write("*Colors " + graph.getLayoutParameters().getBackgroundColorRgb() + ","
            + graph.getLayoutParameters().getEdgeColorRgb());
    writer.newLine();
    writer.write(
            "*Vertices " + graph.getVertexCount() + "," + graph.getLayoutParameters().areNodeIconsAllowed());
    writer.newLine();

    List<V> id = new ArrayList<V>(graph.getVertices());//Indexer.getIndexer(graph);
    for (V currentVertex : graph.getVertices()) {
        // convert from 0-based to 1-based index
        int v_id = id.indexOf(currentVertex) + 1;
        writer.write("" + v_id);
        if (vs != null) {
            String label = vs.transform(currentVertex);
            if (label != null) {
                writer.write(" \"" + label + "\"");
            }
        }
        if (vld != null) {
            Point2D location = vld.transform(currentVertex);
            if (location != null) {
                writer.write(" " + location.getX() + " " + location.getY() + " 0.0");
            }
        }
        writer.newLine();
    }

    Collection<E> d_set = new HashSet<E>();
    Collection<E> u_set = new HashSet<E>();

    boolean directed = graph instanceof DirectedGraph;

    boolean undirected = graph instanceof UndirectedGraph;

    // if it's strictly one or the other, no need to create extra sets
    if (directed) {
        d_set.addAll(graph.getEdges());
    }
    if (undirected) {
        u_set.addAll(graph.getEdges());
    }
    if (!directed && !undirected) // mixed-mode graph
    {
        u_set.addAll(graph.getEdges());
        d_set.addAll(graph.getEdges());
        for (E e : graph.getEdges()) {
            if (graph.getEdgeType(e) == EdgeType.UNDIRECTED) {
                d_set.remove(e);
            } else {
                u_set.remove(e);
            }
        }
    }

    // write out directed edges
    if (!d_set.isEmpty()) {
        writer.write("*Arcs");
        writer.newLine();
    }
    for (E e : d_set) {
        int source_id = id.indexOf(graph.getEndpoints(e).getFirst()) + 1;
        int target_id = id.indexOf(graph.getEndpoints(e).getSecond()) + 1;
        float weight = nev.transform(e).floatValue();
        writer.write(source_id + " " + target_id + " " + weight);
        writer.newLine();
    }

    // write out undirected edges
    if (!u_set.isEmpty()) {
        writer.write("*Edges");
        writer.newLine();
    }
    for (E e : u_set) {
        Pair<V> endpoints = graph.getEndpoints(e);
        int v1_id = id.indexOf(endpoints.getFirst()) + 1;
        int v2_id = id.indexOf(endpoints.getSecond()) + 1;
        float weight = nev.transform(e).floatValue();
        writer.write(v1_id + " " + v2_id + " " + weight);
        writer.newLine();
    }
    writer.close();
}

From source file:main.AddNodeDemo.java

@Override
public void init() {

    //create a graph
    Graph<String, Number> ig = Graphs
            .<String, Number>synchronizedDirectedGraph(new DirectedSparseMultigraph<String, Number>());

    ObservableGraph<String, Number> og = new ObservableGraph<String, Number>(ig);
    og.addGraphEventListener(new GraphEventListener<String, Number>() {

        public void handleGraphEvent(GraphEvent<String, Number> evt) {
            System.err.println("got " + evt);

        }/*from   ww  w.j  a v a2  s  . com*/
    });
    this.g = og;
    //create a graphdraw
    //        layout = new FRLayout2<String,Number>(g);
    //        layout = new SpringLayout<String,Number>(g);
    //        ((FRLayout)layout).setMaxIterations(200);
    layout = new KKLayout<String, Number>(g);

    vv = new VisualizationViewer<String, Number>(layout, new Dimension(600, 600));

    JRootPane rp = this.getRootPane();
    rp.putClientProperty("defeatSystemEventQueueCheck", Boolean.TRUE);

    getContentPane().setLayout(new BorderLayout());
    getContentPane().setBackground(java.awt.Color.lightGray);
    getContentPane().setFont(new Font("Serif", Font.PLAIN, 12));

    vv.getModel().getRelaxer().setSleepTime(500);
    vv.setGraphMouse(new DefaultModalGraphMouse<Number, Number>());

    vv.getRenderer().getVertexLabelRenderer().setPosition(Renderer.VertexLabel.Position.CNTR);
    vv.getRenderContext().setVertexLabelTransformer(new ToStringLabeller<String>());
    vv.setForeground(Color.white);

    FontMetrics fm = vv.getFontMetrics(vv.getFont());
    int width = fm.stringWidth(g.toString());

    Transformer<String, Shape> vertexSize = new Transformer<String, Shape>() {
        public Shape transform(String i) {

            Ellipse2D circle = new Ellipse2D.Double(-20, -20, 40, 40);
            // in this case, the vertex is twice as large                
            return circle;
        }

    };

    //        vv.getRenderContext().setVertexLabelTransformer(new ToStringLabeller() {
    //            @Override
    //            public String transform(Object v) {
    //
    //                return ((VertexTopology)v).screenName;
    //            }});

    vv.getRenderContext().setVertexShapeTransformer(vertexSize);

    getContentPane().setPreferredSize(new Dimension(1400, 900));
    getContentPane().add(vv);
    switchLayout = new JButton("Switch to SpringLayout");
    //        switchLayout.addActionListener(new ActionListener() {
    //
    //            @SuppressWarnings("unchecked")
    //            public void actionPerformed(ActionEvent ae) {
    //               Dimension d = new Dimension(600,600);
    //                if (switchLayout.getText().indexOf("Spring") > 0) {
    //                    switchLayout.setText("Switch to FRLayout");
    //                    layout = new SpringLayout<String,Number>(g,
    //                        new ConstantTransformer(EDGE_LENGTH));
    //                    layout.setSize(d);
    //                    vv.getModel().setGraphLayout(layout, d);
    //                } else {
    //                    switchLayout.setText("Switch to SpringLayout");
    //                    layout = new FRLayout<String,Number>(g, d);
    //                    vv.getModel().setGraphLayout(layout, d);
    //                }
    //            }
    //        });

    getContentPane().add(switchLayout, BorderLayout.SOUTH);

    timer = new Timer();
}

From source file:edu.uci.ics.jung.io.PajekNetWriter.java

/**
 * Writes <code>graph</code> to <code>w</code>.  Labels for vertices may
 * be supplied by <code>vs</code> (defaults to no labels if null), 
 * edge weights may be specified by <code>nev</code>
 * (defaults to weights of 1.0 if null), 
 * and vertex locations may be specified by <code>vld</code> (defaults
 * to no locations if null). // ww  w . j  a  v a2 s  .  co  m
 */
public void save(Graph<V, E> graph, Writer w, Transformer<V, String> vs, Transformer<E, Number> nev,
        Transformer<V, Point2D> vld) throws IOException {
    /*
     * TODO: Changes we might want to make:
     * - optionally writing out in list form
     */

    BufferedWriter writer = new BufferedWriter(w);
    if (nev == null)
        nev = new Transformer<E, Number>() {
            public Number transform(E e) {
                return 1;
            }
        };
    writer.write("*Vertices " + graph.getVertexCount());
    writer.newLine();

    List<V> id = new ArrayList<V>(graph.getVertices());//Indexer.getIndexer(graph);
    for (V currentVertex : graph.getVertices()) {
        // convert from 0-based to 1-based index
        int v_id = id.indexOf(currentVertex) + 1;
        writer.write("" + v_id);
        if (vs != null) {
            String label = vs.transform(currentVertex);
            if (label != null)
                writer.write(" \"" + label + "\"");
        }
        if (vld != null) {
            Point2D location = vld.transform(currentVertex);
            if (location != null)
                writer.write(" " + location.getX() + " " + location.getY() + " 0.0");
        }
        writer.newLine();
    }

    Collection<E> d_set = new HashSet<E>();
    Collection<E> u_set = new HashSet<E>();

    boolean directed = graph instanceof DirectedGraph;

    boolean undirected = graph instanceof UndirectedGraph;

    // if it's strictly one or the other, no need to create extra sets
    if (directed)
        d_set.addAll(graph.getEdges());
    if (undirected)
        u_set.addAll(graph.getEdges());
    if (!directed && !undirected) // mixed-mode graph
    {
        u_set.addAll(graph.getEdges());
        d_set.addAll(graph.getEdges());
        for (E e : graph.getEdges()) {
            if (graph.getEdgeType(e) == EdgeType.UNDIRECTED) {
                d_set.remove(e);
            } else {
                u_set.remove(e);
            }
        }
    }

    // write out directed edges
    if (!d_set.isEmpty()) {
        writer.write("*Arcs");
        writer.newLine();
    }
    for (E e : d_set) {
        int source_id = id.indexOf(graph.getEndpoints(e).getFirst()) + 1;
        int target_id = id.indexOf(graph.getEndpoints(e).getSecond()) + 1;
        float weight = nev.transform(e).floatValue();
        writer.write(source_id + " " + target_id + " " + weight);
        writer.newLine();
    }

    // write out undirected edges
    if (!u_set.isEmpty()) {
        writer.write("*Edges");
        writer.newLine();
    }
    for (E e : u_set) {
        Pair<V> endpoints = graph.getEndpoints(e);
        int v1_id = id.indexOf(endpoints.getFirst()) + 1;
        int v2_id = id.indexOf(endpoints.getSecond()) + 1;
        float weight = nev.transform(e).floatValue();
        writer.write(v1_id + " " + v2_id + " " + weight);
        writer.newLine();
    }
    writer.close();
}