Application: gvSIG desktop

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

         *

         * Copyright (C) 2006 Instituto de Desarrollo Regional and Generalitat Valenciana.

         *

         * This program is free software; you can redistribute it and/or

         * modify it under the terms of the GNU General Public License

         * as published by the Free Software Foundation; either version 2

         * of the License, or (at your option) any later version.

         *

         * This program is distributed in the hope that it will be useful,

         * but WITHOUT ANY WARRANTY; without even the implied warranty of

         * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

         * GNU General Public License for more details.

         *

         * You should have received a copy of the GNU General Public License

         * along with this program; if not, write to the Free Software

         * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

         *

         * For more information, contact:

         *

         *  Generalitat Valenciana

         *   Conselleria d'Infraestructures i Transport

         *   Av. Blasco Iba?ez, 50

         *   46010 VALENCIA

         *   SPAIN

         *

         *      +34 963862235

         *   gvsig@gva.es

         *      www.gvsig.gva.es

         *

         *    or

         *

         *   Instituto de Desarrollo Regional (Universidad de Castilla La-Mancha)

         *   Campus Universitario s/n

         *   02071 Alabacete

         *   Spain

         *

         *   +34 967 599 200

         */

package org.gvsig.remotesensing.decisiontrees.gui;

import java.awt.Color;

import java.awt.Component;

import java.awt.Dimension;

import java.awt.geom.Rectangle2D;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import javax.swing.BorderFactory;

import javax.swing.JMenuItem;

import javax.swing.JPopupMenu;

import javax.swing.JScrollPane;

import javax.swing.JTabbedPane;

import org.gvsig.gui.beans.buttonspanel.ButtonsPanel;

import org.gvsig.gui.beans.defaultbuttonspanel.DefaultButtonsPanel;

import org.gvsig.remotesensing.decisiontrees.DecisionTreeNode;

import org.gvsig.remotesensing.decisiontrees.gui.listener.DecisionTreePanelListener;

import org.gvsig.remotesensing.gui.beans.OptionsPanel;

import org.jgraph.JGraph;

import org.jgraph.graph.DefaultEdge;

import org.jgraph.graph.DefaultGraphCell;

import org.jgraph.graph.DefaultGraphModel;

import org.jgraph.graph.DefaultPort;

import org.jgraph.graph.GraphConstants;

import org.jgraph.graph.GraphModel;

import com.iver.andami.PluginServices;

import com.iver.cit.gvsig.project.documents.view.gui.View;

/**

 * Panel para la herramienta de ?rboles de decisi?n.

 * 

 * @author Diego Guerrero Sevilla (diego.guerrero@uclm.es)

 *

 */

public class DecisionTreePanel extends DefaultButtonsPanel {

        /**

         * 

         */

        private static final long                 serialVersionUID         = 2800193252856199039L;

        private static final Color[]        colors  = new Color[] {Color.RED, Color.GREEN, Color.BLUE, Color.YELLOW, Color.MAGENTA, Color.CYAN,

                Color.ORANGE, Color.PINK, Color.WHITE, Color.BLACK};

        public  static final int                 POSITION_LEFT                 = 0;

        public  static final int                 POSITION_RIGHT                 = 1;

        private JGraph                                                   jGraph                                = null;

        private DecisionTreeDialog                  decisionTreeDialog         = null;

        private JScrollPane                                        scrollPane                        = null;

        private JPopupMenu                                        jPopupMenu                        = null;

        private JMenuItem                                         addMenuItem                        = null;

        private JMenuItem                                        deleteMenuItem                = null;

        private JMenuItem                                        executeMenuItem                = null;

        private DecisionTreeNode                         root                                = null;

        private DecisionTreePanelListener         listener                         = null;

        private DefaultGraphCell                         selectedCell                 = null;

        private View                                                view                                = null;

        private JTabbedPane                                        tabbedPanel                 = null; 

        private OptionsPanel                                outputOptionsPanel  = null;

        /**

         * Tabla de variables y sus asociaciones con las bandas(layerName[bandN]).

         */

        private HashMap                                                varTable                        = null;

        private HashMap                                                classColors                        = null;

        public DecisionTreePanel(DecisionTreeDialog decisionTreeDialog, View view) {

                super(ButtonsPanel.BUTTONS_APPLYCLOSE);

                this.view = view;

                this.decisionTreeDialog = decisionTreeDialog;

                initialize();

        }

        private void initialize() {

                initTree();

                reloadGraph();

//                add(getScrollPane());

                add(getTabbedPanel());

                listener = new DecisionTreePanelListener(this);

                getAddMenuItem().addActionListener(listener);

                getDeleteMenuItem().addActionListener(listener);

                getExecuteMenuItem().addActionListener(listener);

                getJGraph().addMouseListener(listener);

                this.addButtonPressedListener(listener);

        }

        private Component getTabbedPanel() {

                if (tabbedPanel==null){

                        tabbedPanel = new JTabbedPane();

                        tabbedPanel.addTab(PluginServices.getText(this, "arbol_decision"), getScrollPane());

                        tabbedPanel.addTab("opciones_salida", getOutputOptionsPanel());

                }

                return tabbedPanel;

        }

        /**

         * Crea el ?rbol de decisi?n inicial

         *

         */

        private void initTree() {

                root = new DecisionTreeNode();

                root.addChildren();

                root.setExpression("");

                root.getLeftChild().setClassID(generateClassId());

                root.getRightChild().setClassID(generateClassId());

        }

        public void initJGraph(){

                jGraph = null;

        }

        /**

         * Reconstruye el gr?fico a partir del ?rbol (root).

         *

         */

        public void reloadGraph(){

                /*

                 * Limpiar el gr?fico.

                 */

                getJGraph().getGraphLayoutCache().remove(getJGraph().getGraphLayoutCache().getCells(false, true, false, true),true,true);

                getJGraph().getGraphLayoutCache().reload();

                /*

                 * Construir el gr?fico a partir el ?rbol.

                 */

                insertCells(root,null,-1);

        }

        /**

         * Inserta recursivamente en el gr?fico los nodos y arcos el ?rbol que radica en <code>node</node>

         * en el gr?fico.

         * 

         * @param node nodo raiz del sub?rbol.

         * @param parent nodo antecesor del sub?rbol a insertar

         * @param position indica si <code>node</node> es el hijo izquierdo (0) o derecho (1) de <code>parent</code>

         */

        public void insertCells(DecisionTreeNode node, DefaultGraphCell parent, int position) {

                int x = 0;

                int y = 0;

                int w = 40;

                int h = 40;

                if(parent==null){

                        y = 10;

                        x = getScrollPane().getPreferredSize().width/2 - 20;

                }

                else{

                        int leftLevels = ((DecisionTreeNode)parent.getUserObject()).getLeftChild().getLevelsCount();

                        int rightLevels = ((DecisionTreeNode)parent.getUserObject()).getRightChild().getLevelsCount();

                        int minLevels = Math.min(leftLevels, rightLevels);

                        y = ((int)GraphConstants.getBounds(parent.getAttributes()).getMaxY())+50;

                        if(position==POSITION_LEFT)

                                x = ((int)GraphConstants.getBounds(parent.getAttributes()).getMinX())-w*minLevels;

                        else

                                x = ((int)GraphConstants.getBounds(parent.getAttributes()).getMinX())+(w)*minLevels;

                }

                DefaultGraphCell nodeVertex = createVertex(node, x, y, w, h, null, false);

                /*

                 * Si es un nodo final:

                 */

                if (node.isFinal()){

                        Color color = (Color)getClassColors().get(new Integer(node.getClassID()));

                        GraphConstants.setBackground(nodeVertex.getAttributes(), color);

                        GraphConstants.setOpaque(nodeVertex.getAttributes(), true);

                }

                getJGraph().getGraphLayoutCache().insert(nodeVertex);

                if (parent!=null){

                        String label = PluginServices.getText(this, "si");

                        if(position==POSITION_LEFT)

                                label = PluginServices.getText(this, "no");

                        DefaultEdge edge = createEdge(nodeVertex, parent, label);

                        getJGraph().getGraphLayoutCache().insert(edge);

                }

                if (node.getLeftChild()!=null){

                        insertCells(node.getLeftChild(), nodeVertex, POSITION_LEFT);

                }

                if (node.getRightChild()!=null){

                        insertCells(node.getRightChild(), nodeVertex, POSITION_RIGHT);

                }

        }

        private DefaultGraphCell createVertex(Object name, double x,

                        double y, double w, double h, Color bg, boolean raised) {

                        // Create vertex with the given name

                        DefaultGraphCell cell = new DefaultGraphCell(name);

                        // Set bounds

                        GraphConstants.setBounds(cell.getAttributes(),

                                        new Rectangle2D.Double(x, y, w, h));

                        // Set fill color

                        if (bg != null) {

                                GraphConstants.setGradientColor(

                                        cell.getAttributes(), bg);

                                GraphConstants.setOpaque(

                                        cell.getAttributes(), true);

                        }

                        // Set raised border

                        if (raised)

                                GraphConstants.setBorder(

                                        cell.getAttributes(), 

                                        BorderFactory.createRaisedBevelBorder());

                        else

                                // Set black border

                                GraphConstants.setBorderColor(

                                        cell.getAttributes(), Color.black);

                        // Add a Port

                        DefaultPort port = new DefaultPort();

                        cell.add(port);

                        port.setParent(cell);

                        GraphConstants.setBorder(cell.getAttributes(), BorderFactory.createEtchedBorder());

                    GraphConstants.setAutoSize(cell.getAttributes(),false);

                    GraphConstants.setResize(cell.getAttributes(),false);

                    GraphConstants.setInset(cell.getAttributes(), 10);

                    GraphConstants.setMoveable(cell.getAttributes(), false);

                        return cell;

                }

        private DefaultEdge createEdge(DefaultGraphCell cell, DefaultGraphCell parentCell, String label){

                DefaultEdge edge = new DefaultEdge(label);

                edge.setSource(parentCell);

                edge.setTarget(cell);

                GraphConstants.setLineEnd(edge.getAttributes(), GraphConstants.ARROW_CLASSIC);

                GraphConstants.setEndFill(edge.getAttributes(), true);

                GraphConstants.setAutoSize(edge.getAttributes(), true);

                getJGraph().getGraphLayoutCache().insert(edge);

                return edge;

        }

        public JScrollPane getScrollPane() {

                if (scrollPane == null){

                        scrollPane = new JScrollPane(getJGraph());

                        scrollPane.setPreferredSize(new Dimension(500,400));

                }

                return scrollPane;

        }

        public JGraph getJGraph() {

                if (jGraph == null){

                        GraphModel model = new DefaultGraphModel();

                        jGraph = new JGraph(model);

                        jGraph.setCloneable(false);

                jGraph.setInvokesStopCellEditing(true);

                jGraph.setJumpToDefaultPort(true);

                jGraph.setConnectable(false);

                jGraph.setDisconnectable(false);

                jGraph.setEditable(false);

                jGraph.setEnabled(true);

                }

                return jGraph;

        }

        public JPopupMenu getJPopupMenu() {

                if (jPopupMenu==null){

                        jPopupMenu = new JPopupMenu("");

                        jPopupMenu.add(getAddMenuItem());

                        jPopupMenu.add(getDeleteMenuItem());

                        jPopupMenu.add(getExecuteMenuItem());

                }

                return jPopupMenu;

        }

        public JMenuItem getAddMenuItem() {

                if (addMenuItem==null){

                        addMenuItem = new JMenuItem(PluginServices.getText(this, "addChild"));

                }

                return addMenuItem;

        }

        public JMenuItem getDeleteMenuItem() {

                if (deleteMenuItem==null){

                        deleteMenuItem = new JMenuItem(PluginServices.getText(this, "deleteChild"));

                }

                return deleteMenuItem;

        }

        public JMenuItem getExecuteMenuItem() {

                if (executeMenuItem == null)

                        executeMenuItem = new JMenuItem(PluginServices.getText(this, "ejecutar"));

                return executeMenuItem;

        }

        public void setSelectedCell(DefaultGraphCell cell) {

                selectedCell = cell;

        }

        public DefaultGraphCell getSelectedCell() {

                return selectedCell;

        }

        public View getView() {

                return view;

        }

        public DecisionTreeDialog getDecisionTreeDialog() {

                return decisionTreeDialog;

        }

        public HashMap getVarTable() {

                if (varTable == null)

                        varTable = new HashMap();

                return varTable;

        }

        public void setVarTable(HashMap varTable) {

                this.varTable = varTable;

        }

        public OptionsPanel getOutputOptionsPanel() {

                if (outputOptionsPanel == null){

                        outputOptionsPanel = new OptionsPanel(view);

                }

                return outputOptionsPanel;

        }

        /**

         * 

         * @return Nodo raiz del ?rbol de decisi?n.

         */

        public DecisionTreeNode getRoot() {

                return root;

        }

        /**

         * Devuelve un color para asignar a un nuevo nodo final

         * 

         * @return Color

         */

        private Color generateColor(){

                return null;

        }

        /**

         * Devuelve un ID para asignar a un nuevo nodo final

         * 

         * @return int

         */

        public int generateClassId(){

                Color color = null;

                int classColorsCount = getClassColors().size();

                for (int i=0; i<classColorsCount;i++)

                        if(!getClassColors().containsKey(new Integer(i))){

                                if (i<colors.length)

                                        color = colors[i];

                                else

                                        color = new Color((float)Math.random(),(float)Math.random(),(float)Math.random());

                                getClassColors().put(new Integer(i), color);

                                return i;

                        }

                if (classColorsCount<colors.length)

                        color = colors[classColorsCount];

                else

                        color = new Color((float)Math.random(),(float)Math.random(),(float)Math.random());

                getClassColors().put(new Integer(classColorsCount), color);

                return classColorsCount;

        }

        public HashMap getClassColors() {

                if (classColors == null)

                        classColors = new HashMap();

                return classColors;

        }

        /**

         * Elimina las entradas de <code>classColors</code> que se est?n

         * usando en el ?rbol.

         *

         */

        public void cleanClassColors() {

                ArrayList ids = new ArrayList();

                root.getFinals(ids);

                Object keys[] = getClassColors().keySet().toArray();

                for (int i=0; i < keys.length; i++){

                        if (!ids.contains(keys[i]))

                                        getClassColors().remove(keys[i]);

                }

        }

}