root/trunk/GuiTest.java

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.util.*;
import javax.swing.*;
import java.io.IOException;

class GuiTest implements ActionListener, PointListener {

        JButton switchMapButton;
        JButton randomPathButton;
        JButton clearNodesButton;
        JGraphViewer graphViewer;
        Graph graph;

        TiledMap maps[];
        int mapIndex = 0;

        GuiTest(String[] args) {
                // make the graph
                graph = new Graph();

                //graph.createRegularGrid(33, 38, 100, 100, .1, .5);

                maps = new TiledMap[2];

                // the gif map
                maps[0] = new TiledMap(15, 13, 200, 200, AffineTransform.getScaleInstance(1.31,1.31));
                maps[0].setTreeUri("images/uiucmap/");
                maps[0].setExtension("png");
                if(args.length > 0) {
                        maps[0].setRootUri(args[0]);
                }

                Point2D.Double realPoints[] = {
                        new Point2D.Double(1844.4800000000002, 465.05),   // SouthEast corner of DCL (sidewalk int.)
                        new Point2D.Double(2445.77, 3461.0200000000004),  // lone building NE of Windsor and Lincoln
                        new Point2D.Double(463.74, 3537.0000000000005)    // Fork in the river NE of Windsor and Neil
                };
                Point2D.Double imagePoints[] = {
                        new Point2D.Double(1925.8119658119663, 553.1111111111112),
                        new Point2D.Double(2533.643811573166, 3690.2649325233588),
                        new Point2D.Double(460.7444267834348, 3762.0368672661193)
                };

                AffineTransform arialTransform = AffineTransformFactory.createTransform(imagePoints, realPoints);
                //AffineTransform arialTransform = AffineTransform.getScaleInstance(1.17,1.17);
                System.out.println(arialTransform.getScaleX());
                maps[1] = new TiledMap(20, 18, 200, 200, arialTransform);
                maps[1].setTreeUri("images/aerialmap/");
                maps[1].setExtension("jpg");
                if(args.length > 0) {
                        maps[1].setRootUri(args[0]);
                }

                for(int i = 0; i < realPoints.length; i++) {
                        graph.addNode(new PhysicalNode(graph.getUnusedNodeID(), realPoints[i].getX(), realPoints[i].getY()));
                }

                graphViewer = new JGraphViewer(graph, 1/1.31*1, 1/1.31*1, maps[0]);
                graphViewer.setPreferredSize(new Dimension(400,400));

                graphViewer.addPointListener(this);

                // here's an example of how to change how the graphViewer looks
                graphViewer.setBackground(Color.BLACK);
                graphViewer.setDefaultNodePainter(new PhysicalNodePainter(Color.RED, 5));
                graphViewer.setDefaultEdgePainter(new PhysicalEdgePainter(Color.DARK_GRAY, 4));
                graphViewer.setSelectedNodePainter(new PhysicalNodePainter(Color.GREEN, 7));
                graphViewer.setSelectedEdgePainter(new PhysicalEdgePainter(Color.GREEN, 7));

                graphViewer.setBorder(BorderFactory.createEmptyBorder(5, 5, 0, 5));

                // make some buttons
                switchMapButton = new JButton("Switch map");
                switchMapButton.addActionListener(this);

                randomPathButton = new JButton("Find a random path");
                randomPathButton.addActionListener(this);

                clearNodesButton = new JButton("Clear All Selected Nodes");
                clearNodesButton.addActionListener(this);

                // here's the top-level frame thingy
                JFrame frame = new JFrame("Pathways GUI Test");

                // new code using boxlayouts

                // contentPane contains the graphViewer and buttonPane, which
                // holds the buttons, and stacks them vertically
                Container contentPane = frame.getContentPane();
                contentPane.setLayout(new BoxLayout(contentPane, BoxLayout.PAGE_AXIS));
                contentPane.add(graphViewer);

                // this pane holds the buttons, and stacks them horizontally
                JPanel buttonPane = new JPanel();
                buttonPane.setLayout(new BoxLayout(buttonPane, BoxLayout.LINE_AXIS));
                buttonPane.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
                buttonPane.add(switchMapButton);
                buttonPane.add(Box.createRigidArea(new Dimension(5, 5)));
                buttonPane.add(randomPathButton);
                buttonPane.add(Box.createRigidArea(new Dimension(5, 5)));
                buttonPane.add(clearNodesButton);
                buttonPane.add(Box.createHorizontalGlue());

                contentPane.add(buttonPane);

                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.pack();
                frame.setVisible(true);
        }

        // called from the event-dispatching thread when a button is pressed
        public void actionPerformed(ActionEvent e) {
                // CASE: User presses "Switch Map"
                if(e.getSource().equals(switchMapButton)) {

                        mapIndex = (mapIndex + 1) % maps.length;
                        graphViewer.setBackgroundMap(maps[mapIndex]);
                }
                // CASE: User presses "Get a Random Path"
                else if(e.getSource().equals(randomPathButton)) {
                        graphViewer.setSelectedObject(null);
                        showBestPath((PhysicalNode)graph.getRandomNode(), (PhysicalNode)graph.getRandomNode());
                }
                // CASE: User presses "Clear All Selected Nodes"
                else if (  e.getSource().equals(clearNodesButton)  )    {
                        graphViewer.clearAllSpecialNodes();
                }
        }

        /********************************************
         *  pointReceived(MouseEvent event,
         *                Point2D.Double point)
         *
         *  DESCRIPTION--
         *      Whenever the mouse returns an event in the graph,
         *  this function will handle that event.
         *  Currently, the events supported are:
         *
         *  EVENTS--
         *      Clicking the graph: highlights the point
         *  nearest to where you clicked.
         *
         *      Shift-clicking the graph: highlights the
         *  path to where you just clicked from the first
         *  node, or just highlights a node if nothing's
         *  highlighted yet.
         ********************************************/

        public PhysicalNode oldDestination;

        public void pointReceived(MouseEvent event, Point2D.Double point) {

                if(event.getID() == MouseEvent.MOUSE_PRESSED || event.getID() == MouseEvent.MOUSE_DRAGGED) {

                        // Pressing shift means we want a second point!
                        // ... and the path to it.
                        if ( event.isShiftDown()   &&
                             (graphViewer.getSelectedObject() instanceof PhysicalNode) )
                        {
                                PhysicalNode origin = (PhysicalNode)graphViewer.getSelectedObject();
                                PhysicalNode destination = graph.getClosestNode(point);
                                if(destination.equals(oldDestination)) return;
                                showBestPath(origin, destination);
                                oldDestination = destination;
                        }

                        // If shift wasn't pressed or the origin wasn't defined,
                        // act independently of shift key.
                        // Highlight the nearest point.
                        else
                        {

                                // For point-matching purposes
                                System.out.println("Real coordinates: (" + point.getX() + ", " + point.getY() + ")");
                                Point2D imagePoint = ((TiledMap)graphViewer.getBackgroundMap()).getRealToImage().transform(point, null);
                                System.out.println("Image coordinates: (" + imagePoint.getX() + ", " + imagePoint.getY() + ")");

                                //Oh, and let's add a point just for fun
                                graph.addNode(new PhysicalNode(graph.getUnusedNodeID(), point.getX(), point.getY()));
                                graphViewer.graphChanged();

                                Object object = graphViewer.closestMatch(point, 0);
                                //if(!(object instanceof PhysicalNode)) return;
                                graphViewer.setSelectedObject(object);
                        }
                }
        }

        private void showBestPath(PhysicalNode origin, PhysicalNode destination) {
                // do the search
                AStarSearch userSearch = new AStarSearch();
                userSearch.setOrigin(origin);
                userSearch.setDestination(destination);
                Path path = userSearch.computeBestPath();

                // show the path
                graphViewer.setPath(path);

                // for efficient .contains().
                //HashSet pathNodes = new HashSet(path.nodes);

                // display the searched nodes
                graphViewer.clearCustomObjectPainters();
                PhysicalNodePainter painter = new PhysicalNodePainter(Color.CYAN, 5);
                Iterator i = userSearch.getSearchedNodes().iterator();
                while(i.hasNext()) {
                        Node node = (Node)i.next();
                        if(!(node instanceof PhysicalNode)) continue;
                        //if(pathNodes.contains(node)) continue;
                        graphViewer.addCustomObjectPainter(node, 2, painter);
                }

                // display the opened nodes
                painter = new PhysicalNodePainter(Color.RED, 5);
                i = userSearch.getOpenNodes().iterator();
                while(i.hasNext()) {
                        Node node = (Node)i.next();
                        if(!(node instanceof PhysicalNode)) continue;
                        //if(pathNodes.contains(node)) continue;
                        graphViewer.addCustomObjectPainter(node, 2, painter);
                }

                graphViewer.addCustomObjectPainter(path.nodes.getLast(), 1, new PhysicalNodePainter(Color.MAGENTA, 5));
        }

        public static void main(String[] args) {
                //Schedule a job for the event-dispatching thread:
                //creating and showing this application's GUI.
                //yeah, painful, i know
                final String[] finalArgs = args;
                javax.swing.SwingUtilities.invokeLater(new Runnable() {
                        public void run() {
                                new GuiTest(finalArgs);

                                // for paint debugging purposes
                                //new javax.swing.Timer(1000, new ActionListener() {
                                //      public void actionPerformed(ActionEvent evt) {
                                //              System.out.println();
                                //      }
                                //}).start();
                        }
                });
        }
}