Application: gvSIG desktop » gvSIG tools: ToolBox

import com.vividsolutions.jts.geom.Envelope;

import com.vividsolutions.jts.geom.Geometry;

import es.unex.sextante.dataObjects.AbstractVectorLayer;

import es.unex.sextante.dataObjects.IFeatureIterator;

import es.unex.sextante.dataObjects.IVectorLayer;

   }

   /*

    * Sets an internal ID. Useful for keeping external algorithm

    * providers such as GRASS informed which feature is being

	      m_ID = ID;

   }

   public int getID () {

	      return ( m_ID );

  }

   public IVectorLayer getOriginalLayer() {

      return m_OriginalLayer;

   }

}

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.GeometryFactory;

import es.unex.sextante.additionalInfo.AdditionalInfoVectorLayer;

import es.unex.sextante.core.GeoAlgorithm;

import es.unex.sextante.core.Sextante;

         input.addFilter(new BoundingBoxFilter(m_AnalysisExtent));

      }

      m_Output = getNewVectorLayer(POINTS, input.getName() + "[" + Sextante.getText("Points") + "]",

      int i = 0;

      final int iShapeCount = input.getShapesCount();

      final IFeatureIterator iter = input.iterator();

import com.vividsolutions.jts.geom.Geometry;

import es.unex.sextante.additionalInfo.AdditionalInfoNumericalValue;

import es.unex.sextante.additionalInfo.AdditionalInfoVectorLayer;

import es.unex.sextante.core.GeoAlgorithm;

      System.arraycopy(in_fnames, 0, out_fnames, 0, in_fnames.length);

      out_fnames[out_fnames.length - 1] = "GROUP_ID";

      final IVectorLayer driver = getNewVectorLayer(GroupNearFeaturesAlgorithm.RESULT, Sextante.getText("Grouped_Layer"),

      final int iTotal = layerIn.getShapesCount();

      int groupID = 0;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.util.AffineTransformation;

import es.unex.sextante.additionalInfo.AdditionalInfoNumericalValue;

import es.unex.sextante.additionalInfo.AdditionalInfoVectorLayer;

import es.unex.sextante.core.GeoAlgorithm;

         layerIn.addFilter(new BoundingBoxFilter(m_AnalysisExtent));

      }

      m_Output = getNewVectorLayer(RESULT, Sextante.getText("Capa_transformada"), layerIn.getShapeType(),

      final AffineTransformation at = new AffineTransformation();

      at.compose(AffineTransformation.translationInstance(-dAnchorX, -dAnchorY));

import com.vividsolutions.jts.geom.Geometry;

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

/**

 * This is the base interface that all vector layers have to implement to be able to be used by SEXTANTE algorithms.

 * Instead of implementing this class directly, it is recommended to extend {@link AbstractVectorLayer}.

 * @author Victor Olaya. volaya@unex.es

 */

public interface IVectorLayer

         extends

   public static final int SHAPE_TYPE_LINE         = 1;

   public static final int SHAPE_TYPE_POLYGON      = 2;

   public static final int SHAPE_TYPE_MIXED        = 3;

   //Types to create a multilayer in gvSIG. Don't use for anything more

   public static final int SHAPE_TYPE_MULTIPOINT   = 4;

   public static final int SHAPE_TYPE_MULTILINE    = 5;

   /**

    * Adds a new feature to the layer

    * @param geometry

    *                the geometry

    * @param attributes

   /**

    * Adds a new feature to the layer

    * @param feature

    *                the feature to add

    */

   /**

    * Returns an iterator to iterate through the entities of this layer

    * @return an iterator to iterate the layer

    */

   public IFeatureIterator iterator();

   /**

    * Returns the name of a given field in the attributes table

    * @param index

    *                the zero-based field index

    * @return the name of the selected attribute field

   /**

    * Return a class representing the data type of a given field

    * @param index

    *                the zero-based field index

    * @return the data type of the selected attribute field

   /**

    * @return the number of attributes associates to each geometry

    */

   public int getFieldCount();

   /**

    * Returns an array of classes representing the data types of the fields in the attributes table

    * @return the data types of attribute fields

    */

   public Class[] getFieldTypes();

   /**

    * Returns the names of the fields in the attributes table

    * @return the names of the attribute fields

    */

   public String[] getFieldNames();

   /**

    * Returns the number of features in this layer

    * @return the number of features in this layer

    */

   public int getShapesCount();

   /**

    * Returns the type of geometries in this layer

    * @return the type of geometries in this layer

    */

   public int getShapeType();

   /**

    * Returns the index of a field from its name. Returns -1 if there is not a field with that name.

    * @param fieldName

    *                the name of the field

    * @return the index of the given field

   /**

    * Adds a new filter to this layer. When iterating the features in this layer, only those that pass the filter will be

    * returned.

    * @param filter

    *                the filter to add

    */

   /**

    * Returns a list of all the filters currently added to this layer

    * @return a list of all the filters currently added to this layer

    */

   public List<IVectorLayerFilter> getFilters();

   /**

    * Returns true if the layer can be edited. This includes editing while the layer is being read, so it can be overwritten by

    * algorithms that allow overwriting of input layers

    * @return true if the layer can be edited

    */

   public boolean canBeEdited();

}

/**

 * An output representing a vector layer

 * @author volaya

 */

public class OutputVectorLayer

         extends

   public static final int SHAPE_TYPE_UNDEFINED = -1;

   private int             m_iShapeType;

   private String          m_sInputLayerToOverwrite;

   /**

    * Returns the shape type of this output vector layer

    * @return the shape type of this output vector layer

    */

   public int getShapeType() {

   /**

    * Sets the shape type of this output vector layer

    * @param shapeType

    *                The shape type of this output

    */

      final Output out = super.getNewInstance();

      ((OutputVectorLayer) out).setShapeType(m_iShapeType);

      ((OutputVectorLayer) out).setInputLayerToOverwrite(m_sInputLayerToOverwrite);

      return out;

      super.setObjectData(output);

      if (output instanceof OutputVectorLayer) {

         this.setShapeType(((OutputVectorLayer) output).getShapeType());

      }

   }

   /**

    * Returns the name of the input parameter that this output can overwrite

    * @return the name of the input parameter that this output can overwrite

    */

   public String getInputLayerToOverwrite() {

   /**

    * Sets the name of the input parameter that this output can overwrite. Returns null if it cannot overwrite.

    * @param inputLayerToOverwrite

    *                the name of the input parameter that this output can overwrite

    */

   }

}

/**

 * An OutputFactory defines how new data objects (layers and tables) are created. Method in this class are called from

 * geoalgorithms to create output objects

 * @author Victor Olaya volaya@unex.es

 */

public abstract class OutputFactory {

   /**

    * Use this method to create a new IVectorLayer that can be used to generate new vector layers as output from the geo-algorithm

    * @param sName

    *                the name of the layer

    * @param iShapeType

                                                  IOutputChannel channel,

                                                  Object crs) throws UnsupportedOutputChannelException;

   /**

    * Use this method to create a new IVectorLayer that can be used to generate new vector layers as output from the geo-algorithm

    * @param sName

    *                the name of the layer

    * @param iShapeType

                                                  Object crs,

                                                  int[] fieldSize) throws UnsupportedOutputChannelException;

   /**

    * Use this method to create a new raster layer as output from the geo-algorithm. The characteristics of the raster layer

    * (extent and cellsize) are taken from the extent parameter.

    * @param sName

    *                the name of the layer

    * @param iDataType

    * @param crs

    *                An object with information to set the CRS of this layer (i.e. a string with a EPSG code)

    * @return a raster layer

    */

   public abstract IRasterLayer getNewRasterLayer(String sName,

                                                  int iDataType,

   /**

    * Use this method to create a new 3D raster layer as output from the geo-algorithm. The characteristics of the raster layer

    * (extent and cellsizes) are taken from the extent parameter.

    * A default implementation is given, which uses the Default3dRasterLayer class. This way, 3D algorithms can be executed within

    * the context of a GIS that does not support 3D layer, and there is no need to overwrite this method in the corresponding

    * binding

    * @param sName

    *                the name of the layer

    * @param iDataType

   /**

    * Use this method to create a new table.

    * @param sName

    *                the name of the table

    * @param types

   /**

    * @return A temporary filename with the default file extension for vector layers

    */

   public String getTempVectorLayerFilename() {

   /**

    * @return A temporary filename with the default file extension for raster layers

    */

   public String getTempRasterLayerFilename() {

   /**

    * @return A temporary filename with the default file extension for 3D raster layers

    */

   public String getTemp3DRasterLayerFilename() {

   /**

    * @return A temporary filename with the default file extension for tables

    */

   public String getTempTableFilename() {

   /**

    * @return A temporary folder name

    */

   public String getTempFoldername() {

   /**

    * @param out

    *                an Output object

    * @return A temporary filename with the default file extension for the specified type of output

   /**

    * Returns a temporary filename with no extension

    * @returns a temporary filename with no extension.

    */

   public String getTempFilenameWithoutExtension() {

   /**

    * Returns the temporary folder. This will be used to store outputs when they do not have an associated filename an it is

    * needed

    * @return a temporary folder

    */

   public abstract String getTempFolder();

    * Returns the extensions supported by this factory for creating raster layers. If a filename with an extension not found in

    * this list of extensions is used to create a raster layer, the default extension (the first one of the list) will be added to

    * the filename when creating that layer.

    * @return the list of supported extensions for raster layers

    */

   public abstract String[] getRasterLayerOutputExtensions();

    * Returns the extensions supported by this factory for creating 3d raster layers. If a filename with an extension not found in

    * this list of extensions is used to create a 3d raster layer, the default extension (the first one of the list) will be added

    * to the filename when creating that layer.

    * A default implementation is given, which returns just the "asc" extension used by the default implementation of the

    * getNew3DRasterLayer method, which uses the Default3DRasterLayer class

    * @return the list of supported extensions for 3d raster layers

    */

   public String[] get3DRasterLayerOutputExtensions() {

    * Returns the extensions supported by this factory for creating vector layers. If a filename with an extension not found in

    * this list of extensions is used to create a vector layer, the default extension (the first one of the list) will be added to

    * the filename when creating that layer.

    * @return the list of supported extensions for vector layers

    */

   public abstract String[] getVectorLayerOutputExtensions();

    * Returns the extensions supported by this factory for creating raster layers. If a filename with an extension not found in

    * this list of extensions is used to create a raster layer, the default extension (the first one of the list) will be added to

    * the filename when creating that layer.

    * @return the list of supported extensions for raster layers

    */

   public abstract String[] getTableOutputExtensions();

   /**

    * Returns the task monitor that will be used to monitor algorithm execution

    * @param sTitle

    *                a String used to identify the monitor. This will be used, for instance, as the title string of a progress

    *                dialog.

   /**

    * Returns the default CRS for new layers. This will be used when the geoalgorithm generates new layers but does not take any

    * other layer as input, so the CRS cannot be defined from the inputs

    * @return an object containing information about the default CRS (i.e. a String with the EPSG code of the CRS)

    */

   public abstract Object getDefaultCRS();

   /**

    * Returns the default no data value for raster layers created by this output factory

    * @return the default no data value for raster layers created by this output factory

    */

   public double getDefaultNoDataValue() {

   /**

    * Sets the default no data value to use when this output factory cretes a new raster layer

    * @param dValue

    *                the default no data value to use when this output factory cretes a new raster layer

    */

import java.text.DateFormat;

import java.util.ArrayList;

import java.util.Date;

import java.util.HashMap;

import es.unex.sextante.additionalInfo.AdditionalInfoDataObject;

import es.unex.sextante.additionalInfo.AdditionalInfoFixedTable;

import es.unex.sextante.additionalInfo.AdditionalInfoMultipleInput;

import es.unex.sextante.parameters.RasterLayerAndBand;

import es.unex.sextante.shapesTools.ShapesTools;

/**

 * A class defining a geo-algorithm

 *

      return sFilename + "." + exts[0];

   }

   /**

    * This method creates a new vector layer and adds it to the set of output objects of the algorithm. Use this when your

    * algorithm generates a new vector layer and you have to create it.

                                            final String sDescription,

                                            final int iShapeType,

                                            final Class[] types,

      try {

         final OutputVectorLayer out = (OutputVectorLayer) m_OutputObjects.getOutput(sName);

         IVectorLayer layer;

         final IOutputChannel channel = getOutputChannel(sName);

         if(layer!=null){

         }

         return layer;

      }

   }

   /**

    * This method creates a new vector layer and adds it to the set of output objects of the algorithm. Use this when your

    * algorithm generates a new vector layer and you have to create it.

                                            final String[] sFields,

                                            final int[] fieldSize) throws GeoAlgorithmExecutionException {

      try {

         final OutputVectorLayer out = (OutputVectorLayer) m_OutputObjects.getOutput(sName);

         IVectorLayer layer;

         final IOutputChannel channel = getOutputChannel(sName);

         layer = m_OutputFactory.getNewVectorLayer(getLayerName(sName, sDescription), iShapeType, types, sFields, channel, m_CRS,

         addOutputVectorLayer(sName, sDescription, iShapeType, channel, layer, out.getInputLayerToOverwrite());

         return layer;

      }

   }

   /**

    * Adds a new vector layer to the output set

    *

                                       final int iType,

                                       final IOutputChannel channel,

                                       final IVectorLayer layer,

      final OutputVectorLayer out = new OutputVectorLayer();

      out.setName(sName);

      out.setOutputChannel(channel);

      out.setShapeType(iType);

      out.setInputLayerToOverwrite(sInputLayerToOverwrite);

      m_OutputObjects.add(out);

   }

   /**

    * Adds a new vector layer to the output set. The value of the output is null, and so is the filename. Use this method in the

    * DefineCharacteristics() method of the algorithm, to define the outputs expected.

			<groupId>net.sf.kxml</groupId>

			<artifactId>kxml2</artifactId>

		</dependency>

	</dependencies>

</project>