/ - Diff - gvSIG tools: ToolBox - gvSIG

org.gvsig.toolbox/tags/org.gvsig.toolbox-1.0.22/org.gvsig.toolbox.core/MANIFEST.MF
	1	Manifest-Version: 1.0
	2	Ant-Version: Apache Ant 1.7.1
	3	Created-By: 16.0-b13 (Sun Microsystems Inc.)
	4	Implementation-Version: 0.7
	5	Built-Date: 2012-10-04 11:28:17
	6
0	7

     #Modified by DOKSoft PropEditor. http://www.doksoft.com
     #Fri Feb 18 11:30:32 CET 2011
     vector=Vectoriel
     raster=Couche matricielle
     [New_model]=[Nouveau mod\u00e8le]
     chart=graphique
     table=table
     text=texte
     Toolbox=Bo\u00eete \u00e0 outils
     Toolbox_models=Mod\u00e8les

     [New_model]=[Nuevo modelo]
     chart=gr\u00e1fico
     raster=raster
     text=texto
     table=tabla
     vector=vectorial
     Java_code=C\u00f3digo Java
     Toolbox=Caja de herramientas
     Toolbox_models=Modelos

     [New_model]=[New model]
     chart=chart
     raster=raster
     text=text
     table=table
     vector=vector
     Java_code=Java code
     Toolbox=Toolbox
     Toolbox_models=Models

org.gvsig.toolbox/tags/org.gvsig.toolbox-1.0.22/org.gvsig.toolbox.core/src/main/resources/META-INF/services/org.gvsig.tools.library.Library
	1	org.gvsig.toolbox.core.ToolboxCoreLibrary

     <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
     <html>
       <head>
         <title>jaitools</title>
       </head>
       <body>
         The JAITools and CollectionFactory helper classes
       </body>
     </html>

     <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
     <html>
       <head>
         <title>jaitools.tilecache</title>
       </head>
       <body>
       An implementation of TileCache which can use disk caching to supplement
       memory, allowing large volumes of image data to be handled
       </body>
     </html>

     <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
     <html>
       <head>
         <title>jaitools.tiledimage</title>
         <meta http-equiv="Content-Type" content="text/html; charset=MacRoman">
       </head>
       <body>
       A writable tiled image class similar to JAI's TiledImage but backed
       by disk as well as memory storage to handle very large images within
       limited memory.
       </body>
     </html>

     package es.unex.sextante.exceptions;
     public class NullParameterAdditionalInfoException
              extends
                 GeoAlgorithmExecutionException {
        public NullParameterAdditionalInfoException() {
           super("Null parameter additional info exception");
+       }
+    }

     package es.unex.sextante.exceptions;
     public class WrongAnalysisExtentException
              extends
                 GeoAlgorithmExecutionException {
        public WrongAnalysisExtentException(final String s) {
           super(s);
+       }
        public WrongAnalysisExtentException() {
           super("Wrong raster extension exception");
+       }
+    }

     package es.unex.sextante.exceptions;
     public class IteratorException
              extends
                 GeoAlgorithmExecutionException {
        public IteratorException() {
           super("Iterator exception");
+       }
        public IteratorException(final String s) {
           super(s);
+       }
+    }

     package es.unex.sextante.exceptions;
     public class WrongOutputIDException
              extends
                 GeoAlgorithmExecutionException {
        public WrongOutputIDException() {
           super("Wrong uoutput ID exception");
+       }
+    }

     package es.unex.sextante.exceptions;
     public class WrongParameterValueException
              extends
                 GeoAlgorithmExecutionException {
        public WrongParameterValueException() {
           super("Wrong parameter value exception");
+       }
+    }

     package es.unex.sextante.exceptions;
     public class RepeatedParameterNameException
              extends
                 Exception {
        public RepeatedParameterNameException() {}
+    }

     package es.unex.sextante.exceptions;
     public class WrongSerializedStringParameterValueException
              extends
                 Exception {
+    }

     package es.unex.sextante.exceptions;
     public class WrongParameterTypeException
              extends
                 GeoAlgorithmExecutionException {
        public WrongParameterTypeException() {
           super("Wrong parameter type execption");
+       }
+    }

     package es.unex.sextante.exceptions;
     public class OptionalParentParameterException
              extends
                 Exception {
        public OptionalParentParameterException() {}
+    }

     package es.unex.sextante.exceptions;
     public class WrongOutputChannelDataException
              extends
                 Exception {
+    }

     package es.unex.sextante.exceptions;
     public class UnsupportedOutputChannelException
              extends
                 GeoAlgorithmExecutionException {
        public UnsupportedOutputChannelException() {
           super("Unsupported output channel");
+       }
+    }

     package es.unex.sextante.exceptions;
     public class GeoAlgorithmExecutionException
              extends
                 Exception {
        public GeoAlgorithmExecutionException(final String s) {
           super(s);
+       }
+    }

     package es.unex.sextante.exceptions;
     public class NullParameterValueException
              extends
                 GeoAlgorithmExecutionException {
        public NullParameterValueException() {
           super("Null parameter value exception");
+       }
+    }

     package es.unex.sextante.exceptions;
     public class WrongParameterIDException
              extends
                 GeoAlgorithmExecutionException {
        public WrongParameterIDException() {
           super("Wrong parameter ID exception");
+       }
+    }

     package es.unex.sextante.exceptions;
     import es.unex.sextante.core.Sextante;
     public class WrongInputException
              extends
                 Exception {
        public WrongInputException() {
           super(Sextante.getText("Wrong_or_missing_parameters_definition"));
+       }
        public WrongInputException(final String s) {
           super(s);
+       }
+    }

     package es.unex.sextante.exceptions;
     public class UndefinedParentParameterNameException
              extends
                 Exception {
        public UndefinedParentParameterNameException() {}
+    }

     package es.unex.sextante.dataObjects;
     import java.awt.geom.Rectangle2D;
     /**
      * Interface for layers
+     *
      * @author volaya
+     *
      */
     public interface ILayer
              extends
                 IDataObject {
        /**
         * Returns the extent covered by the layer
+        *
         * @return the extent of the layer
         */
        public Rectangle2D getFullExtent();
        /**
         * Returns an object with information about the CRS associated to this layer. The class of this object depends on the
         * implementation of this interface
+        *
         * @return An object with information about the CRS used for this layer (i.e. a string with a EPSG code)
         */
        public Object getCRS();
+    }

     package es.unex.sextante.dataObjects;
     /**
      * A simple interface for a database record.
+     *
      * @author volaya
+     *
      */
     public interface IRecord {
        /**
         * Returns the value at a field
+        *
         * @param iField
         *                the index of the field. zero-based
         * @return The value at the specified field
         */
        public Object getValue(int iField);
        /**
         * Returns an array with all the values of the record
+        *
         * @return an array with all the values of the record
         */
        public Object[] getValues();
+    }

     package es.unex.sextante.dataObjects;
     import java.awt.image.DataBuffer;
     import es.unex.sextante.core.AnalysisExtent;
     /**
      * This is the base interface that all 3D raster object have to implement to be able to be used by SEXTANTE algorithms.
+     *
      * @author Victor Olaya. volaya@unex.es
+     *
      */
     public interface I3DRasterLayer
              extends
                 ILayer {
        public static final int RASTER_DATA_TYPE_FLOAT  = DataBuffer.TYPE_FLOAT;
        public static final int RASTER_DATA_TYPE_DOUBLE = DataBuffer.TYPE_DOUBLE;
        public static final int RASTER_DATA_TYPE_INT    = DataBuffer.TYPE_INT;
        public static final int RASTER_DATA_TYPE_SHORT  = DataBuffer.TYPE_SHORT;
        public static final int RASTER_DATA_TYPE_BYTE   = DataBuffer.TYPE_BYTE;
        /**
         * Returns the data type of the layer
+        *
         * @return the data type of the layer
         */
        public int getDataType();
        /**
         * Returns the extent of the whole layer
+        *
         * @return the extent of the whole layer
         */
        public AnalysisExtent getLayerExtent();
        /**
         * Return the original cellsize of the layer. X and Y cellsizes are assumed to be equal
+        *
         * @return the original cellsize of the layer
         */
        public double getCellSize();
        /**
         * Return the original vertical cellsize (Z) of the layer.
+        *
         * @return the original vertical cellsize (Z) of the layer
         */
        public double getCellSizeZ();
        /**
         * Sets the value at a cell
+        *
         * @param x
         *                the x coordinate
         * @param y
         *                the y coordinate
         * @param z
         *                the z coordinate
         * @param dValue
         *                the new value
         */
        public void setCellValue(int x,
                                 int y,
                                 int z,
                                 double dValue);
        /**
         * Gets the no-data value of the layer
+        *
         * @return the no-data value of the layer
         */
        public double getNoDataValue();
        /**
         * Sets the no-data value of the layer
+        *
         * @param dNoDataValue
         *                the new no-data value
         */
        public void setNoDataValue(double dNoDataValue);
        /**
         * Set the value of a cell to the no-data value
+        *
         * @param x
         *                the x coordinate of the cell to set to no-data
         * @param y
         *                the y coordinate of the cell to set to no-data
         * @param z
         *                the z coordinate of the cell to set to no-data
         */
        public void setNoData(int x,
                              int y,
                              int z);
        /**
         * Checks if the given value equals the no-data value of the layer
+        *
         * @param dNoDataValue
         *                a value to check
         * @return true if the given value equals the no-data value of the layer
         */
        public boolean isNoDataValue(double dNoDataValue);
        public byte getCellValueAsByte(int x,
                                       int y,
                                       int z);
        public short getCellValueAsShort(int x,
                                         int y,
                                         int z);
        public int getCellValueAsInt(int x,
                                     int y,
                                     int z);
        public float getCellValueAsFloat(int x,
                                         int y,
                                         int z);
        public double getCellValueAsDouble(int x,
                                           int y,
                                           int z);
        /**
         * Returns the value at a given world coordinate.
+        *
         * @param x
         *                the x coordinate
         * @param y
         *                the y coordinate
         * @param z
         *                the y coordinate
         * @return the value at the given world coordinate
         */
        public double getValueAt(double x,
                                 double y,
                                 double z);
        /**
+        *
         * @param x
         *                the x coordinate(col) of the cell
         * @param y
         *                the y coordinate(row) of the cell
         * @param z
         *                the z coordinate of the cell
+        *
         * @return true if the given cell is within the query window extent
         */
        public boolean isInWindow(int x,
                                  int y,
                                  int z);
        /**
         * Returns the number of columns in the query window of this layer
+        *
         * @return the number of columns in the query window
         */
        public int getNX();
        /**
         * Returns the number of rows in the query window of this layer
+        *
         * @return the number of rows in the query window
         */
        public int getNY();
        /**
         * Returns the number of vertical (z) cols in the query window
+        *
         * @return the number of vertical (z) cols in the query window
         */
        public int getNZ();
+    }

     package es.unex.sextante.dataObjects;
     /**
      * This is the base interface that all table objects have to implement to be able to be used by SEXTANTE algorithms.
+     *
      * Instead of implementing this class directly, it is recommended to extend {@link AbstractTable}
+     *
      * @author Victor Olaya. volaya@unex.es
+     *
      */
     public interface ITable
              extends
                 IDataObject {
        /**
         * Creates a new table
+        *
         * @param sName
         *                The name of the table
         * @param sFilename
         *                The filename associated with the table
         * @param types
         *                an array with attributes data types
         * @param sFields
         *                an array with attributes names
         */
        //	public void create(String sName,
        //						String sFilename,
        //						Class[] types,
        //						String[] sFields);
        /**
         * adds a new record to the table
+        *
         * @param attributes
         *                the values of the record
         */
        public void addRecord(Object[] attributes);
        /**
         * Returns an iterator to iterate the table
+        *
         * @return an iterator to iterate the table
         */
        public IRecordsetIterator iterator();
        /**
         * Returns the name of a field
+        *
         * @param i
         *                the field. zero-based
         * @return The name of the specified field
         */
        public String getFieldName(int i);
        /**
         * Returns the data type of a field
+        *
         * @param i
         *                the field. zero-based
         * @return The data type of the specified field
         */
        public Class getFieldType(int i);
        /**
         * Returns the total number of fields
+        *
         * @return the total number of fields
         */
        public int getFieldCount();
        /**
         * Returns an array with data types of all the fields in the table
+        *
         * @return an array with data types of all the fields in the table
         */
        public Class[] getFieldTypes();
        /**
         * Returns an array with the names of all the fields in the table
+        *
         * @return an array with the names of all the fields in the table
         */
        public String[] getFieldNames();
        /**
         * Returns the total number of records(rows) in the table
+        *
         * @return the total number of records(rows) in the table
         */
        public long getRecordCount();
        /**
         * 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
         */
        public int getFieldIndexByName(String fieldName);
+    }

     package es.unex.sextante.dataObjects;
     /**
      * A simple implementation of the IRecord interface
+     *
      * @author volaya
+     *
      */
     public class RecordImpl
              implements
                 IRecord {
        private final Object m_Values[];
        /**
         * Creates a new record from an array of values
+        *
         * @param values
         *                an array of values
         */
        public RecordImpl(final Object[] values) {
           m_Values = values;
+       }
        public Object getValue(final int field) {
           return m_Values[field];
+       }
        public Object[] getValues() {
           return m_Values;
+       }
+    }

     package es.unex.sextante.dataObjects;
     import com.vividsolutions.jts.geom.Geometry;
     /**
      * A generic interface for features, to be used by SEXTANTE algorithms
+     *
      * @author Victor Olaya volaya@unex.es
+     *
      */
     public interface IFeature {
        /**
         * Returns the geometry of the feature
+        *
         * @return the geometry of the feature
         */
        public Geometry getGeometry();
        /**
         * Returns the set of attributes of the feature
+        *
         * @return the attributes of the feature
         */
        public IRecord getRecord();
+    }

     package es.unex.sextante.dataObjects;
     import java.awt.image.DataBuffer;
     import es.unex.sextante.core.AnalysisExtent;
     /**
      * This is the base interface that all raster object have to implement to be able to be used by SEXTANTE algorithms.
+     *
      * Instead of implementing this class directly, it is recommended to extend {@link AbstractRasterLayer}, since it solves some of
      * the most complex methods, such as grid window definition and resampling methods
+     *
      * @author Victor Olaya. volaya@unex.es
+     *
      */
     public interface IRasterLayer
              extends
                 ILayer {
        public static final int RASTER_DATA_TYPE_FLOAT         = DataBuffer.TYPE_FLOAT;
        public static final int RASTER_DATA_TYPE_DOUBLE        = DataBuffer.TYPE_DOUBLE;
        public static final int RASTER_DATA_TYPE_INT           = DataBuffer.TYPE_INT;
        public static final int RASTER_DATA_TYPE_SHORT         = DataBuffer.TYPE_SHORT;
        public static final int RASTER_DATA_TYPE_BYTE          = DataBuffer.TYPE_BYTE;
        public static final int INTERPOLATION_NearestNeighbour = 0;
        public static final int INTERPOLATION_Bilinear         = 1;
        public static final int INTERPOLATION_InverseDistance  = 2;
        public static final int INTERPOLATION_BicubicSpline    = 3;
        public static final int INTERPOLATION_BSpline          = 4;
        /**
         * Returns the data type of the layer
+        *
         * @return the data type of the layer
         */
        public int getDataType();
        /**
         * Returns the extent of the query window of this layer. Each layer can have a query window, which makes it easier to
         * seamlessly combine several layers.
+        *
         * @return the window grid extent
         */
        public AnalysisExtent getWindowGridExtent();
        /**
         * Returns the extent of the whole layer
+        *
         * @return the extent of the whole layer
         */
        public AnalysisExtent getLayerGridExtent();
        /**
         * Return the cellsize of the query window. X and Y cellsizes are assumed to be equal
+        *
         * @return the cellsize of the query window
         */
        public double getWindowCellSize();
        /**
         * Return the original cellsize of the layer. X and Y cellsizes are assumed to be equal
+        *
         * @return the original cellsize of the layer
         */
        public double getLayerCellSize();
        public void assign(double dValue);
        public void assign(IRasterLayer layer);
        public void assignNoData();
        /**
         * Sets the value at a cell, in the first band of the layer
+        *
         * @param x
         *                the x coordinate (cols)
         * @param y
         *                the y coordinate (rows)
         * @param dValue
         *                the new value
         */
        public void setCellValue(int x,
                                 int y,
                                 double dValue);
        /**
         * Sets the value at a cell
+        *
         * @param x
         *                the x coordinate (cols)
         * @param y
         *                the y coordinate (rows)
         * @param iBand
         *                the band (zero-based)
         * @param dValue
         *                the new value
         */
        public void setCellValue(int x,
                                 int y,
                                 int iBand,
                                 double dValue);
        /**
         * Adds a value to the current value of a cell in the first band of the layer in the first band of the layer
+        *
         * @param x
         *                the x coordinate (cols)
         * @param y
         *                the y coordinate (rows)
         * @param dValue
         *                the value to sum
         */
        public void addToCellValue(int x,
                                   int y,
                                   double dValue);
        /**
         * Adds a value to the current value of a cell
+        *
         * @param x
         *                the x coordinate (cols)
         * @param y
         *                the y coordinate (rows)
         * @param iBand
         *                the band (zero-based)
         * @param dValue
         *                the value to sum
         */
        public void addToCellValue(int x,
                                   int y,
                                   int iBand,
                                   double dValue);
        /**
         * adds the value of another raster layer to this one. Both layers must have the same window This is supposed to be used with
         * monoband layers, so only the first band of each one is used.
         */
        public void add(IRasterLayer layer);
        /**
         * Multiplies all the values of a layer by a fixed value
+        *
         * @param d
         *                the value to multiply
         */
        public void multiply(double d);
        /**
         * Gets the no-data value of the layer
+        *
         * @return the no-data value of the layer
         */
        public double getNoDataValue();
        /**
         * Sets the no-data value of the layer
+        *
         * @param dNoDataValue
         *                the new no-data value
         */
        public void setNoDataValue(double dNoDataValue);
        /**
         * Set the value of a cell to the no-data value
+        *
         * @param x
         *                the x coordinate(col) of the cell to set to no-data
         * @param y
         *                the y coordinate(row) of the cell to set to no-data
         * @param iBand
         *                the band to set to no-data
         */
        public void setNoData(int x,
                              int y,
                              int iBand);
        /**
         * Set the value of a cell in the first band of a layer to the no-data value
+        *
         * @param x
         *                the x coordinate(col) of the cell to set to no-data
         * @param y
         *                the y coordinate(row) of the cell to set to no-data
         */
        public void setNoData(int x,
                              int y);
        /**
         * Checks if the given value equals the no-data value of the layer
+        *
         * @param dNoDataValue
         *                a value to check
         * @return true if the given value equals the no-data value of the layer
         */
        public boolean isNoDataValue(double dNoDataValue);
        //coordinates in the following methods are coordinates of the query window.
        public byte getCellValueAsByte(int x,
                                       int y,
                                       int iBand);
        public byte getCellValueAsByte(int x,
                                       int y);
        public short getCellValueAsShort(int x,
                                         int y,
                                         int iBand);
        public short getCellValueAsShort(int x,
                                         int y);
        public int getCellValueAsInt(int x,
                                     int y,
                                     int iBand);
        public int getCellValueAsInt(int x,
                                     int y);
        public float getCellValueAsFloat(int x,
                                         int y,
                                         int iBand);
        public float getCellValueAsFloat(int x,
                                         int y);
        public double getCellValueAsDouble(int x,
                                           int y,
                                           int iBand);
        public double getCellValueAsDouble(int x,
                                           int y);
        /**
         * Returns the value of a cell in the original image coords, that is, not using the query window. Ckecking that coordinates are
         * within bounds is not needed, and is assumed to be done by methods calling this method.
+        *
         * @param x
         *                the x coordinate(col) of the cell
         * @param y
         *                the y coordinate(row) of the cell
         * @param band
         *                the band to be queried
         * @return the value of a cell in the original image coords.
         */
        public double getCellValueInLayerCoords(int x,
                                                int y,
                                                int band);
        /**
         * Returns the value at a given world coordinate. The current interpolation method is used if the coordinate does not fall on
         * the exact center of a cell.
+        *
         * @param x
         *                the x coordinate
         * @param y
         *                the y coordinate
         * @param iBand
         *                the band to query
         * @return the value at the given world coordinate
         */
        public double getValueAt(double x,
                                 double y,
                                 int iBand);
        /**
         * Returns the value of the first band of this layer, at a given world coordinate. The current interpolation method is used if
         * the coordinate does not fall on the exact center of a cell.
+        *
         * @param x
         *                the x coordinate
         * @param y
         *                the y coordinate
         * @return the value at the given coordinate. If it falls outside of the layer, the current no-data value of the layer is
         *         returned
         */
        public double getValueAt(double x,
                                 double y);
        /**
+        *
         * @param x
         *                the x coordinate(col) of the cell
         * @param y
         *                the y coordinate(row) of the cell
         * @return true if the given ccell is within the query window extent
         */
        public boolean isInWindow(int x,
                                  int y);
        /**
         * Returns the number of columns in the query window of this layer
+        *
         * @return the number of columns in the query window
         */
        public int getNX();
        /**
         * Returns the number of rows in the query window of this layer
+        *
         * @return the number of rows in the query window
         */
        public int getNY();
        /**
         * Returns the number of bands of the layer
+        *
         * @return the number of bands of the layer
         */
        public int getBandsCount();
        /**
         * Sets the extent of the query window using the full extent of another layer
+        *
         * @param layer
         *                the layer from which to take the extent
         */
        public void setWindowExtent(IRasterLayer layer);
        /**
         * Sets a new query window extent
+        *
         * @param gridExtent
         *                the new grid extent to set fro this layer
         */
        public void setWindowExtent(AnalysisExtent gridExtent);
        /**
         * Sets the query window extent to the full extent of the layer
         */
        public void setFullExtent();
        /**
         * Resamples the layer so the new full extent is the same as a given gridExtent. This method is called before calling
         * postProcess, once a GeoAlgorithm is finished
+        *
         * @param gridExtent
         *                the reference gridExtent
         */
        //public void fitToGridExtent(AnalysisExtent gridExtent);
        /**
         * Sets the interpolation method to use for calculating value in points other than cell centers
+        *
         * @param iMethod
         */
        public void setInterpolationMethod(int iMethod);
        /**
         * Returns the mean value in the first band of the layer
+        *
         * @return the mean value of the first band of this layer
         */
        public double getMeanValue();
        /**
         * Returns the min value in the first band of the layer
+        *
         * @return the min value of the first band of this layer
         */
        public double getMinValue();
        /**

Application: gvSIG desktop » gvSIG tools: ToolBox

Revision 171