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:org.drugis.mtc.jags.JagsSyntaxModel.java

private String getDerivations() {
    Collection<String> lines = NetworkModel.transformTreatmentPairs(d_network,
            new Transformer<Pair<Treatment>, String>() {
                public String transform(Pair<Treatment> input) {
                    Treatment ti = input.getFirst();
                    Treatment tj = input.getSecond();
                    BasicParameter p = new BasicParameter(ti, tj);
                    BasicParameter q = new BasicParameter(tj, ti);
                    if (!d_pmtz.getParameters().contains(p) && !d_pmtz.getParameters().contains(q)) {
                        String e = expressRelativeEffect(ti, tj, s_rTransform);
                        return "\t`" + p + "` = function(x) { " + e + " }";
                    }/*from   www  .j av a 2s  .c  o  m*/
                    return null;
                }
            });
    CollectionUtils.filter(lines, PredicateUtils.notNullPredicate());
    return StringUtils.join(lines, ",\n");
}

From source file:org.drugis.mtc.NetworkBuilderTest.java

@Test
public void testIdTransform() {
    NoneNetworkBuilder<Integer> builder = new NoneNetworkBuilder<Integer>(new Transformer<Integer, String>() {
        public String transform(Integer input) {
            return StringUtils.repeat("A", input.intValue());
        }//  w ww .  j ava  2  s.  co  m
    }, new EmptyStringTransformer<Integer>());

    builder.add("1", 5);
    HashMap<Integer, Treatment> expected = new HashMap<Integer, Treatment>();
    expected.put(5, new Treatment("AAAAA"));
    assertEquals(expected, builder.getTreatmentMap());
}

From source file:org.drugis.mtc.NetworkBuilderTest.java

@Test
public void testDescriptionTransform() {
    NoneNetworkBuilder<Integer> builder = new NoneNetworkBuilder<Integer>(
            new NetworkBuilder.ToStringTransformer<Integer>(), new Transformer<Integer, String>() {
                public String transform(Integer input) {
                    return StringUtils.repeat("A", input.intValue());
                }//  ww  w  . ja  va2 s.  c o m
            });

    builder.add("1", 5);
    HashMap<Integer, Treatment> expected = new HashMap<Integer, Treatment>();
    expected.put(5, new Treatment("5", "AAAAA"));
    assertEquals(expected, builder.getTreatmentMap());
}

From source file:org.eclipse.titanium.graph.generators.GraphGenerator.java

/**
 * Constructor, note that after this method you must call
 * {@link #generateGraph()} to make the graph. The constructor only does
 * initialization.//from   w ww  .  jav  a 2s .  c  o m
 * 
 * @param project
 *            : The project to generate graph for
 * @param eHandler
 *            : An object that implements error handling capabilities
 */
public GraphGenerator(final IProject project, final ErrorHandler eHandler) {
    labeler = new Transformer<NodeDescriptor, String>() {
        @Override
        public String transform(final NodeDescriptor v) {
            return v.getDisplayName();
        }
    };

    this.project = project;
    if (eHandler == null) {
        errorHandler = new PrimitiveErrorHandler();
    } else {
        errorHandler = eHandler;
    }

    graphGenerator = new Job("Graph generator") {
        @Override
        protected IStatus run(final IProgressMonitor monitor) {
            try {
                createGraph();
            } catch (Exception ex) {
                errorHandler.reportException("Error while generating graph", ex);
            }

            return Status.OK_STATUS;
        }
    };
}

From source file:org.eclipse.titanium.graph.visualization.GraphHandler.java

/**
 * Saves a Jung graph to a Pajek .net file
 * /*from   w w  w . jav  a2  s  . c om*/
 * @param g
 *            : The graph to save
 * @param path
 *            : The save path
 * @throws BadLayoutException
 *             on file handling error and own inner problems
 */
public static void saveGraphToPajek(final Graph<NodeDescriptor, EdgeDescriptor> g, final String path)
        throws BadLayoutException {
    if (g == null) {
        throw new BadLayoutException("You must draw a graph before!", ErrorType.NO_OBJECT);
    }

    final Transformer<EdgeDescriptor, Number> edgeWeights = new Transformer<EdgeDescriptor, Number>() {
        @Override
        public Number transform(final EdgeDescriptor e) {
            return e.getWeight();
        }
    };

    try {
        final PajekNetWriter<NodeDescriptor, EdgeDescriptor> writer = new PajekNetWriter<NodeDescriptor, EdgeDescriptor>();
        writer.save(g, path, NODE_LABELER, edgeWeights);
    } catch (IOException e) {
        throw new BadLayoutException("An error occured during writing to the output file.", ErrorType.IO_ERROR,
                e);
    }
}

From source file:org.eclipse.titanium.graph.visualization.GraphHandler.java

/**
 * Exports the graph set for this class to a PNG file
 * /*from  w w w.java2 s.co  m*/
 * @param path
 *            : The PNG file's path
 * @param mode
 *            : The way of export, see {@link GraphHandler}
 *            <code>public static</code> fields for possible values (EXPORT_
 *            named fields)
 * @param size
 *            : This parameter sets the size of the exported image in pixels
 * @throws Exception
 *             on file handling error
 */
public void saveToImage(final String path, final ImageExportType mode) throws BadLayoutException {
    if (layout == null || actVisualisator == null) {
        throw new BadLayoutException("Either the layout or the visuaizer is not set (is null)",
                ErrorType.NO_OBJECT);
    }

    VisualizationViewer<NodeDescriptor, EdgeDescriptor> tempVisualisator = null;
    Dimension size = null;
    switch (mode) {
    case EXPORT_SEEN_GRAPH: {
        tempVisualisator = actVisualisator;
        size = actVisualisator.getPreferredSize();
    }
        break;
    case EXPORT_WHOLE_GRAPH: {
        layout = actVisualisator.getGraphLayout();
        if (size == null) {
            size = new Dimension(layout.getSize().width, layout.getSize().height);
        }

        final Transformer<NodeDescriptor, Point2D> trf = new Transformer<NodeDescriptor, Point2D>() {
            @Override
            public Point2D transform(final NodeDescriptor v) {
                return layout.transform(v);
            }
        };

        tempVisualisator = new VisualizationViewer<NodeDescriptor, EdgeDescriptor>(
                new LayoutBuilder(g, Layouts.LAYOUT_STATIC, size).transformer(trf).build());
        tempVisualisator.setPreferredSize(size);
        tempVisualisator.setSize(size);
        tempVisualisator.getRenderContext().setVertexLabelTransformer(NODE_LABELER);

        final GraphRenderer<NodeDescriptor, EdgeDescriptor> rnd = new GraphRenderer<NodeDescriptor, EdgeDescriptor>(
                NODE_LABELER, tempVisualisator.getPickedVertexState(), tempVisualisator.getPickedEdgeState());
        setNodeRenderer(rnd, tempVisualisator);
        tempVisualisator.getRenderer().getVertexLabelRenderer().setPosition(Position.CNTR);
        tempVisualisator.setBackground(Color.white);
        tempVisualisator.setDoubleBuffered(false);
    }
        break;
    case EXPORT_SATELLITE: {
        tempVisualisator = satView;
        size = tempVisualisator.getSize();
    }
        break;
    default:
        ErrorReporter.logError("Unexpected image export type " + mode);
        return;
    }

    BufferedImage image;
    final GUIErrorHandler errorHandler = new GUIErrorHandler();
    try {
        image = new BufferedImage(size.width, size.height, BufferedImage.TYPE_INT_RGB);
    } catch (OutOfMemoryError e) {
        final long needed = (long) size.width * (long) size.height * 4;
        String temp;
        if (needed < 1024) {
            temp = needed + " bytes";
        } else if (needed < 1024 * 1024) {
            temp = needed / 1024 + " Kbytes";
        } else {
            temp = needed / 1024 / 1024 + " Mbytes";
        }
        final String errorText = "Could not save an image of " + size.width + "*" + size.height
                + " size as there was not enough free memory (" + temp + ")";
        errorHandler.reportErrorMessage(errorText);
        ErrorReporter.logExceptionStackTrace(errorText, e);
        return;
    }
    final Graphics2D g2 = image.createGraphics();
    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    tempVisualisator.paint(g2);
    g2.dispose();
    try {
        ImageIO.write(image, "png", new File(path));
    } catch (IOException e) {
        final String message = "Error while writing to file" + path;
        ErrorReporter.logExceptionStackTrace(message, e);
        errorHandler.reportException(message, e);
    }
}

From source file:org.eknet.neoswing.view.DefaultVisualizationViewFactory.java

@Override
public VisualizationViewer<Vertex, Edge> createViewer(Graph<Vertex, Edge> graph, GraphDb db) {
    final VisualizationViewer<Vertex, Edge> vv = new VisualizationViewer<Vertex, Edge>(
            new FRLayout2<Vertex, Edge>(graph));
    vv.getModel().getRelaxer().setSleepTime(0);
    DefaultModalGraphMouse<Vertex, Edge> mouseSupport = new DefaultModalGraphMouse<Vertex, Edge>();
    final GraphModel model = new SimpleGraphModel(graph, vv, db);
    addMousePlugins(mouseSupport, model);
    vv.setGraphMouse(mouseSupport);/*from   ww  w .jav a2 s.  c  o  m*/
    vv.addKeyListener(mouseSupport.getModeKeyListener());
    vv.setToolTipText("<html><center>Type 'p' for Pick mode<p>Type 't' for Transform mode");

    VertexLabelAsShapeRenderer<Vertex, Edge> vertexShape = new VertexLabelAsShapeRenderer<Vertex, Edge>(
            vv.getRenderContext()) {
        @Override
        public Shape transform(Vertex v) {
            Rectangle rect = (Rectangle) super.transform(v);
            return new RoundRectangle2D.Double(rect.x - 3, rect.y - 3, rect.width + 7, rect.height + 7, 10, 10);
        }
    };

    vertexShape.setPosition(Renderer.VertexLabel.Position.CNTR);
    vv.setBackground(Color.WHITE);
    vv.getRenderContext().setVertexShapeTransformer(vertexShape);
    vv.getRenderContext().setVertexLabelTransformer(new VertexTransformer(model));
    vv.getRenderer().setVertexLabelRenderer(vertexShape);
    vv.getRenderContext().setVertexFillPaintTransformer(new Transformer<Vertex, Paint>() {
        private Color nodefill = Color.getHSBColor(207, 19, 97);

        @Override
        public Paint transform(Vertex v) {
            //        if (v.getId() == 0) {
            //          return Color.green;
            //        }
            return nodefill;
        }
    });

    vv.getRenderContext().setEdgeLabelTransformer(new Transformer<Edge, String>() {

        private final WeakHashMap<Object, String> cache = new WeakHashMap<Object, String>();

        @Override
        public String transform(final Edge e) {
            String s = cache.get(e.getId());
            if (s == null) {
                s = "<null>";
                GraphDb.Tx tx = model.getDatabase().beginTx();
                try {
                    Edge edge = model.getDatabase().lookupEdge(e.getId());
                    s = edge.getLabel();
                    tx.success();
                    cache.put(edge.getId(), s);
                } catch (Exception e1) {
                    log.error("Error obtaining edge label", e1);
                } finally {
                    tx.finish();
                }
            }
            return s;
        }
    });

    return vv;
}

From source file:org.encog.workbench.tabs.visualize.bayesian.BayesianStructureTab.java

public BayesianStructureTab(BayesianNetwork method) {
    super(null);/*from ww w  .j a  v a  2 s  .  co m*/

    // Graph<V, E> where V is the type of the vertices
    // and E is the type of the edges
    this.graph = buildGraph(method);

    Layout<DrawnEvent, DrawnEventConnection> layout = new KKLayout(graph);

    vv = new VisualizationViewer<DrawnEvent, DrawnEventConnection>(layout);

    vv.getRenderer().getVertexLabelRenderer().setPosition(Renderer.VertexLabel.Position.CNTR);
    vv.getRenderContext().setVertexLabelTransformer(new ToStringLabeller<DrawnEvent>());
    vv.getRenderer().getVertexLabelRenderer().setPositioner(new InsidePositioner());
    vv.getRenderer().getVertexLabelRenderer().setPosition(Renderer.VertexLabel.Position.N);

    vv.setVertexToolTipTransformer(new Transformer<DrawnEvent, String>() {
        public String transform(DrawnEvent edge) {
            return edge.getToolTip();
        }
    });

    Transformer<DrawnEvent, Paint> vertexPaint = new Transformer<DrawnEvent, Paint>() {
        public Paint transform(DrawnEvent neuron) {
            return Color.white;
        }
    };

    final GraphZoomScrollPane panel = new GraphZoomScrollPane(vv);
    this.setLayout(new BorderLayout());
    add(panel, BorderLayout.CENTER);
    final AbstractModalGraphMouse graphMouse = new DefaultModalGraphMouse();
    vv.setGraphMouse(graphMouse);

    vv.addKeyListener(graphMouse.getModeKeyListener());
    vv.getRenderContext().setVertexFillPaintTransformer(vertexPaint);

    final ScalingControl scaler = new CrossoverScalingControl();

    Class[] combos = getCombos();
    final JComboBox jcb = new JComboBox(combos);
    // use a renderer to shorten the layout name presentation
    jcb.setRenderer(new DefaultListCellRenderer() {
        public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected,
                boolean cellHasFocus) {
            String valueString = value.toString();
            valueString = valueString.substring(valueString.lastIndexOf('.') + 1);
            return super.getListCellRendererComponent(list, valueString, index, isSelected, cellHasFocus);
        }
    });
    jcb.addActionListener(new LayoutChooser(jcb, vv));
    jcb.setSelectedItem(FRLayout.class);

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

    JComboBox modeBox = graphMouse.getModeComboBox();
    modeBox.addItemListener(((DefaultModalGraphMouse<Integer, Number>) vv.getGraphMouse()).getModeListener());

    JPanel controls = new JPanel();
    controls.setLayout(new FlowLayout(FlowLayout.LEFT));
    controls.add(plus);
    controls.add(minus);
    controls.add(reset);
    controls.add(modeBox);
    controls.add(jcb);
    Border border = BorderFactory.createEtchedBorder();
    controls.setBorder(border);
    add(controls, BorderLayout.NORTH);

}

From source file:org.encog.workbench.tabs.visualize.epl.EPLTreeTab.java

public EPLTreeTab(final EncogProgram prg) {
    super(null);//from   www .  ja  v a 2  s . c o m

    // Graph<V, E> where V is the type of the vertices
    // and E is the type of the edges
    // Graph<V, E> where V is the type of the vertices 
    // and E is the type of the edges
    this.graph = new DelegateForest<ProgramNode, Integer>(
            new DirectedOrderedSparseMultigraph<ProgramNode, Integer>());

    buildGraph(prg);
    // Add some vertices. From above we defined these to be type Integer.
    // The Layout<V, E> is parameterized by the vertex and edge types
    TreeLayout<ProgramNode, Integer> treeLayout = new TreeLayout<ProgramNode, Integer>(graph);

    Transformer<ProgramNode, Paint> vertexPaint = new Transformer<ProgramNode, Paint>() {
        public Paint transform(ProgramNode v) {
            return Color.white;
        }
    };

    //layout.setSize(new Dimension(5000,5000)); // sets the initial size of the space
    // The BasicVisualizationServer<V,E> is parameterized by the edge types
    //BasicVisualizationServer<DrawnNeuron, DrawnConnection> vv = new BasicVisualizationServer<DrawnNeuron, DrawnConnection>(
    //      layout);

    //Dimension d = new Dimension(600,600);

    vv = new VisualizationViewer<ProgramNode, Integer>(treeLayout, new Dimension(600, 600));

    //vv.setPreferredSize(d); //Sets the viewing area size

    vv.getRenderer().getVertexLabelRenderer().setPosition(Renderer.VertexLabel.Position.CNTR);
    vv.getRenderContext().setVertexLabelTransformer(new Transformer<ProgramNode, String>() {

        @Override
        public String transform(ProgramNode node) {
            ProgramExtensionTemplate temp = node.getTemplate();
            if (temp == StandardExtensions.EXTENSION_VAR_SUPPORT) {
                int varIndex = (int) node.getData()[0].toIntValue();
                return prg.getVariables().getVariableName(varIndex);
            } else if (temp == StandardExtensions.EXTENSION_CONST_SUPPORT) {
                ExpressionValue expr = node.getData()[0];
                if (expr.isFloat()) {
                    return Format.formatDouble(expr.toFloatValue(), 2);
                } else {
                    return node.getData()[0].toStringValue();
                }
            } else if (node.getTemplate().getNodeType().isOperator()) {
                return node.getTemplate().getName();
            } else {
                return node.getTemplate().getName() + "()";
            }

        }
    });

    vv.setVertexToolTipTransformer(new ToStringLabeller<ProgramNode>());

    vv.setVertexToolTipTransformer(new Transformer<ProgramNode, String>() {
        public String transform(ProgramNode node) {
            ProgramExtensionTemplate temp = node.getTemplate();
            if (temp == StandardExtensions.EXTENSION_CONST_SUPPORT) {
                return node.getData()[0].toStringValue();
            } else {
                return null;
            }
        }
    });

    /*vv.setEdgeToolTipTransformer(new Transformer<DrawnConnection,String>() {
       public String transform(DrawnConnection edge) {
    return edge.getToolTip();
       }});*/

    final GraphZoomScrollPane panel = new GraphZoomScrollPane(vv);
    this.setLayout(new BorderLayout());
    add(panel, BorderLayout.CENTER);
    final AbstractModalGraphMouse graphMouse = new DefaultModalGraphMouse<ProgramNode, Integer>();
    vv.setGraphMouse(graphMouse);
    vv.getRenderContext().setVertexFillPaintTransformer(vertexPaint);
    vv.getRenderContext().setEdgeShapeTransformer(new EdgeShape.Line());
    vv.getRenderContext().setEdgeArrowPredicate(new Predicate() {
        @Override
        public boolean evaluate(Object arg0) {
            // TODO Auto-generated method stub
            return false;
        }
    });
    Predicate d;

    vv.addKeyListener(graphMouse.getModeKeyListener());

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

    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.setLayout(new FlowLayout(FlowLayout.LEFT));
    controls.add(plus);
    controls.add(minus);
    controls.add(reset);
    Border border = BorderFactory.createEtchedBorder();
    controls.setBorder(border);
    add(controls, BorderLayout.NORTH);

}

From source file:org.encog.workbench.tabs.visualize.structure.GenomeStructureTab.java

public GenomeStructureTab(NEATGenome genome) {
    super(null);/*from w w w .j av a 2s .  c  o  m*/
    this.genome = genome;

    // Graph<V, E> where V is the type of the vertices
    // and E is the type of the edges
    Graph<DrawnNeuron, DrawnConnection> g = null;
    g = buildGraph(genome);

    if (g == null) {
        throw new WorkBenchError("Can't visualize genome");
    }

    Transformer<DrawnNeuron, Point2D> staticTranformer = new Transformer<DrawnNeuron, Point2D>() {

        public Point2D transform(DrawnNeuron n) {
            int x = (int) (n.getX() * 600);
            int y = (int) (n.getY() * 300);

            Point2D result = new Point(x + 32, y);
            return result;
        }
    };

    Transformer<DrawnNeuron, Paint> vertexPaint = new Transformer<DrawnNeuron, Paint>() {
        public Paint transform(DrawnNeuron neuron) {
            switch (neuron.getType()) {
            case Bias:
                return Color.yellow;
            case Input:
                return Color.white;
            case Output:
                return Color.green;
            case Context:
                return Color.cyan;
            case Linear:
                return Color.blue;
            case Sigmoid:
                return Color.magenta;
            case Gaussian:
                return Color.cyan;
            case SIN:
                return Color.gray;
            default:
                return Color.red;
            }
        }

    };

    Transformer<DrawnConnection, Paint> edgePaint = new Transformer<DrawnConnection, Paint>() {
        public Paint transform(DrawnConnection connection) {
            if (connection.isContext()) {
                return Color.lightGray;
            } else {
                return Color.black;
            }
        }
    };

    // The Layout<V, E> is parameterized by the vertex and edge types
    StaticLayout<DrawnNeuron, DrawnConnection> layout = new StaticLayout<DrawnNeuron, DrawnConnection>(g,
            staticTranformer);

    layout.setSize(new Dimension(5000, 5000)); // sets the initial size of
    // the space
    // The BasicVisualizationServer<V,E> is parameterized by the edge types
    // BasicVisualizationServer<DrawnNeuron, DrawnConnection> vv = new
    // BasicVisualizationServer<DrawnNeuron, DrawnConnection>(
    // layout);

    // Dimension d = new Dimension(600,600);

    vv = new VisualizationViewer<DrawnNeuron, DrawnConnection>(layout);

    // vv.setPreferredSize(d); //Sets the viewing area size

    vv.getRenderer().getVertexLabelRenderer().setPosition(Renderer.VertexLabel.Position.CNTR);
    vv.getRenderContext().setVertexLabelTransformer(new ToStringLabeller());
    vv.getRenderContext().setVertexFillPaintTransformer(vertexPaint);
    vv.getRenderContext().setEdgeDrawPaintTransformer(edgePaint);
    vv.getRenderContext().setArrowDrawPaintTransformer(edgePaint);
    vv.getRenderContext().setArrowFillPaintTransformer(edgePaint);

    vv.setVertexToolTipTransformer(new ToStringLabeller());

    vv.setVertexToolTipTransformer(new Transformer<DrawnNeuron, String>() {
        public String transform(DrawnNeuron edge) {
            return edge.getToolTip();
        }
    });

    vv.setEdgeToolTipTransformer(new Transformer<DrawnConnection, String>() {
        public String transform(DrawnConnection edge) {
            return edge.getToolTip();
        }
    });

    final GraphZoomScrollPane panel = new GraphZoomScrollPane(vv);
    this.setLayout(new BorderLayout());
    add(panel, BorderLayout.CENTER);
    final AbstractModalGraphMouse graphMouse = new DefaultModalGraphMouse();
    vv.setGraphMouse(graphMouse);

    vv.addKeyListener(graphMouse.getModeKeyListener());

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

    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.setLayout(new FlowLayout(FlowLayout.LEFT));
    controls.add(plus);
    controls.add(minus);
    controls.add(reset);
    Border border = BorderFactory.createEtchedBorder();
    controls.setBorder(border);
    add(controls, BorderLayout.NORTH);
    add(new LegendPanel(true), BorderLayout.SOUTH);

}