Application: gvSIG desktop » gvSIG tools: ToolBox

Manifest-Version: 1.0

Ant-Version: Apache Ant 1.7.1

Created-By: 20.1-b02 (Sun Microsystems Inc.)

Implementation-Version: 0.7

Built-Date: 2013-03-04 16:06:37

package es.unex.sextante.gui.algorithm;

import info.clearthought.layout.TableLayout;

import info.clearthought.layout.TableLayoutConstants;

import java.awt.Font;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.ArrayList;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JDialog;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JTabbedPane;

import javax.swing.JTextField;

import es.unex.sextante.core.AnalysisExtent;

import es.unex.sextante.core.GeoAlgorithm;

import es.unex.sextante.core.OutputObjectsSet;

import es.unex.sextante.core.ParametersSet;

import es.unex.sextante.core.Sextante;

import es.unex.sextante.exceptions.WrongAnalysisExtentException;

import es.unex.sextante.exceptions.WrongInputException;

import es.unex.sextante.gui.core.IGUIFactory;

import es.unex.sextante.gui.core.SextanteGUI;

import es.unex.sextante.gui.exceptions.LayerCannotBeOverwrittenException;

import es.unex.sextante.gui.exceptions.OverwrittingNotAllowedException;

import es.unex.sextante.gui.exceptions.TooLargeGridExtentException;

import es.unex.sextante.gui.history.DateAndCommand;

import es.unex.sextante.gui.history.History;

import es.unex.sextante.outputs.Output;

import es.unex.sextante.outputs.Output3DRasterLayer;

import es.unex.sextante.outputs.OutputRasterLayer;

import es.unex.sextante.outputs.OutputTable;

import es.unex.sextante.outputs.OutputVectorLayer;

import es.unex.sextante.parameters.Parameter;

/**

 * A dialog used to introduce all the necessary input for a geoalgorithm (input parameters and raster extent if needed. see

 * {@link es.unex.sextante.core.GeoAlgorithm#getUserCanDefineAnalysisExtent()}) for a given algorithm

 * 

 * @author volaya

 * 

 */

public class AlgorithmDialog

         extends

            JDialog {

   protected GeoAlgorithm                  m_Algorithm;

   protected JTabbedPane                   jTabbedPane1;

   private JPanel                          jPanelButtons;

   private JPanel                          jMainPanel;

   protected JButton                       jButtonCancel;

   protected JButton                       jButtonOK;

   private int                             m_iDialogReturn;

   protected GeoAlgorithmParametersPanel   jPanelParametersMain = null;

   private AnalysisExtentPanel             jAnalysisExtentPanel;

   private JButton                         jButtonHelp;

   private String[]                        m_PreviousParameters;

   private String[]                        m_Extents;

   private JTextField                      jLabelCommand;

   private JButton                         jButtonPrevious;

   private JButton                         jButtonNext;

   private int                             m_iPreviousCommandIndex;

   private final ArrayList<DateAndCommand> m_sCommand;

   /**

    * Creates a new dialog for a given algorithm.

    * 

    * @param algorithm

    *                the algorithm

    * @param parent

    *                the parent dialog

    * @param panel

    *                the parameters panel to use. Doesn't have to be initialized using its init(Geoalgorithm) method. This

    *                constructor will initialize it

    * @param commands

    *                a list of DateAndCommand objects to use as previous parameters set. Must include both the "runalg" commands

    *                and the "extent" ones, in case you want them to be used for algorithms generating new raster layers. If null,

    *                all suitable commands from history are used

    */

   public AlgorithmDialog(final GeoAlgorithm algorithm,

                          final JDialog parent,

                          final GeoAlgorithmParametersPanel panel,

                          final ArrayList<DateAndCommand> commands) {

      super(parent, algorithm.getName(), true);

      setResizable(false);

      m_Algorithm = algorithm;

      m_sCommand = commands;

      jPanelParametersMain = panel;

      jPanelParametersMain.init(m_Algorithm);

      initGUI();

      setLocationRelativeTo(null);

   }

   /**

    * Creates a new dialog for a given algorithm. The main frame of the UI is used as the parent component

    * 

    * @param algorithm

    *                the algorithm

    * @param panel

    *                the parameters panel to use. Doesn't have to be initialized using its init(Geoalgorithm) method. This

    *                constructor will initialize it

    * @param comands

    *                a list of DateAndCommand objects to use as previous parameters set. Must include both the "runalg" commands

    *                and the "extent" ones, in case you want them to be used for algorithms generating new raster layers. If null,

    *                all suitable commands from history are used

    */

   public AlgorithmDialog(final GeoAlgorithm algorithm,

                          final GeoAlgorithmParametersPanel panel,

                          final ArrayList<DateAndCommand> commands) {

      super(SextanteGUI.getMainFrame(), algorithm.getName(), true);

      setResizable(false);

      m_sCommand = commands;

      m_Algorithm = algorithm;

      jPanelParametersMain = panel;

      jPanelParametersMain.init(m_Algorithm);

      initGUI();

      setLocationRelativeTo(null);

   }

   private void initGUI() {

      jMainPanel = new JPanel();

      this.add(jMainPanel);

      final TableLayout thisLayout = new TableLayout(new double[][] { { 10.0, TableLayoutConstants.FILL, 10. },

               { 1.0, 338.0, 37.0 } });

      jMainPanel.setLayout(thisLayout);

      this.setSize(696, 446);

      {

         jTabbedPane1 = new JTabbedPane();

         jMainPanel.add(jTabbedPane1, "1, 1");

         {

            jTabbedPane1.addTab(Sextante.getText("Parameters"), null, jPanelParametersMain, null);

         }

         {

            if (m_Algorithm.getUserCanDefineAnalysisExtent()) {

               jTabbedPane1.addTab(Sextante.getText("Raster_output"), null, getAnalysisExtentPanel(), null);

            }

         }

      }

      {

         jPanelButtons = new JPanel();

         final TableLayout jPanelButtonsLayout = new TableLayout(new double[][] {

                  { 5.0, 45.0, 120.0, 120.0, 45.0, TableLayoutConstants.FILL, 90.0, 90.0, 25.0, 15.0 },

                  { TableLayoutConstants.FILL, 25.0, TableLayoutConstants.FILL } });

         jPanelButtonsLayout.setHGap(5);

         jPanelButtonsLayout.setVGap(5);

         jPanelButtons.setLayout(jPanelButtonsLayout);

         jMainPanel.add(jPanelButtons, "1, 2");

         jPanelButtons.setFocusable(false);

         {

            jButtonOK = new JButton();

            jPanelButtons.add(jButtonOK, "6, 1");

            jButtonOK.setText(Sextante.getText("OK"));

            jButtonOK.addActionListener(new java.awt.event.ActionListener() {

               public void actionPerformed(final java.awt.event.ActionEvent e) {

                  executeAlgorithm();

               }

            });

         }

         {

            jButtonHelp = new JButton();

            jPanelButtons.add(jButtonHelp, "8, 1");

            jButtonHelp.setIcon(new ImageIcon(getClass().getClassLoader().getResource("images/info.gif")));

            jButtonHelp.setPreferredSize(new java.awt.Dimension(33, 0));

            jButtonHelp.addActionListener(new ActionListener() {

               public void actionPerformed(final ActionEvent evt) {

                  showHelp();

               }

            });

         }

         {

            jButtonCancel = new JButton();

            jPanelButtons.add(jButtonCancel, "7, 1");

            jButtonCancel.setText(Sextante.getText("Cancel"));

            jButtonCancel.addActionListener(new java.awt.event.ActionListener() {

               public void actionPerformed(final java.awt.event.ActionEvent e) {

                  m_iDialogReturn = IGUIFactory.CANCEL;

                  dispose();

                  setVisible(false);

               }

            });

         }

      }

      retrievePreviouslyUsedParametersFromHistory();

      if (m_PreviousParameters != null) {

         try {

            {

               jButtonPrevious = new JButton();

               jPanelButtons.add(jButtonPrevious, "1, 1");

               jButtonPrevious.setText("<");

               jButtonPrevious.addActionListener(new ActionListener() {

                  public void actionPerformed(final ActionEvent evt) {

                     setPreviousSetOfPreviouslyUsedCommand();

                  }

               });

            }

            {

               jButtonNext = new JButton();

               jPanelButtons.add(jButtonNext, "4, 1");

               jButtonNext.setText(">");

               jButtonNext.addActionListener(new ActionListener() {

                  public void actionPerformed(final ActionEvent evt) {

                     setNextSetOfPreviouslyUsedCommand();

                  }

               });

            }

            {

               jLabelCommand = new JTextField();

               jLabelCommand.setFont(new Font("Monospaced", Font.PLAIN, 10));

               jLabelCommand.setEditable(false);

               jPanelButtons.add(jLabelCommand, "2, 1, 3, 1");

            }

            m_iPreviousCommandIndex = m_PreviousParameters.length - 1;

            setPreviouslyUsedParameters(m_iPreviousCommandIndex);

         }

         catch (final Exception e) {

            // do nothing

         }

      }

   }

   private void setPreviouslyUsedParameters(final int iIndex) {

      int i;

      Parameter param;

      String[] args;

      String sArg;

      jLabelCommand.setText("[" + Integer.toString(iIndex + 1) + "] " + m_PreviousParameters[iIndex]);

      args = m_PreviousParameters[iIndex].split("\"");

      for (int j = 0; j < 2; j++) { //twice to handle dependencies

         final ParametersSet ps = m_Algorithm.getParameters();

         for (i = 0; i < m_Algorithm.getNumberOfParameters(); i++) {

            param = ps.getParameter(i);

            sArg = args[i * 2 + 3];

            jPanelParametersMain.setParameterValue(param.getParameterName(), sArg.trim());

         }

         int iOutputIndex = i * 2 + 3;

         final OutputObjectsSet ooSet = m_Algorithm.getOutputObjects();

         for (i = 0; i < ooSet.getOutputObjectsCount(); i++) {

            final Output out = ooSet.getOutput(i);

            if ((out instanceof OutputRasterLayer) || (out instanceof Output3DRasterLayer) || (out instanceof OutputVectorLayer)

                || (out instanceof OutputTable)) {

               final String sValue = args[iOutputIndex].trim();

               jPanelParametersMain.setOutputValue(out.getName(), sValue);

               iOutputIndex += 2;

            }

         }

      }

      if (m_Algorithm.getUserCanDefineAnalysisExtent()) {

         String sExtent = m_Extents[iIndex];

         if (sExtent != null) {

            sExtent = sExtent.substring(sExtent.indexOf("(") + 1, sExtent.indexOf(")"));

            final AnalysisExtent ae = new AnalysisExtent();

            final String[] sCoords = sExtent.split(",");

            final double dCellSize = Double.parseDouble(sCoords[6]);

            final double dCellSizeZ = Double.parseDouble(sCoords[7]);

            ae.setCellSize(dCellSize);

            ae.setCellSizeZ(dCellSizeZ);

            final double xMin = Double.parseDouble(sCoords[0]);

            final double xMax = Double.parseDouble(sCoords[3]);

            ae.setXRange(xMin, xMax, true);

            final double yMin = Double.parseDouble(sCoords[1]);

            final double yMax = Double.parseDouble(sCoords[4]);

            ae.setYRange(yMin, yMax, true);

            final double zMin = Double.parseDouble(sCoords[2]);

            final double zMax = Double.parseDouble(sCoords[5]);

            ae.setZRange(zMin, zMax, true);

            getAnalysisExtentPanel().setExtent(ae);

         }

         else {

            getAnalysisExtentPanel().setAutoExtent();

         }

      }

   }

   private void retrievePreviouslyUsedParametersFromHistory() {

      ArrayList<DateAndCommand> dac;

      if (m_sCommand != null) {

         dac = m_sCommand;

      }

      else {

         dac = History.getHistory();

      }

      final ArrayList<String> previousParameters = new ArrayList<String>();

      final ArrayList<String> extents = new ArrayList<String>();

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

         String command = dac.get(i).getCommand();

         if (command.startsWith("runalg(\"" + m_Algorithm.getCommandLineName() + "\"")) {

            previousParameters.add(command);

            if (m_Algorithm.getUserCanDefineAnalysisExtent() && (i != 0)) {

               command = dac.get(i - 1).getCommand();

               if (command.startsWith("extent")) {

                  extents.add(command);

               }

               else {

                  extents.add(null);

               }

            }

         }

      }

      if (previousParameters.size() == 0) {

         m_PreviousParameters = null;

         m_Extents = null;

      }

      else {

         m_PreviousParameters = previousParameters.toArray(new String[0]);

         m_Extents = extents.toArray(new String[0]);

      }

   }

   public void setPreviousSetOfPreviouslyUsedCommand() {

      if (m_iPreviousCommandIndex <= 0) {

         //m_iPreviousCommandIndex = m_PreviousParameters.length - 1;

      }

      else {

         m_iPreviousCommandIndex--;

         setPreviouslyUsedParameters(m_iPreviousCommandIndex);

      }

   }

   public void setNextSetOfPreviouslyUsedCommand() {

      if (m_iPreviousCommandIndex >= m_PreviousParameters.length - 1) {

         //m_iPreviousCommandIndex = 0;

      }

      else {

         m_iPreviousCommandIndex++;

         setPreviouslyUsedParameters(m_iPreviousCommandIndex);

      }

   }

   protected void showHelp() {

      SextanteGUI.getGUIFactory().showHelpDialog(m_Algorithm);

   }

   protected void executeAlgorithm() {

      try {

         try {

            assignParameters();

         }

         catch (final TooLargeGridExtentException e) {

            final int iRet = JOptionPane.showConfirmDialog(null, e.getMessage(), Sextante.getText("Warning"),

                     JOptionPane.YES_NO_OPTION);

            if (iRet != JOptionPane.YES_OPTION) {

               this.jTabbedPane1.setSelectedIndex(1);

               return;

            }

         }

         m_iDialogReturn = IGUIFactory.OK;

         dispose();

         setVisible(false);

      }

      catch (final WrongInputException e) {

         JOptionPane.showMessageDialog(null, e.getMessage(), Sextante.getText("Warning"), JOptionPane.WARNING_MESSAGE);

         this.jTabbedPane1.setSelectedIndex(0);

      }

      catch (final WrongAnalysisExtentException e) {

         JOptionPane.showMessageDialog(null, e.getMessage(), Sextante.getText("Warning"), JOptionPane.WARNING_MESSAGE);

         this.jTabbedPane1.setSelectedIndex(1);

      }

      catch (final OverwrittingNotAllowedException e) {

         JOptionPane.showMessageDialog(null, e.getMessage(), Sextante.getText("Warning"), JOptionPane.WARNING_MESSAGE);

         this.jTabbedPane1.setSelectedIndex(0);

      }

      catch (final LayerCannotBeOverwrittenException e) {

         JOptionPane.showMessageDialog(null, e.getMessage(), Sextante.getText("Warning"), JOptionPane.WARNING_MESSAGE);

         this.jTabbedPane1.setSelectedIndex(0);

      }

   }

   protected void assignParameters() throws WrongInputException, OverwrittingNotAllowedException,

                                    LayerCannotBeOverwrittenException, WrongAnalysisExtentException, TooLargeGridExtentException {

      jPanelParametersMain.assignParameters();

      if (m_Algorithm.getUserCanDefineAnalysisExtent()) {

         getAnalysisExtentPanel().assignExtent();

      }

   }

   private AnalysisExtentPanel getAnalysisExtentPanel() {

      if (jAnalysisExtentPanel == null) {

         if (m_Algorithm.is3D()) {

            jAnalysisExtentPanel = new TridimensionalAnalysisExtentPanel(m_Algorithm);

         }

         else {

            jAnalysisExtentPanel = new AnalysisExtentPanel(m_Algorithm);

         }

      }

      return jAnalysisExtentPanel;

   }

   /**

    * Returns {@link es.unex.sextante.gui.core.IGUIFactory#OK} if the user selected "OK" and the algorithm should be executed

    * 

    * @return IGUIFactory.OK if the user selected "OK" and the algorithm should be executed

    */

   public int getDialogReturn() {

      return m_iDialogReturn;

   }

}

package es.unex.sextante.gui.algorithm;

import info.clearthought.layout.TableLayout;

import java.awt.event.ActionListener;

import javax.swing.JButton;

import javax.swing.JPanel;

import es.unex.sextante.core.Sextante;

import es.unex.sextante.outputs.Output;

import es.unex.sextante.outputs.OutputVectorLayer;

public class GeneralOptionsChannelSelectionPanel

         extends

            JPanel {

   public static final String   OVERWRITE            = "OVERWRITE";

   public static final String   SAVE_TO_TEMP_FILE    = "SET_TEMP_FILE";

   public static final String   DO_NOT_CREATE_OUTPUT = "DO_NOT_CREATE_OUTPUT";

   private final ActionListener m_Listener;

   private JButton              jButtonSetTempFile;

   private JButton              jButtonSetOverwrite;

   private JButton              jButtonDoNotCreate;

   private final Output         m_Output;

   public GeneralOptionsChannelSelectionPanel(final Output output,

                                              final ActionListener listener) {

      super();

      m_Listener = listener;

      m_Output = output;

      initGUI();

   }

   private void initGUI() {

      this.setLayout(new TableLayout(new double[][] { { 50, TableLayout.FILL, 50 },

               { 50, TableLayout.MINIMUM, 50, TableLayout.MINIMUM, 50, TableLayout.MINIMUM, TableLayout.FILL } }));

      //this.setLayout(new FlowLayout());

      if (m_Output instanceof OutputVectorLayer) {

         if (((OutputVectorLayer) m_Output).canOverwrite()) {

            jButtonSetOverwrite = new JButton(Sextante.getText("Overwrite"));

            jButtonSetOverwrite.addActionListener(m_Listener);

            jButtonSetOverwrite.setActionCommand(OVERWRITE);

            this.add("1,5", jButtonSetOverwrite);

         }

      }

      jButtonSetTempFile = new JButton(Sextante.getText("Save_to_temp_file"));

      jButtonSetTempFile.addActionListener(m_Listener);

      jButtonSetTempFile.setActionCommand(SAVE_TO_TEMP_FILE);

      this.add("1,1", jButtonSetTempFile);

      jButtonDoNotCreate = new JButton(Sextante.getText("Do_not_create_output"));

      jButtonDoNotCreate.addActionListener(m_Listener);

      jButtonDoNotCreate.setActionCommand(DO_NOT_CREATE_OUTPUT);

      this.add("1,3", jButtonDoNotCreate);

   }

}

package es.unex.sextante.gui.algorithm.iterative;

import java.awt.geom.Rectangle2D;

import com.vividsolutions.jts.geom.Envelope;

import com.vividsolutions.jts.geom.Geometry;

import org.gvsig.tools.exception.BaseException;

import es.unex.sextante.dataObjects.AbstractVectorLayer;

import es.unex.sextante.dataObjects.IFeatureIterator;

import es.unex.sextante.dataObjects.IVectorLayer;

import es.unex.sextante.dataObjects.vectorFilters.IVectorLayerFilter;

import es.unex.sextante.outputs.IOutputChannel;

public class SingleFeatureVectorLayer

         extends

            AbstractVectorLayer {

   private String         m_sName;

   private Object[]       m_Record;

   private Geometry       m_Geometry;

   private final String[] m_sFields;

   private final Object   m_CRS;

   private IVectorLayer   m_OriginalLayer;

   private final int      m_iShapeType;

   private int      	  m_ID;

   public SingleFeatureVectorLayer(final IVectorLayer layer) {

      m_sFields = layer.getFieldNames();

      m_CRS = layer.getCRS();

      m_OriginalLayer = layer;

      m_sName = layer.getName();

      m_iShapeType = layer.getShapeType();

   }

   public void setFeature(final Geometry geometry,

                          final Object[] record) {

      m_Geometry = geometry;

      m_Record = record;

   }

   public void addFeature(final Geometry geometry,

                          final Object[] attributes) {}

   public int getFieldCount() {

      return m_Record.length;

   }

   public String getFieldName(final int iIndex) {

      return m_sFields[iIndex];

   }

   public Class getFieldType(final int iIndex) {

      return m_Record[iIndex].getClass();

   }

   public int getShapeType() {

      return m_iShapeType;

   }

   public IFeatureIterator iterator() {

      return new SingleFeatureIterator(m_Geometry, m_Record);

   }

   public Object getCRS() {

      return m_CRS;

   }

   @Override

   public Rectangle2D getFullExtent() {

      final Envelope env = m_Geometry.getEnvelopeInternal();

      return new Rectangle2D.Double(env.getMinX(), env.getMinY(), env.getWidth(), env.getHeight());

   }

   public void close() {}

   public IOutputChannel getOutputChannel() {

      return null;

   }

   public String getName() {

      return m_sName;

   }

   public void open() {}

   public void postProcess() throws Exception {}

   public void setName(final String sName) {

      m_sName = sName;

   }

   /*

    * Sets an internal ID. Useful for keeping external algorithm

    * providers such as GRASS informed which feature is being

    * processed by an iterative processor.

    * Use range 1..n.

    */

   public void setID (final int ID) {

	      m_ID = ID;

   }

   public int getID () {

	      return ( m_ID );

  }

   public IVectorLayer getOriginalLayer() {

      return m_OriginalLayer;

   }

   @Override

   public void addFilter(final IVectorLayerFilter filter) {}

   @Override

   public void removeFilters() {}

   @Override

   public Object getBaseDataObject() {

      return null;

   }

   public void free() {

      m_OriginalLayer = null;

   }

   public boolean canBeEdited() {

      return false;

   }

    /* (non-Javadoc)

     * @see es.unex.sextante.dataObjects.IVectorLayer#getSubType()

     */

    @Override

    public int getSubType() throws BaseException {

        return m_OriginalLayer.getSubType();

    }

}

package es.unex.sextante.gui.algorithm.iterative;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Set;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

import javax.swing.JDialog;

import javax.swing.JOptionPane;

import javax.swing.JScrollPane;

import javax.swing.JTable;

import javax.swing.table.DefaultTableModel;

import es.unex.sextante.core.GeoAlgorithm;

import es.unex.sextante.core.ITaskMonitor;

import es.unex.sextante.core.ObjectAndDescription;

import es.unex.sextante.core.OutputObjectsSet;

import es.unex.sextante.core.Sextante;

import es.unex.sextante.dataObjects.IFeature;

import es.unex.sextante.dataObjects.IFeatureIterator;

import es.unex.sextante.dataObjects.IVectorLayer;

import es.unex.sextante.exceptions.GeoAlgorithmExecutionException;

import es.unex.sextante.exceptions.NullParameterValueException;

import es.unex.sextante.exceptions.WrongParameterIDException;

import es.unex.sextante.exceptions.WrongParameterTypeException;

import es.unex.sextante.gui.additionalResults.AdditionalResults;

import es.unex.sextante.gui.core.SextanteGUI;

import es.unex.sextante.outputs.FileOutputChannel;

import es.unex.sextante.outputs.IOutputChannel;

import es.unex.sextante.outputs.Output;

import es.unex.sextante.outputs.OutputNumericalValue;

/**

 * A task to execute an algorithm iteratively over all the features of a vector layer

 * 

 * @author volaya

 * 

 */

public class IterativeAlgorithmMonitorableTask

         implements

            Runnable {

   private String                                           m_sErrorMessage;

   private final GeoAlgorithm                               m_Algorithm;

   private ITaskMonitor                                     m_ProgressMonitor = null;

   private final String                                     m_sParameterToIterateOver;

   private final SingleFeatureVectorLayer                   m_SFVL;

   private final IFeatureIterator                           m_Iterator;

   private final int                                        m_iShapesCount;

   private String                                           m_sLayerName;

   private final ArrayList<ArrayList<OutputNumericalValue>> m_NumericalOutputs;

   /**

    * Creates a new task

    * 

    * @param algorithm

    *                the algorithm to execute

    * @param parent

    *                the dialog from which it has been called, to be used as parent for the monitor dialog

    * @param sParameterToIterateOver

    *                the name of the parameter to iterate over

    * @throws WrongParameterIDException

    * @throws NullParameterValueException

    * @throws WrongParameterTypeException

    */

   public IterativeAlgorithmMonitorableTask(final GeoAlgorithm algorithm,

                                            final JDialog parent,

                                            final String sParameterToIterateOver) throws GeoAlgorithmExecutionException {

      try {

         m_Algorithm = algorithm;

         m_NumericalOutputs = new ArrayList<ArrayList<OutputNumericalValue>>();

         m_sParameterToIterateOver = sParameterToIterateOver;

         m_ProgressMonitor = SextanteGUI.getOutputFactory().getTaskMonitor(algorithm.getName(),

                  algorithm.isDeterminatedProcess(), parent);

         final IVectorLayer layer = m_Algorithm.getParameters().getParameter(m_sParameterToIterateOver).getParameterValueAsVectorLayer();

         m_Iterator = layer.iterator();

         m_iShapesCount = layer.getShapesCount();

         m_SFVL = new SingleFeatureVectorLayer(layer);

         m_Algorithm.getParameters().getParameter(m_sParameterToIterateOver).setParameterValue(m_SFVL);

         m_sLayerName = layer.getName();

      }

      catch (final Exception e) {

         if (m_ProgressMonitor != null) {

            m_ProgressMonitor.close();

         }

         throw new GeoAlgorithmExecutionException(e.getMessage());

      }

   }

   /**

    * Runs the batch process

    */

   public void run() {

      final OutputObjectsSet ooset = m_Algorithm.getOutputObjects();

      final HashMap<String, String> filenames = new HashMap<String, String>();

      for (int i = 0; i < ooset.getOutputObjectsCount(); i++) {

         final Output output = ooset.getOutput(i);

         final IOutputChannel channel = output.getOutputChannel();

         if (channel != null) {

            if (channel instanceof FileOutputChannel) {

               final FileOutputChannel foc = (FileOutputChannel) channel;

               filenames.put(output.getName(), foc.getFilename());

            }

            else {

               m_sErrorMessage = Sextante.getText("Unsupported output channel:") + channel.toString();

               JOptionPane.showMessageDialog(null, m_sErrorMessage, Sextante.getText("Error"), JOptionPane.ERROR_MESSAGE);

            }

         }

      }

      int iIteration = 1;

      while (m_Iterator.hasNext()) {

         try {

            final IFeature feature = m_Iterator.next();

            m_SFVL.setFeature(feature.getGeometry(), feature.getRecord().getValues());

            m_SFVL.setName(m_sLayerName + "[" + Integer.toString(iIteration) + "]");

            m_SFVL.setID(iIteration);

            final Set<String> names = filenames.keySet();

            for (final Iterator iter = names.iterator(); iter.hasNext();) {

               final String sName = (String) iter.next();

               String sFilename = filenames.get(sName);

               if (sFilename == null) {

                  ooset.getOutput(sName).setOutputChannel(new FileOutputChannel(null));

               }

               else {

                  sFilename = sFilename + "_" + Integer.toString(iIteration);

                  ooset.getOutput(sName).setOutputChannel(new FileOutputChannel(sFilename));

               }

            }

            m_ProgressMonitor.setDescriptionPrefix("[" + Integer.toString(iIteration) + "/" + Integer.toString(m_iShapesCount)

                                                   + "] ");

            IterativeAlgorithmSingleUnit unit;

            final GeoAlgorithm alg = m_Algorithm.getNewInstance();

            unit = new IterativeAlgorithmSingleUnit(alg, m_ProgressMonitor, Integer.toString(iIteration), m_NumericalOutputs);

            final ExecutorService pool = Executors.newFixedThreadPool(2);

            final Future<Boolean> future = pool.submit(unit);

            Boolean success = null;

            success = future.get();

            if (!success.booleanValue() || m_ProgressMonitor.isCanceled()) {

               break;

            }

            iIteration++;

         }

         catch (final Exception e) {

            Sextante.addErrorToLog(e);

            m_sErrorMessage = e.getMessage();

            break;

         }

      }

      m_ProgressMonitor.close();

      if (m_sErrorMessage != null) {

         JOptionPane.showMessageDialog(null, m_sErrorMessage, Sextante.getText("Error"), JOptionPane.ERROR_MESSAGE);

      }

      final JScrollPane table = createNumericalOutputsTable();

      SextanteGUI.getInputFactory().clearDataObjects();

      SextanteGUI.getInputFactory().createDataObjects();

      if (table != null) {

         AdditionalResults.addComponent(new ObjectAndDescription(m_Algorithm.getName() + "[" + m_sLayerName + "]", table));

      }

   }

   private JScrollPane createNumericalOutputsTable() {

      if (m_NumericalOutputs.size() == 0) {

         return null;

      }

      final JScrollPane jScrollPane = new JScrollPane();

      final JTable jTable = new JTable();

      jScrollPane.setViewportView(jTable);

      final int iRecordsCount = m_NumericalOutputs.size();

      final int iFieldsCount = m_NumericalOutputs.get(0).size();

      final String[] fields = new String[iFieldsCount];

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

         fields[i] = m_NumericalOutputs.get(0).get(i).getDescription();

      }

      final String[][] data = new String[iRecordsCount][fields.length];

      for (int i = 0; i < iRecordsCount; i++) {

         for (int j = 0; j < iFieldsCount; j++) {

            data[i][j] = m_NumericalOutputs.get(i).get(j).getOutputObject().toString();

         }

      }

      final DefaultTableModel model = new DefaultTableModel();

      model.setDataVector(data, fields);

      jTable.setModel(model);

      jTable.setEnabled(false);

      return jScrollPane;

   }

}

package es.unex.sextante.gui.algorithm.iterative;

import java.util.ArrayList;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

import es.unex.sextante.core.GeoAlgorithm;

import es.unex.sextante.core.ITaskMonitor;

import es.unex.sextante.core.OutputObjectsSet;

import es.unex.sextante.core.ProcessTask;

import es.unex.sextante.exceptions.GeoAlgorithmExecutionException;

import es.unex.sextante.gui.core.SextanteGUI;

import es.unex.sextante.outputs.Output;

import es.unex.sextante.outputs.OutputNumericalValue;

/**

 * A task representing a single algorithm execution as a part of a batch process. The process is comprised of several single units

 * like the one represented by this class

 * 

 * @author volaya

 * 

 */

public class IterativeAlgorithmSingleUnit

         implements

            Callable<Boolean> {

   private final GeoAlgorithm                               m_Algorithm;

   private StringBuffer                                     m_sLog;

   private final ITaskMonitor                               m_TaskMonitor;

   private final String                                     m_sUnitName;

   private final ArrayList<ArrayList<OutputNumericalValue>> m_NumericalOutputs;

   /**

    * 

    * @param alg

    *                the algorithm to execute

    * @param monitor

    *                the task monitor to use

    * @param sUnitName

    *                the name of the unit to be executed

    * @param numericalOutputs

    *                an array list to collect numerical outputs produced by the algorithm

    */

   public IterativeAlgorithmSingleUnit(final GeoAlgorithm alg,

                                       final ITaskMonitor monitor,

                                       final String sUnitName,

                                       final ArrayList<ArrayList<OutputNumericalValue>> numericalOutputs) {

      m_Algorithm = alg;

      m_TaskMonitor = monitor;

      m_sUnitName = sUnitName;

      m_NumericalOutputs = numericalOutputs;

   }

   /**

    * Executes the algorithm

    * 

    * @return true if the algorithm was not canceled

    * @throws GeoAlgorithmExecutionException

    */

   public Boolean call() throws GeoAlgorithmExecutionException {

      final ExecutorService pool = Executors.newFixedThreadPool(1);

      final Future<Boolean> p = pool.submit(new ProcessTask(m_Algorithm, SextanteGUI.getOutputFactory(), m_TaskMonitor));

      try {

         final Boolean success = p.get();

         if ((success != null) && success.booleanValue()) {

            changeOutputDescriptions();

            collectIndividualNumericalOutputs();

            final Runnable postProcess = SextanteGUI.getPostProcessTask(m_Algorithm, false);

            if (postProcess != null) {

               postProcess.run();

            }

            return true;

         }

         else {

            return false;

         }

      }

      catch (final Exception e) {

         throw new GeoAlgorithmExecutionException(e.getMessage());

      }

   }

   private void collectIndividualNumericalOutputs() {

      final ArrayList<OutputNumericalValue> numericalOutputs = new ArrayList<OutputNumericalValue>();

      final OutputObjectsSet ooset = m_Algorithm.getOutputObjects();

      for (int i = 0; i < ooset.getOutputObjectsCount(); i++) {

         final Output out = ooset.getOutput(i);

         if (out instanceof OutputNumericalValue) {

            numericalOutputs.add((OutputNumericalValue) out);

         }

      }

      m_NumericalOutputs.add(numericalOutputs);

   }

   private void changeOutputDescriptions() {

      final OutputObjectsSet ooset = m_Algorithm.getOutputObjects();

      for (int i = 0; i < ooset.getOutputObjectsCount(); i++) {

         final Output out = ooset.getOutput(i);

         if (!(out instanceof OutputNumericalValue)) {

            out.setDescription(out.getDescription() + " <" + m_sUnitName + ">");

         }

      }

   }

   /**

    * Returns a string with information about the executed process

    * 

    * @return a string with information about the executed process

    */

   public String getLog() {

      return m_sLog.toString();

   }

}

package es.unex.sextante.gui.algorithm.iterative;

import java.awt.geom.Rectangle2D;

import com.vividsolutions.jts.geom.Envelope;

import com.vividsolutions.jts.geom.Geometry;

import es.unex.sextante.dataObjects.FeatureImpl;

import es.unex.sextante.dataObjects.IFeature;

import es.unex.sextante.dataObjects.IFeatureIterator;

public class SingleFeatureIterator

         implements

            IFeatureIterator {

   private final Geometry m_Geometry;

   private final Object[] m_Record;

   private boolean        m_bHasNext;

   public SingleFeatureIterator(final Geometry geometry,

                                final Object[] record) {

      m_Geometry = geometry;

      m_Record = record;

      m_bHasNext = true;

   }

   public void close() {}

   public int getFeatureCount() {

      return 1;

   }

   public boolean hasNext() {

      return m_bHasNext;

   }

   public IFeature next() {

      m_bHasNext = false;

      return new FeatureImpl(m_Geometry, m_Record);

   }

   public Rectangle2D getExtent() {

      final Envelope envelope = m_Geometry.getEnvelopeInternal();

      return new Rectangle2D.Double(envelope.getMinX(), envelope.getMinY(), envelope.getWidth(), envelope.getHeight());

   }

}

package es.unex.sextante.gui.algorithm;

import info.clearthought.layout.TableLayout;

import info.clearthought.layout.TableLayoutConstants;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.geom.Point2D;

import java.util.ArrayList;

import javax.swing.JButton;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JTextField;

import es.unex.sextante.core.Sextante;

import es.unex.sextante.gui.core.NamedPoint;

import es.unex.sextante.gui.core.SextanteGUI;

/**

 * A panel with two text fields, to introduce point coordinates. It also features a button to access pre-stored coordinates

 * 

 * @author volaya

 * 

 */

public class PointSelectionPanel

         extends

            JPanel {

   private JTextField textFieldX;

   private JButton    jButton;

   private JTextField textFieldY;

   private JLabel     labelX;

   private JLabel     labelY;

   PointSelectionPanel() {

      super();

      initGUI();

   }

   private void initGUI() {

      textFieldX = new JTextField("0");

      textFieldY = new JTextField("0");

      labelX = new JLabel(" X:");

      labelY = new JLabel(" Y:");

      jButton = new JButton();

      jButton.setText("...");

      final TableLayout thisLayout = new TableLayout(new double[][] {

               { 25.0, TableLayoutConstants.FILL, 25.0, TableLayoutConstants.FILL, 5.0, 25.0, 5.0 },

               { TableLayoutConstants.FILL } });

      this.setLayout(thisLayout);

      this.setPreferredSize(new java.awt.Dimension(128, 22));

      this.add(labelX, "0,  0");

      this.add(textFieldX, "1,  0");

      this.add(labelY, "2,  0");

      this.add(textFieldY, "3,  0");

      this.add(jButton, "5, 0");

      jButton.addActionListener(new ActionListener() {

         public void actionPerformed(final ActionEvent evt) {

            showPointSelector();

         }

      });

   }

   protected void showPointSelector() {

      final ArrayList<NamedPoint> coordsList = SextanteGUI.getGUIFactory().getCoordinatesList();

      if (coordsList.size() != 0) {

         final NamedPoint[] pts = coordsList.toArray(new NamedPoint[0]);

         final NamedPoint pt = (NamedPoint) JOptionPane.showInputDialog(this, Sextante.getText("Select_coordinates"),

                  Sextante.getText("Coordinates"), JOptionPane.PLAIN_MESSAGE, null, pts, null);

         if (pt != null) {

            textFieldX.setText(Double.toString(pt.getPoint().getX()));

            textFieldY.setText(Double.toString(pt.getPoint().getY()));

         }

      }

   }

   /**

    * Returns the selected point

    * 

    * @return the point introduced using this panel

    */

   public Point2D getPoint() {

      try {

         final Point2D pt = new Point2D.Double(Double.parseDouble(textFieldX.getText()), Double.parseDouble(textFieldY.getText()));

         return pt;

      }

      catch (final Exception e) {

         return null;

      }

   }

   /**

    * Sets the current point

    * 

    * @param point

    *                the new point to set

    */

   public void setPoint(final Point2D point) {

      textFieldX.setText(Double.toString(Math.floor(point.getX() * 10000.) / 10000.));

      textFieldY.setText(Double.toString(Math.floor(point.getY() * 10000.) / 10000.));

   }

}

package es.unex.sextante.gui.algorithm;

import info.clearthought.layout.TableLayout;

import info.clearthought.layout.TableLayoutConstants;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.JButton;

import javax.swing.JPanel;

import javax.swing.JTextField;

import jsh.shell.Utils;

import es.unex.sextante.core.ParametersSet;

import es.unex.sextante.core.Sextante;

import es.unex.sextante.dataObjects.IVectorLayer;

import es.unex.sextante.exceptions.WrongOutputChannelDataException;

import es.unex.sextante.outputs.DatabaseOutputChannel;

import es.unex.sextante.outputs.FileOutputChannel;

import es.unex.sextante.outputs.IOutputChannel;

import es.unex.sextante.outputs.NullOutputChannel;

import es.unex.sextante.outputs.Output;

import es.unex.sextante.outputs.OutputVectorLayer;

import es.unex.sextante.outputs.OverwriteOutputChannel;

import es.unex.sextante.parameters.Parameter;

/**

 * A panel with a text field and a button, which pops-up a dialog to select an output channel

 * 

 * @author volaya

 * 

 */

public class OutputChannelSelectionPanel

         extends

            JPanel {

   private JTextField          textField;

   private JButton             button;

   private final Output        m_Output;

   private final ParametersSet m_ParametersSet;

   /**

    * Creates a new output channel selection panel

    * 

    * @param out

    *                the output represented by this panel

    * 

    */

   public OutputChannelSelectionPanel(final Output out,

                                      final ParametersSet paramSet) {

      super();

      m_Output = out;

      m_ParametersSet = paramSet;

      initGUI();

   }

   private void initGUI() {

      button = new JButton("...");

      textField = new JTextField(Sextante.getText("[Save_to_temporary_file]"));

      textField.setMaximumSize(new java.awt.Dimension(340, 18));

      button.addActionListener(new ActionListener() {

         public void actionPerformed(final ActionEvent evt) {

            showDialog();

         }

      });

      final TableLayout thisLayout = new TableLayout(new double[][] { { TableLayoutConstants.FILL, 25.0 },

               { TableLayoutConstants.FILL } });

      this.setLayout(thisLayout);

      this.add(textField, "0,  0");

      this.add(button, "1,  0");

   }

   /**

    * Returns the current output channel

    * 

    * @return the current output channel

    * @throws WrongOutputChannelDataException

    *                 if the channel could not be created

    */