Foro de elhacker.net

// SearchApplet.java //
 // This class is an abstract class for defining search // algorithm classes. // // Copyright Mark Watson, 1998. Open Source and Open Content. // 
 import java.awt.*; 
 import java.awt.event.*; 
 import java.util.Vector;
 abstract public class SearchApplet extends java.applet.Applet { 
     public void init() { 
         String width = getParameter("pwidth"); 
         if (width == null) { 
             xSizePixels = 80; } 
             else { 
                 xSizePixels = Integer.valueOf(width).intValue(); 
                } 
                String height = getParameter("pheight"); 
                if (height == null) {
                    ySizePixels = 80; 
                } 
                else { 
                    ySizePixels = Integer.valueOf(height).intValue(); 
                } 
                System.out.println("width=" + xSizePixels + ", height=" + ySizePixels); setLayout(null); 
                startChoice = new Choice(); 
                goalChoice = new Choice(); 
                for (int i=0; i<numNodes; i++) { 
                    startChoice.add(nodeNames[i]); 
                    goalChoice.add(nodeNames[i]); } 
                    startChoice.select(0); 
                    goalChoice.select(numNodes - 1); 
                    Label l1 = new Label("Starting node:"); 
                    Label l2 = new Label("Goal node:"); 
                    l1.setBounds(5, 10, 90, 24); 
                    startChoice.setBounds(100, 10, 50, 30); 
                    l2.setBounds(5, 50, 90, 24); 
                    goalChoice.setBounds(100, 50, 50, 30); 
                    timeDelayChoice = new Choice(); 
                    timeDelayChoice.add("No plot time delay"); 
                    timeDelayChoice.add("Plot time delay"); 
                    timeDelayChoice.setBounds(160, 10, 90, 24); 
                    timeDelayChoice.select(1); add(l1); 
                    add(l2); 
                    add(startChoice); 
                    add(goalChoice); 
                    add(timeDelayChoice); 
                    Button b = new Button("Run"); 
                    b.setBounds(160, 50, 90, 32); 
                    add(b); 
                    b.addMouseListener(new java.awt.event.MouseAdapter() 
                    { public void mouseClicked(MouseEvent me) { 
                        int i1 = startChoice.getSelectedIndex(); 
                        int i2 = goalChoice.getSelectedIndex(); 
                        startNodeIndex = i1; 
                        goalNodeIndex = i2; 
                        System.out.println("mouse clicked " + i1 + " " + i2); 
                        findPath(i1, i2); } } ); 
                        canvas = new Canvas(); 
                        //
                       // Panel pp = new Panel(); 
                        add(canvas); 
                        canvas.setBounds(5, 80, xSizePixels + 20, ySizePixels + 20); 
                        add(canvas); repaintPath(null, 0); 
                        setBackground(Color.white); 
                    } 
                    protected Choice startChoice, goalChoice, timeDelayChoice; 
                    private Canvas canvas; 
                    private int goalNodeIndex = -1, 
                    startNodeIndex = -1; 
                    public void repaintPath(int [] path, int num) { 
                        System.out.print("repaintPath("); 
                        boolean time_delay = timeDelayChoice.getSelectedIndex() == 1; 
                        for (int i=0; i<num; i++) { 
                            System.out.print(path[i]); if (i < (num - 1)) System.out.print(", "); 
                        } System.out.println(")"); 
                        Graphics g = canvas.getGraphics(); 
                        g.setColor(Color.black); 
                        float x_scale = (float)xSizePixels / (x_max - x_min); 
                        float y_scale = (float)ySizePixels / (y_max - y_min); 
                        // start by plotting nodes and links: 
                        for (int i=0; i<numLinks; i++) { 
                            int i1 = link_1[i]; 
                            int i2 = link_2[i]; 
                            int x1 = (int)(node_x[i1] * x_scale); 
                            int x2 = (int)(node_x[i2] * x_scale); 
                            int y1 = (int)(node_y[i1] * y_scale); 
                            int y2 = (int)(node_y[i2] * y_scale); 
                            g.drawLine(x1 + 10, y1 + 10, x2 + 10, y2 + 10); 
                            g.drawLine(x1 + 10, y1 + 11, x2 + 10, y2 + 11); } 
                            for (int i=0; i<numNodes; i++) { 
                                int x1 = (int)(node_x[i] * x_scale); 
                                int y1 = (int)(node_y[i] * y_scale); 
                                if (i == startNodeIndex) 
                                g.setColor(Color.green); 
                                else if (i == goalNodeIndex) 
                                g.setColor(Color.blue); 
                                else g.setColor(Color.black); 
                                paintNode(g, nodeNames[i], x1 + 10, y1 + 10); } 
                                if (path == null) 
                                return; 
                                // set line color to red: 
                                g.setColor(Color.red); 
                                for (int i=0; i<num - 1; i += 2) { 
                                    int x1 = (int)(node_x[path[i]] * x_scale); 
                                    int x2 = (int)(node_x[path[i+1]] * x_scale); 
                                    int y1 = (int)(node_y[path[i]] * y_scale); 
                                    int y2 = (int)(node_y[path[i+1]] * y_scale); 
                                    g.drawLine(x1 + 10, y1 + 10, x2 + 10, y2 + 10); 
                                    g.drawLine(x1 + 10, y1 + 11, x2 + 10, y2 + 11); } 
                                    if (time_delay) { 
                                        try { 
                                            Thread.sleep(1000); 
                                        } catch (Exception e) { } }
                                    } 
                                    public void repaintPath(int [] path) { 
                                        repaintPath(path, path.length); 
                                    } 
                                    protected void paintNode(Graphics g, String name, int x, int y) { 
                                        int len = name.length() * 10 + 6; 
                                        int x1 = x - (len / 2); 
                                        int x2 = x + (len / 2); 
                                        int y1 = y - 10; 
                                        int y2 = y + 10; 
                                        g.setColor(Color.cyan); 
                                        g.fill3DRect(x1, y1, len, 20, true); 
                                        g.setColor(Color.black); 
                                        g.drawString(name, x1 + 4, y2 - 6); 
                                    } 
                                    public void paint(Graphics g) { 
                                        super.paint(g); 
                                        repaintPath(null, 0); 
                                    } 
                                    public void addNode(String name, float x, float y) { 
                                        System.out.println("Adding node: " + name + ", " + x + ", " + y); 
                                        nodeNames[numNodes] = name; 
                                        node_x[numNodes] = x; 
                                        node_y[numNodes] = y; 
                                        numNodes++;
                                        if (x < x_min) 
                                        x_min = x; 
                                        if (x > x_max) 
                                        x_max = x; 
                                        if (y < y_min) 
                                        y_min = y; 
                                        if (y > y_max) 
                                        y_max = y; 
                                    } 
                                    public String getNodeName(int index) 
                                    { 
                                        try { 
                                            return nodeNames[index]; 
                                        } catch (Exception e) 
                                        { System.out.println("Error in getNodeName: " + e); 
                                        } return "no name"; 
                                        // error condition 
                                    } 
                                    public float getNodeX(int index) 
                                    { 
                                        try { 
                                            return node_x[index]; } 
                                            catch (Exception e) {
                                                System.out.println("Error in getNodePosition: " + e); } 
                                                return 0.0f; 
                                                // error condition 
                                            } 
                                            public float getNodeY(int index) { 
                                                try { 
                                                    return node_y[index]; } 
                                                    catch (Exception e) 
                                                    { 
                                                        System.out.println("Error in getNodePosition: " + e); 
                                                    } return 0.0f; 
                                                    // error condition 
                                                } 
                                                public float getPathLength(int index) { 
                                                    // currently unsued - for adding heuristics 
                                                    return lengths[index]; } 
                                                    public void addLink(int node1, int node2) { 
                                                        link_1[numLinks] = node1; 
                                                        link_2[numLinks] = node2; 
                                                        float dist_squared = (node_x[node1] - node_x[node2]) * (node_x[node1] - node_x[node2]) + (node_y[node1] - node_y[node2]) * (node_y[node1] - node_y[node2]); 
                                                        lengths[numLinks] = (float)Math.sqrt(dist_squared);
                                                        numLinks++; } 
                                                        public void addLink(String name1, String name2) { 
                                                            int index1 = -1, index2 = -1; 
                                                            for (int i=0; i<numNodes; i++) { 
                                                                if (name1.equals(nodeNames[i])) 
                                                                index1 = i; 
                                                                if (name2.equals(nodeNames[i])) 
                                                                index2 = i; 
                                                            } 
                                                            if (index1 != -1 && index2 != -1) 
                                                            addLink(index1, index2); 
                                                        } 
                                                        /** findPath - abstract method that is defined in subclasses */ 
                                                        abstract public int [] findPath(int node_1, int node_2); 
                                                        // return an array of node indices 
                                                        protected int getNodeIndex(String name) { 
                                                            for (int i=0; i<numNodes; i++) { 
                                                                if (name.equals(nodeNames[i])) 
                                                                return i; 
                                                            } 
                                                            return -1; 
                                                            // error condition 
                                                        }
                                                        final public static int MAX = 50; 
                                                        // max number of nodes and max number of links // for nodes: 
                                                        private String [] nodeNames = new String[MAX]; 
                                                        private float [] node_x = new float[MAX]; 
                                                        private float [] node_y = new float[MAX]; 
                                                        // for links between nodes: 
                                                        protected int [] link_1 = new int[MAX]; 
                                                        protected int [] link_2 = new int[MAX]; 
                                                        private float [] lengths = new float[MAX]; 
                                                        protected int numNodes = 0; 
                                                        protected int numLinks = 0; 
                                                        // For optional display of search progress: 
                                                        private int xSizePixels = 0, ySizePixels = 0; 
                                                        private float x_min = 0.0f, x_max = 0.1f; 
                                                        private float y_min = 0.0f, y_max = 0.1f; 
                                                    }