Application: gvSIG desktop » gvSIG geoprocess

 *

    private static final long serialVersionUID = 1L;

    private GeoAlgorithm m_Algorithm = null;

    private JComboBox fieldsCombo = null;

    private JCheckBox allLayers = null;

    //private AlgorithmOutputPanel             output             = null;

    private final String[] columnNames = {GeoProcessLocator.getGeoProcessManager().getTranslation("Selected"),

        GeoProcessLocator.getGeoProcessManager().getTranslation("Layer")};

    private final int[] columnWidths = {35, 334};

    private TableContainer table = null;

    private ObjectAndDescription[] layerList = null;

    private AlgorithmOutputPanel algorithmOutputPanel = null;

    private OutputChannelSelectionPanel outputChannelSelectionPanelPol;

    private OutputChannelSelectionPanel outputChannelSelectionPanelLine;

    private OutputChannelSelectionPanel outputChannelSelectionPanelPoint;

    private JPanel outputPanel;

    public MergeParametersPanel() {

        super();

    }

        m_Algorithm = algorithm;

        initGUI();

    private void initGUI() {

        GridBagLayout gbl = new GridBagLayout();

        this.setLayout(gbl);

        GridBagConstraints gbc = new GridBagConstraints();

        gbc.fill = GridBagConstraints.HORIZONTAL;

        gbc.weightx = 1.0;

        gbc.gridx = 0;

        gbc.gridy = 0;

        gbc.insets = new Insets(5, 5, 8, 5);

        this.add(getAllLayersCheck(), gbc);

        gbc.gridy = 1;

        gbc.fill = GridBagConstraints.BOTH;

        gbc.insets = new Insets(0, 0, 12, 0);

        gbc.weighty = 1.0;

        this.add(getCheckBoxTable(), gbc);

        gbc.gridy = 2;

        gbc.fill = GridBagConstraints.HORIZONTAL;

        gbc.insets = new Insets(5, 5, 8, 5);

        gbc.weightx = 1.0;

        gbc.weighty = 0;

        this.add(getFieldsComboPanel(GeoProcessLocator.getGeoProcessManager().getTranslation("use_fields_from_layer"), getFieldsCombo()), gbc);

        gbc.gridy = 3;

        this.add(getOutputChannelSelectionPanel(), gbc);

        initTable();

    }

    /**

     * Gets the output panel (SEXTANTE)

     *

     * @return

     */

    private JPanel getOutputChannelSelectionPanel() {

        if (outputPanel == null) {

            try {

                outputPanel = new JPanel();

                outputPanel.setLayout(new GridBagLayout());

                final OutputObjectsSet ooSet = m_Algorithm.getOutputObjects();

                final Output out_pol = ooSet.getOutput(MergeAlgorithm.RESULT_POL);

                final Output out_line = ooSet.getOutput(MergeAlgorithm.RESULT_LINE);

                final Output out_point = ooSet.getOutput(MergeAlgorithm.RESULT_POINT);

                outputChannelSelectionPanelPol = new OutputChannelSelectionPanel(out_pol, m_Algorithm.getParameters());

                outputChannelSelectionPanelLine = new OutputChannelSelectionPanel(out_line, m_Algorithm.getParameters());

                outputChannelSelectionPanelPoint = new OutputChannelSelectionPanel(out_point, m_Algorithm.getParameters());

                String label = GeoProcessLocator.getGeoProcessManager().getTranslation("Merge");

                GridBagConstraints gbc = new GridBagConstraints();

                gbc.fill = GridBagConstraints.HORIZONTAL;

                gbc.insets = new Insets(0, 0, 4, 0);

                gbc.weightx = 1;

                gbc.gridx = 0;

                gbc.gridy = 0;

                outputPanel.add(new JLabel(" " + label + " ["

                        + GeoProcessLocator.getGeoProcessManager().getTranslation("Polygon") + "]               "), gbc);

                gbc.gridx = 0;

                gbc.gridy = 1;

                outputPanel.add(new JLabel(" " + label + " ["

                        + GeoProcessLocator.getGeoProcessManager().getTranslation("Line") + "]               "), gbc);

                gbc.gridx = 0;

                gbc.gridy = 2;

                outputPanel.add(new JLabel(" " + label + " ["

                        + GeoProcessLocator.getGeoProcessManager().getTranslation("Point") + "]               "), gbc);

                gbc.fill = GridBagConstraints.HORIZONTAL;

                gbc.weightx = 1;

                gbc.gridx = 1;

                gbc.gridy = 0;

                outputPanel.add(outputChannelSelectionPanelPol, gbc);

                gbc.gridx = 1;

                gbc.gridy = 1;

                outputPanel.add(outputChannelSelectionPanelLine, gbc);

                gbc.gridx = 1;

                gbc.gridy = 2;

                outputPanel.add(outputChannelSelectionPanelPoint, gbc);

            } catch (final Exception e) {

                Sextante.addErrorToLog(e);

            }

        }

        return outputPanel;

    }

    /**

     * Gets the output panel (DAL)

     *

     * @return

     */

    @SuppressWarnings("unused")

    private AlgorithmOutputPanel getAlgorithmOutputPanel() {

        if (algorithmOutputPanel == null) {

            algorithmOutputPanel = new AlgorithmOutputPanel();

        }

        return algorithmOutputPanel;

    }

    /**

     * Gets a new JPanel with the text and JComboBox

     *

     * @param text

     * @param combo

     * @return

     */

    public JPanel getFieldsComboPanel(String text, JComboBox combo) {

        JPanel panel = new JPanel();

        GridBagLayout gbl = new GridBagLayout();

        panel.setLayout(gbl);

        GridBagConstraints gbc = new GridBagConstraints();

        gbc.fill = GridBagConstraints.HORIZONTAL;

        gbc.weightx = 1.0;

        gbc.gridx = 0;

        gbc.insets = new Insets(0, 0, 4, 0);

        JLabel label = new JLabel(text);

        panel.add(label, gbc);

        gbc.fill = GridBagConstraints.HORIZONTAL;

        gbc.weightx = 1.0;

        gbc.gridx = 1;

        gbc.insets = new Insets(0, 0, 4, 0);

        panel.add(combo, gbc);

        return panel;

    }

    /**

     * Gets a ComboBox

     *

     * @return

     */

    public JComboBox getFieldsCombo() {

        if (fieldsCombo == null) {

            fieldsCombo = new JComboBox();

            ObjectAndDescription[] fieldList = getLayerList();

            fieldsCombo.removeAllItems();

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

                fieldsCombo.addItem(fieldList[i]);

            }

        }

        return fieldsCombo;

    }

    /**

     * Gets a CheckBox

     *

     * @return

     */

    public JCheckBox getAllLayersCheck() {

        if (allLayers == null) {

            allLayers = new JCheckBox(GeoProcessLocator.getGeoProcessManager().getTranslation("select_all_layers"));

            allLayers.addActionListener(this);

        }

        return allLayers;

    }

    /**

     * Gets the summary table

     *

     * @return TableContainer

     */

    public TableContainer getCheckBoxTable() {

        if (table == null) {

            table = new TableContainer(columnNames, columnWidths, null);

            table.setModel("CheckBoxModel");

            table.setControlVisible(false);

            table.initialize();

        }

        return table;

    }

    //------------------------------------------------------------

    /*

     */

    public void actionPerformed(ActionEvent e) {

        if (e.getSource() == getAllLayersCheck()) {

            //Selecci?n de todas las capas de la tabla

            try {

                for (int i = 0; i < getCheckBoxTable().getRowCount(); i++) {

                    if (getAllLayersCheck().isSelected()) {

                        getCheckBoxTable().getModel().setValueAt(new Boolean(true), i, 0);

                    } else {

                        getCheckBoxTable().getModel().setValueAt(new Boolean(false), i, 0);

                    }

                }

            } catch (NotInitializeException e1) {

                Sextante.addErrorToLog(e1);

            }

        }

    }

    /**

     * Adds to the table one entry for each field

     */

    private void initTable() {

        try {

            getCheckBoxTable().removeAllRows();

            ObjectAndDescription[] layerList = getLayerList();

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

                addTableRow(layerList[i].getDescription());

            }

        } catch (NotInitializeException e) {

            Sextante.addErrorToLog(e);

        }

    }

    /**

     * Adds one entry to the table

     *

     * @param layerName Layer name

     * @throws NotInitializeException

     */

    private void addTableRow(String layerName) throws NotInitializeException {

        Object[] row = {new Boolean(false),

            layerName};

        getCheckBoxTable().addRow(row);

    }

    @Override

        try {

            ParametersSet params = m_Algorithm.getParameters();

            params.getParameter(MergeAlgorithm.FIELDLAYER).setParameterValue(getSelectedVectorLayer());

            params.getParameter(MergeAlgorithm.LAYERS).setParameterValue(getSelectedLayerList());

            OutputObjectsSet ooSet = m_Algorithm.getOutputObjects();

            Output outPol = ooSet.getOutput(MergeAlgorithm.RESULT_POL);

            Output outLine = ooSet.getOutput(MergeAlgorithm.RESULT_LINE);

            Output outPoint = ooSet.getOutput(MergeAlgorithm.RESULT_POINT);

            //Reponer estas l?neas para cambiar el panel de salida y comentar la siguiente

            //AlgorithmOutputPanel fsp = getAlgorithmOutputPanel();

            //out.setOutputChannel(new CompositeSourceOutputChannel(fsp.getOutputParameters()));

            outPol.setOutputChannel(outputChannelSelectionPanelPol.getOutputChannel());

            outLine.setOutputChannel(outputChannelSelectionPanelLine.getOutputChannel());

            outPoint.setOutputChannel(outputChannelSelectionPanelPoint.getOutputChannel());

        } catch (Exception e) {

            Sextante.addErrorToLog(e);

        }

    }

    @Override

    public void setOutputValue(String arg0, String arg1) {

    }

    @Override

    public void setParameterValue(String arg0, String arg1) {

    }

    /**

     * Gets the input layer list

     *

     * @return

     */

    private ObjectAndDescription[] getLayerList() {

        if (layerList == null) {

            IVectorLayer[] layers = SextanteGUI.getInputFactory()

                    .getVectorLayers(IVectorLayer.SHAPE_TYPE_WRONG);

            layerList = new ObjectAndDescription[layers.length];

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

                layerList[i] = new ObjectAndDescription(layers[i].getName(), layers[i]);

            }

        }

        return layerList;

    }

    /**

     * Gets the list of selected layers

     *

     * @return

     */

    private ArrayList<IVectorLayer> getSelectedLayerList() {

        ObjectAndDescription[] layerList = getLayerList();

        ArrayList<IVectorLayer> vLayer = new ArrayList<IVectorLayer>();

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

            Boolean check = (Boolean) getCheckBoxTable().getModel().getValueAt(i, 0);

            if (check.booleanValue()) {

                vLayer.add((IVectorLayer) layerList[i].getObject());

            }

        }

        return vLayer;

    }

    /**

     * Gets the selected vector layer in the JComboBox

     *

     * @return

     */

    private IVectorLayer getSelectedVectorLayer() {

        if (getFieldsCombo().getSelectedItem() != null) {

            return (IVectorLayer) ((ObjectAndDescription) getFieldsCombo().getSelectedItem()).getObject();

        }

        return null;

    }

 *

                "org.gvsig.geoprocess.algorithm.merge.merge", MergeLibrary.class

                        .getClassLoader(), MergeLibrary.class.getClass().getName());

 *

    public static final String RESULT_POL = "RESULT_POL";

    public static final String RESULT_POINT = "RESULT_POINT";

    public static final String RESULT_LINE = "RESULT_LINE";

    public static final String LAYERS = "LAYERS";

    public static final String FIELDLAYER = "LAYER";

    /*

     */

    public void defineCharacteristics() {

        try {

            m_Parameters.addMultipleInput(LAYERS,

                    getTranslation("Input_layers"),

                    AdditionalInfoMultipleInput.DATA_TYPE_VECTOR_ANY,

                    true);

            m_Parameters.addInputVectorLayer(FIELDLAYER,

                    getTranslation("Fields"),

                    IVectorLayer.SHAPE_TYPE_WRONG,

                    true);

            addOutputVectorLayer(RESULT_POL, getTranslation("Merge_polygon"),

                    OutputVectorLayer.SHAPE_TYPE_POLYGON);

            addOutputVectorLayer(RESULT_LINE, getTranslation("Merge_line"),

                    OutputVectorLayer.SHAPE_TYPE_LINE);

            addOutputVectorLayer(RESULT_POINT, getTranslation("Merge_point"),

                    OutputVectorLayer.SHAPE_TYPE_POINT);

        } catch (RepeatedParameterNameException e) {

            Sextante.addErrorToLog(e);

        }

    }

    /*

     */

    @SuppressWarnings("unchecked")

    public boolean processAlgorithm() throws GeoAlgorithmExecutionException {

        if (existsOutPutFile(RESULT_POL, 0)

                || existsOutPutFile(RESULT_LINE, 0)

                || existsOutPutFile(RESULT_POINT, 0)) {

            throw new GeoAlgorithmExecutionException(getTranslation("file_exists"));

        }

        IVectorLayer layer = m_Parameters.getParameterValueAsVectorLayer(FIELDLAYER);

        ArrayList<IVectorLayer> layers = m_Parameters.getParameterValueAsArrayList(LAYERS);

        FeatureStore storeLayer = null;

        if (layer instanceof FlyrVectIVectorLayer) {

            storeLayer = ((FlyrVectIVectorLayer) layer).getFeatureStore();

        } else {

            return false;

        }

        try {

            //Gets the list of FeatureStore

            ArrayList<FeatureStore> featureStoreList = new ArrayList<FeatureStore>();

            for (int i = 0; i < layers.size(); i++) {

                IVectorLayer lyr = layers.get(i);

                if (lyr instanceof FlyrVectIVectorLayer && layer.getShapeType() == lyr.getShapeType()) {

                    featureStoreList.add(((FlyrVectIVectorLayer) lyr).getFeatureStore());

                } else {

                    JOptionPane.showMessageDialog(null,

                            getTranslation("layers_type_are_different"),

                            "Error",

                            JOptionPane.WARNING_MESSAGE);

                    return false;

                }

            }

            //Builds the output FeatureStore

            FeatureSet features = null;

            features = storeLayer.getFeatureSet();

            FeatureType featureType = features.getDefaultFeatureType();

            /* FeatureStore outFeatStore =

             */

            GeometryOperation operation = new MergeOperation(layer, this);

            if (isPolygon(storeLayer) || isUndefined(storeLayer)) {

                FeatureStore outFeatStore

                        = buildOutPutStore(featureType, IVectorLayer.SHAPE_TYPE_POLYGON,

                                getTranslation("Merge_polygon"), RESULT_POL);

                operation.computesGeometryOperationInAList(featureStoreList, outFeatStore, attrNames,

                        false, false, true);

            } else {

                buildOutPutStore(featureType, IVectorLayer.SHAPE_TYPE_POLYGON,

                        getTranslation("Null_polygon"), RESULT_POL);

            }

            if (isLine(storeLayer) || isUndefined(storeLayer)) {

                FeatureStore outFeatStore

                        = buildOutPutStore(featureType, IVectorLayer.SHAPE_TYPE_LINE,

                                getTranslation("Merge_line"), RESULT_LINE);

                operation.computesGeometryOperationInAList(featureStoreList, outFeatStore, attrNames,

                        false, false, true);

            } else {

                buildOutPutStore(featureType.getCopy(), IVectorLayer.SHAPE_TYPE_LINE,

                        getTranslation("Null_line"), RESULT_LINE);

            }

            if (isPoint(storeLayer) || isUndefined(storeLayer)) {

                FeatureStore outFeatStore

                        = buildOutPutStore(featureType.getCopy(), IVectorLayer.SHAPE_TYPE_POINT,

                                getTranslation("Merge_point"), RESULT_POINT);

                operation.computesGeometryOperationInAList(featureStoreList, outFeatStore, attrNames,

                        false, false, true);

            } else {

                buildOutPutStore(featureType.getCopy(), IVectorLayer.SHAPE_TYPE_POINT,

                        getTranslation("Null_point"), RESULT_POINT);

            }

        } catch (DataException e) {

            Sextante.addErrorToLog(e);

            return false;

        }

        if (getTaskMonitor().isCanceled()) {

            return false;

        }

        return true;

    }

 *

    private IVectorLayer layer = null;

    public MergeOperation(IVectorLayer layer, AbstractSextanteGeoProcess p) {

        super(p);

        this.layer = layer;

    }

    /**

     * Computes intersection between the geometry and the overlay layer. The

     * fields of the intersected features will be added.

     *

     * @param g

     * @param featureInput

     * @return

     */

    public EditableFeature invoke(org.gvsig.fmap.geom.Geometry g, Feature featureInput) {

        if (g == null) {

            return lastEditFeature;

        }

        try {

            if (inFeatureStore == ((FlyrVectIVectorLayer) layer).getFeatureStore()) {

                lastEditFeature = persister.addFeature(featureInput, g);

            } else {

                lastEditFeature = persister.addDifferentFieldFeature(featureInput, g);

            }

        } catch (CreateGeometryException e) {

            Sextante.addErrorToLog(e);

        } catch (DataException e) {

            Sextante.addErrorToLog(e);

        }

        return lastEditFeature;

    }

    /**

     * clips feature's geometry with the clipping geometry, preserving feature's

     * original attributes. If feature's geometry doesn't touch clipping

     * geometry, it will be ignored.

     */

    public void invoke(org.gvsig.fmap.geom.Geometry g, EditableFeature featureInput) {

        try {

            lastEditFeature = persister.addGeometryToExistingFeature(featureInput, g);

        } catch (CreateGeometryException e) {

            Sextante.addErrorToLog(e);

        } catch (DataException e) {

            Sextante.addErrorToLog(e);

        }

    }