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:joshua.ui.hypergraph_visualizer.HyperGraphViewer.java

private Transformer<Vertex, String> toStringTransformer() {
    return new Transformer<Vertex, String>() {
        public String transform(Vertex v) {
            if (v instanceof LeafVertex) {
                return vocab.getWord(((LeafVertex) v).getEnglish());
            } else if (v instanceof NodeVertex) {
                String nt = vocab.getWord(((NodeVertex) v).getNode().lhs);
                return String.format("%s{%d-%d}", nt, ((NodeVertex) v).getNode().i,
                        ((NodeVertex) v).getNode().j);
            } else {
                Rule r = ((HyperEdgeVertex) v).getHyperEdge().getRule();
                if (r != null) {
                    String lhs = vocab.getWord(r.getLHS());
                    String french = vocab.getWords(r.getFrench());
                    String english = vocab.getWords(r.getEnglish());
                    return String.format("%s -> { %s ; %s }", lhs, french, english);
                } else
                    return "";
            }/*from ww w. j  a v  a  2s. c o m*/
        }
    };
}

From source file:graphView.JungTreeViewer.java

public JungTreeViewer(ArrayList<String> versions) {

    // Added by Minh Nguyen for CS550 Term Project, KAIST, 2014
    Transformer<String, Shape> vertexSize = new Transformer<String, Shape>() {
        public Shape transform(String str) {
            Ellipse2D circle = new Ellipse2D.Double(-15, -15, 30, 30);
            // in this case, the vertex is twice as large
            return AffineTransform.getScaleInstance(1.5, 1.5).createTransformedShape(circle);
        }/*from w  ww . j a v  a2s . c om*/
    };

    Transformer<String, Paint> vertexPaint = new Transformer<String, Paint>() {
        @Override
        public Paint transform(String str) {
            Color green = new Color(0, 1, 0, 0.1f);
            String[] chars = str.split("\\.");
            if (chars.length == 1) {
                return Color.blue;
            } else {
                return green;
            }
        }
    };

    // create a simple graph for the demo
    graph = new DelegateForest<String, Integer>();

    createTree(versions);

    layout = new TreeLayout<String, Integer>(graph);
    radialLayout = new RadialTreeLayout<String, Integer>(graph);
    radialLayout.setSize(new Dimension(700, 700));
    vv = new VisualizationViewer<String, Integer>(layout, new Dimension(700, 700)); //jy: size
    vv.setBackground(Color.white);
    vv.getRenderContext().setEdgeShapeTransformer(new EdgeShape.Line());
    vv.getRenderContext().setVertexLabelTransformer(new ToStringLabeller());
    // add a listener for ToolTips
    vv.setVertexToolTipTransformer(new ToStringLabeller());
    //vv.getRenderContext().setArrowFillPaintTransformer(new ConstantTransformer(Color.lightGray));
    vv.getRenderContext().setArrowFillPaintTransformer(new ConstantTransformer(Color.BLACK));
    vv.getRenderContext().setVertexFillPaintTransformer(vertexPaint);
    //vv.getRenderContext().setVertexShapeTransformer(vertexSize);      

    rings = new Rings();

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

    final DefaultModalGraphMouse graphMouse = new DefaultModalGraphMouse();

    vv.setGraphMouse(graphMouse);

    JComboBox<String> 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());
        }
    });

    JToggleButton radial = new JToggleButton("Radial");
    radial.addItemListener(new ItemListener() {

        public void itemStateChanged(ItemEvent e) {
            if (e.getStateChange() == ItemEvent.SELECTED) {

                LayoutTransition<String, Integer> lt = new LayoutTransition<String, Integer>(vv, layout,
                        radialLayout);
                Animator animator = new Animator(lt);
                animator.start();
                vv.getRenderContext().getMultiLayerTransformer().setToIdentity();
                vv.addPreRenderPaintable(rings);
            } else {
                LayoutTransition<String, Integer> lt = new LayoutTransition<String, Integer>(vv, radialLayout,
                        layout);
                Animator animator = new Animator(lt);
                animator.start();
                vv.getRenderContext().getMultiLayerTransformer().setToIdentity();
                vv.removePreRenderPaintable(rings);
            }
            vv.repaint();
        }
    });

    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(radial);
    controls.add(scaleGrid);
    controls.add(modeBox);

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

From source file:cl.b9.socialNetwork.jung.SNPajekNetWriter.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). /*  w  w  w.  j a v a2s .  c  om*/
 */
@SuppressWarnings("unchecked")
public void save(Graph<V, E> graph, Writer w, Transformer<V, String> vs, Transformer<E, Number> nev,
        Transformer<V, Point2D> vld, Transformer<V, String> shape) 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());
        }
        if (shape != null) {
            writer.write(" " + shape.transform(currentVertex) + " x_fact 1");
        }
        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.get(e).floatValue();
        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.get(e).floatValue();
        float weight = nev.transform(e).floatValue();
        writer.write(v1_id + " " + v2_id + " " + weight);
        writer.newLine();
    }
    writer.close();
}

From source file:au.edu.uwa.csse.plot.Clustering.java

private void setUpView(Graph graph) throws IOException {

    //Create a simple layout frame
    //specify the Fruchterman-Rheingold layout algorithm
    final AggregateLayout<Integer, Number> layout = new AggregateLayout<Integer, Number>(
            new FRLayout<Integer, Number>(graph));

    vv = new VisualizationViewer<Integer, Number>(layout);
    vv.setBackground(Color.white);
    vv.setVertexToolTipTransformer(Plot.vertexLabelTransformer);
    //Tell the renderer to use our own customized color rendering
    vv.getRenderContext()/*from  w w w  .  j  a va  2  s . c  o  m*/
            .setVertexFillPaintTransformer(MapTransformer.<Integer, Paint>getInstance(vertexPaints));
    vv.getRenderContext().setVertexDrawPaintTransformer(new Transformer<Integer, Paint>() {
        public Paint transform(Integer v) {
            if (vv.getPickedVertexState().isPicked(v)) {
                return Color.cyan;
            } else {
                return Color.BLACK;
            }
        }
    });

    vv.getRenderContext().setEdgeDrawPaintTransformer(MapTransformer.<Number, Paint>getInstance(edgePaints));

    vv.getRenderContext().setEdgeStrokeTransformer(new Transformer<Number, Stroke>() {
        protected final Stroke THIN = new BasicStroke(1);
        protected final Stroke THICK = new BasicStroke(2);

        public Stroke transform(Number e) {
            Paint c = edgePaints.get(e);
            if (c == Color.LIGHT_GRAY)
                return THIN;
            else
                return THICK;
        }
    });

    //add restart button
    JButton scramble = new JButton("Restart");
    scramble.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            Layout layout = vv.getGraphLayout();
            layout.initialize();
            Relaxer relaxer = vv.getModel().getRelaxer();
            if (relaxer != null) {
                relaxer.stop();
                relaxer.prerelax();
                relaxer.relax();
            }
        }

    });

    DefaultModalGraphMouse gm = new DefaultModalGraphMouse();
    vv.setGraphMouse(gm);

    final JToggleButton groupVertices = new JToggleButton("Group Clusters");

    //Create slider to adjust the number of edges to remove when clustering
    final JSlider edgeBetweennessSlider = new JSlider(JSlider.HORIZONTAL);
    edgeBetweennessSlider.setBackground(Color.WHITE);
    edgeBetweennessSlider.setPreferredSize(new Dimension(210, 50));
    edgeBetweennessSlider.setPaintTicks(true);
    edgeBetweennessSlider.setMaximum(graph.getEdgeCount());
    edgeBetweennessSlider.setMinimum(0);
    edgeBetweennessSlider.setValue(0);
    edgeBetweennessSlider.setMajorTickSpacing(10);
    edgeBetweennessSlider.setPaintLabels(true);
    edgeBetweennessSlider.setPaintTicks(true);

    //      edgeBetweennessSlider.setBorder(BorderFactory.createLineBorder(Color.black));
    //TO DO: edgeBetweennessSlider.add(new JLabel("Node Size (PageRank With Priors):"));
    //I also want the slider value to appear
    final JPanel eastControls = new JPanel();
    eastControls.setOpaque(true);
    eastControls.setLayout(new BoxLayout(eastControls, BoxLayout.Y_AXIS));
    eastControls.add(Box.createVerticalGlue());
    eastControls.add(edgeBetweennessSlider);

    final String COMMANDSTRING = "Edges removed for clusters: ";
    final String eastSize = COMMANDSTRING + edgeBetweennessSlider.getValue();

    final TitledBorder sliderBorder = BorderFactory.createTitledBorder(eastSize);
    eastControls.setBorder(sliderBorder);
    //eastControls.add(eastSize);
    eastControls.add(Box.createVerticalGlue());

    groupVertices.addItemListener(new ItemListener() {
        public void itemStateChanged(ItemEvent e) {
            clusterAndRecolor(layout, edgeBetweennessSlider.getValue(), similarColors,
                    e.getStateChange() == ItemEvent.SELECTED);
            vv.repaint();
        }
    });

    clusterAndRecolor(layout, 0, similarColors, groupVertices.isSelected());

    edgeBetweennessSlider.addChangeListener(new ChangeListener() {
        public void stateChanged(ChangeEvent e) {
            JSlider source = (JSlider) e.getSource();
            if (!source.getValueIsAdjusting()) {
                int numEdgesToRemove = source.getValue();
                clusterAndRecolor(layout, numEdgesToRemove, similarColors, groupVertices.isSelected());
                sliderBorder.setTitle(COMMANDSTRING + edgeBetweennessSlider.getValue());
                eastControls.repaint();
                vv.validate();
                vv.repaint();
            }
        }
    });

    Container content = getContentPane();
    content.add(new GraphZoomScrollPane(vv));
    JPanel south = new JPanel();
    JPanel grid = new JPanel(new GridLayout(2, 1));
    grid.add(scramble);
    grid.add(groupVertices);
    south.add(grid);
    south.add(eastControls);
    JPanel p = new JPanel();
    p.setBorder(BorderFactory.createTitledBorder("Mouse Mode"));
    p.add(gm.getModeComboBox());
    south.add(p);
    content.add(south, BorderLayout.SOUTH);
}

From source file:com.syncleus.dann.graph.jung.BrainPanel.java

@Override
protected void initVis(VisualizationViewer<N, S> vis) {
    vis.getRenderContext().setVertexLabelTransformer(new NeuronLabeller());
    vis.getRenderContext().setEdgeLabelTransformer(new SynapseLabeller());
    vis.getRenderContext().setVertexFillPaintTransformer(new Transformer<N, Paint>() {

        public Paint transform(N n) {
            if (n instanceof InputNeuron) {
                return Color.MAGENTA;
            } else if (n instanceof OutputNeuron) {
                return Color.GREEN;
            } else {
                return Color.GRAY;
            }/*from  w w w  . j a v a 2s.c om*/
        }
    });
    vis.getRenderContext().setVertexShapeTransformer(new Transformer<N, Shape>() {

        public Shape transform(N n) {
            float s = 0.5f;
            if (n instanceof OutputNeuron) {
                OutputNeuron aan = (OutputNeuron) n;
                s = (float) Math.abs(aan.getOutput());
            } else if (n instanceof InputNeuron) {
                InputNeuron aan = (InputNeuron) n;
                s = (float) Math.abs(aan.getInput());
            }
            int w = (int) (s * 44.0);
            int h = (int) (s * 44.0);
            int x = -w / 2;
            int y = -h / 2;
            return new Rectangle2D.Float(x, y, w, h);
        }
    });
    vis.getRenderContext().setEdgeStrokeTransformer(new Transformer<S, Stroke>() {

        public Stroke transform(S i) {
            return new BasicStroke((int) ((Math.abs(i.getWeight())) * 8.0));
        }
    });
    vis.getRenderContext().setEdgeDrawPaintTransformer(new Transformer<S, Paint>() {

        public Paint transform(S syn) {
            float b = (float) Math.abs(syn.getWeight());
            float s = 0.8f;
            float h = syn.getWeight() < 0 ? 0.6f : 0.9f;
            return Color.getHSBColor(h, s, b);
        }
    });

}

From source file:drcl.inet.sensorsim.drl.demo.DRLDemo.java

private void initDemo() {
    setLayout(new BorderLayout());

    /*map.put("0",new double[]{550.0,350.0});
    map.put("1",new double[]{450.0,250.0});
    map.put("2",new double[]{450.0,450.0});
    map.put("3",new double[]{350.0,350.0});
    map.put("4",new double[]{360.0,340.0});
    map.put("5",new double[]{300.0,300.0});
    map.put("6",new double[]{250.0,450.0});
    map.put("7",new double[]{150.0,350.0});
    map.put("8",new double[]{270.0,325.0});
    map.put("9",new double[]{251.0,270.0});*/

    // create a simple graph for the demo
    graph = new DirectedSparseMultigraph<Integer, Number>();

    Dimension layoutSize = new Dimension(800, 800);

    layout = new StaticLayout<Integer, Number>(graph,
            new ChainedTransformer(new Transformer[] { new NodeTransformer(), new LatLonPixelTransformer() }));

    layout.setSize(layoutSize);/*from  w w  w.  j  a v  a2  s.c  om*/
    vv = new VisualizationViewer<Integer, Number>(layout, new Dimension(400, 200));

    vv.getRenderer()
            .setVertexRenderer(new GradientVertexRenderer<Integer, Number>(Color.white, Color.red, false));
    vv.getRenderContext().setVertexShapeTransformer(new VertexShapeSizeAspect(graph));
    // add my listeners for ToolTips
    vv.setVertexToolTipTransformer(new Transformer<Integer, String>() {
        public String transform(Integer v) {
            return nodeTypes.get(v) + "-" + v + "[" + DRLDiffApp.doubleArrToString(map.get(v)) + "]"
                    + ",Energy=" + nodeStats[v].getCurrEnergy();
        }
    });
    vv.setEdgeToolTipTransformer(new Transformer<Number, String>() {
        public String transform(Number edge) {
            return "E" + graph.getEndpoints(edge).toString();
        }
    });

    vv.getRenderContext().setVertexLabelTransformer(new Transformer<Integer, String>() {
        public String transform(Integer v) {
            return nodeTypes.get(v) + "-" + v;
        }
    });
    vv.getRenderer().getVertexLabelRenderer().setPositioner(new InsidePositioner());
    vv.getRenderer().getVertexLabelRenderer().setPosition(Renderer.VertexLabel.Position.E);

    final GraphZoomScrollPane panel = new GraphZoomScrollPane(vv);
    add(panel);
    final AbstractModalGraphMouse graphMouse = new DefaultModalGraphMouse();
    vv.setGraphMouse(graphMouse);

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

    final ScalingControl scaler = new CrossoverScalingControl();

    //        vv.scaleToLayout(scaler);

    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());
        }
    });

    JButton reset = new JButton("reset");
    reset.addActionListener(new ActionListener() {

        public void actionPerformed(ActionEvent e) {
            vv.getRenderContext().getMultiLayerTransformer().getTransformer(Layer.LAYOUT).setToIdentity();
            vv.getRenderContext().getMultiLayerTransformer().getTransformer(Layer.VIEW).setToIdentity();
        }
    });

    JPanel controls = new JPanel();
    controls.add(plus);
    controls.add(minus);
    controls.add(reset);
    add(controls, BorderLayout.SOUTH);
}

From source file:edu.uci.ics.jung.samples.PerspectiveTransformerDemo.java

/**
 * create an instance of a simple graph with controls to
 * demo the zoom and perspective features.
 * //  ww w  . j  a v a 2 s . c  o m
 */
@SuppressWarnings("serial")
public PerspectiveTransformerDemo() {

    // create a simple graph for the demo
    graph = TestGraphs.getOneComponentGraph();

    graphLayout = new FRLayout<String, Number>(graph);
    ((FRLayout<String, Number>) graphLayout).setMaxIterations(1000);

    Dimension preferredSize = new Dimension(600, 600);
    Map<String, Point2D> map = new HashMap<String, Point2D>();
    Transformer<String, Point2D> vlf = TransformerUtils.mapTransformer(map);
    grid = this.generateVertexGrid(map, preferredSize, 25);
    gridLayout = new StaticLayout<String, Number>(grid, vlf, preferredSize);

    final VisualizationModel<String, Number> visualizationModel = new DefaultVisualizationModel<String, Number>(
            graphLayout, preferredSize);
    vv = new VisualizationViewer<String, Number>(visualizationModel, preferredSize);
    PickedState<Number> pes = vv.getPickedEdgeState();
    vv.getRenderContext()
            .setEdgeDrawPaintTransformer(new PickableEdgePaintTransformer<Number>(pes, Color.black, Color.red));
    vv.getRenderContext().setVertexShapeTransformer(new Transformer<String, Shape>() {

        public Shape transform(String v) {
            return new Rectangle2D.Float(-10, -10, 20, 20);
        }
    });
    vv.setBackground(Color.white);

    // add a listener for ToolTips
    vv.setVertexToolTipTransformer(new ToStringLabeller<String>());

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

    /**
     * the regular graph mouse for the normal view
     */
    final DefaultModalGraphMouse<Number, Number> graphMouse = new DefaultModalGraphMouse<Number, Number>();

    vv.setGraphMouse(graphMouse);

    viewSupport = new PerspectiveViewTransformSupport<String, Number>(vv);
    layoutSupport = new PerspectiveLayoutTransformSupport<String, Number>(vv);

    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, 0.9f, vv.getCenter());
        }
    });
    final JSlider horizontalSlider = new JSlider(-120, 120, 0) {

        /* (non-Javadoc)
         * @see javax.swing.JComponent#getPreferredSize()
         */
        @Override
        public Dimension getPreferredSize() {
            return new Dimension(80, super.getPreferredSize().height);
        }
    };

    final JSlider verticalSlider = new JSlider(-120, 120, 0) {

        /* (non-Javadoc)
         * @see javax.swing.JComponent#getPreferredSize()
         */
        @Override
        public Dimension getPreferredSize() {
            return new Dimension(super.getPreferredSize().width, 80);
        }
    };
    verticalSlider.setOrientation(JSlider.VERTICAL);
    final ChangeListener changeListener = new ChangeListener() {

        public void stateChanged(ChangeEvent e) {
            int vval = -verticalSlider.getValue();
            int hval = horizontalSlider.getValue();

            Dimension d = vv.getSize();
            PerspectiveTransform pt = null;
            pt = PerspectiveTransform.getQuadToQuad(vval, hval, d.width - vval, -hval, d.width + vval,
                    d.height + hval, -vval, d.height - hval,

                    0, 0, d.width, 0, d.width, d.height, 0, d.height);

            viewSupport.getPerspectiveTransformer().setPerspectiveTransform(pt);
            layoutSupport.getPerspectiveTransformer().setPerspectiveTransform(pt);
            vv.repaint();
        }
    };
    horizontalSlider.addChangeListener(changeListener);
    verticalSlider.addChangeListener(changeListener);

    JPanel perspectivePanel = new JPanel(new BorderLayout());
    JPanel perspectiveCenterPanel = new JPanel(new BorderLayout());
    perspectivePanel.setBorder(BorderFactory.createTitledBorder("Perspective Controls"));
    final JButton center = new JButton("Center");
    center.addActionListener(new ActionListener() {

        public void actionPerformed(ActionEvent e) {
            horizontalSlider.setValue(0);
            verticalSlider.setValue(0);
        }
    });
    ButtonGroup radio = new ButtonGroup();
    JRadioButton normal = new JRadioButton("None");
    normal.addItemListener(new ItemListener() {
        public void itemStateChanged(ItemEvent e) {
            boolean selected = e.getStateChange() == ItemEvent.SELECTED;
            if (selected) {
                if (viewSupport != null) {
                    viewSupport.deactivate();
                }
                if (layoutSupport != null) {
                    layoutSupport.deactivate();
                }
            }
            center.setEnabled(!selected);
            horizontalSlider.setEnabled(!selected);
            verticalSlider.setEnabled(!selected);
        }
    });

    final JRadioButton perspectiveView = new JRadioButton("In View");
    perspectiveView.addItemListener(new ItemListener() {
        public void itemStateChanged(ItemEvent e) {
            viewSupport.activate(e.getStateChange() == ItemEvent.SELECTED);
        }
    });
    final JRadioButton perspectiveModel = new JRadioButton("In Layout");
    perspectiveModel.addItemListener(new ItemListener() {
        public void itemStateChanged(ItemEvent e) {
            layoutSupport.activate(e.getStateChange() == ItemEvent.SELECTED);
        }
    });

    radio.add(normal);
    radio.add(perspectiveModel);
    radio.add(perspectiveView);
    normal.setSelected(true);

    ButtonGroup graphRadio = new ButtonGroup();
    JRadioButton graphButton = new JRadioButton("Graph");
    graphButton.setSelected(true);
    graphButton.addItemListener(new ItemListener() {

        public void itemStateChanged(ItemEvent e) {
            if (e.getStateChange() == ItemEvent.SELECTED) {
                visualizationModel.setGraphLayout(graphLayout);
                vv.repaint();
            }
        }
    });
    JRadioButton gridButton = new JRadioButton("Grid");
    gridButton.addItemListener(new ItemListener() {

        public void itemStateChanged(ItemEvent e) {
            if (e.getStateChange() == ItemEvent.SELECTED) {
                visualizationModel.setGraphLayout(gridLayout);
                vv.repaint();
            }
        }
    });
    graphRadio.add(graphButton);
    graphRadio.add(gridButton);

    JPanel modePanel = new JPanel(new GridLayout(2, 1));
    modePanel.setBorder(BorderFactory.createTitledBorder("Display"));
    modePanel.add(graphButton);
    modePanel.add(gridButton);

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

    Container controls = new JPanel(new BorderLayout());
    JPanel zoomControls = new JPanel(new GridLayout(2, 1));
    zoomControls.setBorder(BorderFactory.createTitledBorder("Zoom"));
    JPanel perspectiveControls = new JPanel(new GridLayout(3, 1));
    zoomControls.add(plus);
    zoomControls.add(minus);
    perspectiveControls.add(normal);
    perspectiveControls.add(perspectiveModel);
    perspectiveControls.add(perspectiveView);

    controls.add(zoomControls, BorderLayout.WEST);
    controls.add(modePanel);
    perspectivePanel.add(perspectiveControls, BorderLayout.WEST);
    perspectiveCenterPanel.add(horizontalSlider, BorderLayout.SOUTH);
    perspectivePanel.add(verticalSlider, BorderLayout.EAST);
    perspectiveCenterPanel.add(center);
    perspectivePanel.add(perspectiveCenterPanel);
    controls.add(perspectivePanel, BorderLayout.EAST);

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

From source file:edu.uci.ics.jung.algorithms.scoring.TestBetweennessCentrality.java

public void testWeighted() {
    Graph<Integer, Character> graph = new DirectedSparseGraph<Integer, Character>();

    for (int i = 0; i < 5; i++)
        graph.addVertex(i);/*ww w. ja  va 2  s .com*/

    char edge = 'a';
    graph.addEdge(edge++, 0, 1);
    graph.addEdge(edge++, 0, 2);
    graph.addEdge(edge++, 2, 3);
    graph.addEdge(edge++, 3, 1);
    graph.addEdge(edge++, 1, 4);

    final int weights[] = { 1, 1, 1, 1, 1 };

    Transformer<Character, Integer> edge_weights = new Transformer<Character, Integer>() {
        public Integer transform(Character arg0) {
            return weights[arg0 - 'a'];
        }
    };

    BetweennessCentrality<Integer, Character> bc = new BetweennessCentrality<Integer, Character>(graph,
            edge_weights);
    //          new BetweennessCentrality<Integer,Integer>(graph);

    System.out.println("scoring");
    System.out.println("(weighted)");
    System.out.println("vertices:");
    for (int i = 0; i < graph.getVertexCount(); i++)
        System.out.println(String.format("%d: %f", i, bc.getVertexScore(i)));
    System.out.println("edges:");
    for (int i = 0; i < graph.getEdgeCount(); i++) {
        char e = (char) (i + 'a');
        System.out.println(
                String.format("%c: (weight: %d), %f", e, edge_weights.transform(e), bc.getEdgeScore(e)));
    }
}

From source file:fr.univ_tours.li.mdjedaini.ideb.algo.user.UserModelPageRank.java

/**
 * /*from  w w  w .j a  v  a2  s.  co  m*/
 * @return 
 */
private Graph createGraph() {
    this.g = new DirectedSparseGraph<>();

    for (Pair<Query, Query> p_tmp : this.pairToCount.keySet()) {

        if (!g.containsVertex(p_tmp.getKey())) {
            g.addVertex(p_tmp.getKey());
        }

        if (!g.containsVertex(p_tmp.getValue())) {
            g.addVertex(p_tmp.getValue());
        }

        g.addEdge(p_tmp, p_tmp.getKey(), p_tmp.getValue());

    }

    // transforme un edge en poids
    Transformer<Pair<Query, Query>, Double> edgeWeight = new Transformer<Pair<Query, Query>, Double>() {
        public Double transform(Pair<Query, Query> arg_edge) {
            return pairToWeight.get(arg_edge);
        }
    };

    Double alpha = 0.15;
    this.pr = new PageRank(g, edgeWeight, alpha);
    this.pr.initialize();
    this.pr.evaluate();

    // faire 10 iterations
    for (int i = 0; i < 10; i++) {
        this.pr.step();
    }

    return g;
}

From source file:ega.projekt.graphDraw.DrawGraph.java

public static BasicVisualizationServer<Node, Edge> generatePanel(ega.projekt.graph.Graph dataGraph,
        int panelWidth, int panelHeight) {
    if (dataGraph.getEdges().isEmpty())
        System.out.println("Error initializing graph");
    DrawGraph graphView = new DrawGraph(dataGraph);
    Layout<Node, Edge> layout = new StaticLayout(graphView.drawGraph);
    for (Node n : graphView.drawGraph.getVertices()) {
        layout.setLocation(n, new java.awt.geom.Point2D.Double(n.getX(), n.getY()));
    }/*from   w w  w  . j a  va2  s .c  o  m*/
    layout.setSize(new Dimension(panelWidth, panelHeight));
    BasicVisualizationServer<Node, Edge> vv = new BasicVisualizationServer<>(layout);
    vv.setPreferredSize(new Dimension(panelWidth, panelHeight));
    Transformer<Node, Paint> vertexPaint = new Transformer<Node, Paint>() {
        public Paint transform(Node i) {
            return Color.GREEN;
        }
    };
    final Stroke edgeStroke = new BasicStroke(1.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER);
    Transformer<Edge, Stroke> edgeStrokeTransformer = new Transformer<Edge, Stroke>() {
        public Stroke transform(Edge e) {
            return edgeStroke;
        }
    };
    vv.getRenderContext().setVertexFillPaintTransformer(vertexPaint);
    vv.getRenderContext().setEdgeStrokeTransformer(edgeStrokeTransformer);
    vv.getRenderContext().setEdgeShapeTransformer(new EdgeShape.QuadCurve<Node, Edge>());
    vv.getRenderContext().setEdgeLabelTransformer(new Transformer<Edge, String>() {
        public String transform(Edge e) {
            return (e.getFlowString() + "/" + Integer.toString(e.getCapacity()));
        }
    });
    vv.getRenderContext().setVertexLabelTransformer(new Transformer<Node, String>() {
        public String transform(Node n) {
            return (Integer.toString(n.getID()));
        }
    });
    vv.getRenderer().getVertexLabelRenderer().setPosition(Renderer.VertexLabel.Position.CNTR);

    return vv;
}