Application: gvSIG desktop » gvSIG tools: ToolBox

Manifest-Version: 1.0

Ant-Version: Apache Ant 1.7.1

Created-By: 16.0-b13 (Sun Microsystems Inc.)

Implementation-Version: 0.7

Built-Date: 2012-10-04 11:28:17

org.gvsig.toolbox.core.ToolboxCoreLibrary

[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

#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

package es.unex.sextante.modeler.elements;

public class ModelElementString

         implements

            IModelElement {

}

package es.unex.sextante.modeler.elements;

import es.unex.sextante.additionalInfo.AdditionalInfoFixedTable;

import es.unex.sextante.additionalInfo.AdditionalInfoMultipleInput;

import es.unex.sextante.additionalInfo.AdditionalInfoVectorLayer;

import es.unex.sextante.exceptions.NullParameterAdditionalInfoException;

import es.unex.sextante.parameters.Parameter;

import es.unex.sextante.parameters.ParameterBand;

import es.unex.sextante.parameters.ParameterBoolean;

import es.unex.sextante.parameters.ParameterFilepath;

import es.unex.sextante.parameters.ParameterFixedTable;

import es.unex.sextante.parameters.ParameterMultipleInput;

import es.unex.sextante.parameters.ParameterNumericalValue;

import es.unex.sextante.parameters.ParameterPoint;

import es.unex.sextante.parameters.ParameterRasterLayer;

import es.unex.sextante.parameters.Parameter3DRasterLayer;

import es.unex.sextante.parameters.ParameterSelection;

import es.unex.sextante.parameters.ParameterString;

import es.unex.sextante.parameters.ParameterTable;

import es.unex.sextante.parameters.ParameterTableField;

import es.unex.sextante.parameters.ParameterVectorLayer;

public class ModelElementFactory {

   public static IModelElement getParameterAsModelElement(final Parameter param) {

      IModelElement element = null;

      try {

         if (param instanceof ParameterRasterLayer) {

            element = new ModelElementRasterLayer();

            ((ModelElementRasterLayer) element).setNumberOfBands(ModelElementRasterLayer.NUMBER_OF_BANDS_UNDEFINED);

         }

         if (param instanceof Parameter3DRasterLayer) {

             element = new ModelElement3DRasterLayer();

         }         

         else if (param instanceof ParameterVectorLayer) {

            element = new ModelElementVectorLayer();

            final AdditionalInfoVectorLayer ai = (AdditionalInfoVectorLayer) param.getParameterAdditionalInfo();

            ((ModelElementVectorLayer) element).setShapeType(ai.getShapeType());

         }

         else if (param instanceof ParameterTable) {

            element = new ModelElementTable();

         }

         else if (param instanceof ParameterPoint) {

            element = new ModelElementPoint();

         }

         else if (param instanceof ParameterNumericalValue) {

            element = new ModelElementNumericalValue();

         }

         else if (param instanceof ParameterString) {

            element = new ModelElementString();

         }

         else if (param instanceof ParameterFilepath) {

             element = new ModelElementFilepath();

          }         

         else if (param instanceof ParameterFixedTable) {

            element = new ModelElementFixedTable();

            final AdditionalInfoFixedTable aift = (AdditionalInfoFixedTable) param.getParameterAdditionalInfo();

            ((ModelElementFixedTable) element).setRowsCount(aift.getRowsCount());

            ((ModelElementFixedTable) element).setColsCount(aift.getColsCount());

            ((ModelElementFixedTable) element).setIsNumberOfRowsFixed(aift.isNumberOfRowsFixed());

         }

         else if (param instanceof ParameterSelection) {

            element = new ModelElementSelection();

         }

         else if (param instanceof ParameterMultipleInput) {

            element = new ModelElementInputArray();

            final AdditionalInfoMultipleInput ai = (AdditionalInfoMultipleInput) param.getParameterAdditionalInfo();

            ((ModelElementInputArray) element).setType(ai.getDataType());

         }

         else if (param instanceof ParameterBoolean) {

            element = new ModelElementBoolean();

         }

         else if (param instanceof ParameterMultipleInput) {

            element = new ModelElementInputArray();

         }

         else if (param instanceof ParameterTableField) {

            element = new ModelElementTableField();

         }

         else if (param instanceof ParameterBand) {

            element = new ModelElementBand();

         }

      }

      catch (final NullParameterAdditionalInfoException e) {

      }

      return element;

   }

}

package es.unex.sextante.modeler.elements;

public class ModelElementFixedTable

         implements

            IModelElement {

   private int     m_iRowsCount;

   private int     m_iColsCount;

   private boolean m_bIsNumberOfRowsFixed;

   public void setRowsCount(final int rowsCount) {

      m_iRowsCount = rowsCount;

   }

   public void setColsCount(final int colsCount) {

      m_iColsCount = colsCount;

   }

   public void setIsNumberOfRowsFixed(final boolean isNumberOfRowsFixed) {

      m_bIsNumberOfRowsFixed = isNumberOfRowsFixed;

   }

   public int getColsCount() {

      return m_iColsCount;

   }

   public int getRowsCount() {

      return m_iRowsCount;

   }

}

package es.unex.sextante.modeler.elements;

public class ModelElementNumericalValue

         implements

            IModelElement {

   @Override

   public String toString() {

      return this.getClass().toString();

   }

}

package es.unex.sextante.modeler.elements;

public class ModelElementBoolean

         implements

            IModelElement {

}

package es.unex.sextante.modeler.elements;

public class ModelElement3DRasterLayer

         implements

            IModelElement {

   @Override

   public String toString() {

      return this.getClass().toString();

   }

}

package es.unex.sextante.modeler.elements;

public class ModelElementSelection

         implements

            IModelElement {

}

package es.unex.sextante.modeler.elements;

public class ModelElementTable

         implements

            IModelElement {

   @Override

   public String toString() {

      return this.getClass().toString();

   }

}

package es.unex.sextante.modeler.elements;

public interface IModelElement {

}

package es.unex.sextante.modeler.elements;

public class ModelElementPoint

         implements

            IModelElement {

}

package es.unex.sextante.modeler.elements;

public class ModelElementTableField

         implements

            IModelElement {

}

package es.unex.sextante.modeler.elements;

public class ModelElementFilepath

         implements

            IModelElement {

   @Override

   public String toString() {

      return this.getClass().toString();

   }

}

package es.unex.sextante.modeler.elements;

public class ModelElementRasterLayer

         implements

            IModelElement {

   public static final int NUMBER_OF_BANDS_UNDEFINED = -1;

   private int             m_iNumberOfBands          = NUMBER_OF_BANDS_UNDEFINED;

   public int getNumberOfBands() {

      return m_iNumberOfBands;

   }

   public void setNumberOfBands(int numberOfBands) {

      if (numberOfBands < 1) {

         numberOfBands = NUMBER_OF_BANDS_UNDEFINED;

      }

      m_iNumberOfBands = numberOfBands;

   }

   @Override

   public String toString() {

      return this.getClass().toString() + "," + Integer.toString(m_iNumberOfBands);

   }

}

package es.unex.sextante.modeler.elements;

public class ModelElementInputArray

         implements

            IModelElement {

   private int             m_iType;

   public static final int DATA_TYPE_RASTER         = 1;

   public static final int DATA_TYPE_VECTOR_POINT   = 2;

   public static final int DATA_TYPE_VECTOR_LINE    = 3;

   public static final int DATA_TYPE_VECTOR_POLYGON = 4;

   public static final int DATA_TYPE_VECTOR_ANY     = 5;

   public static final int DATA_TYPE_TABLE          = 6;

   public static final int DATA_TYPE_BAND           = 7;

   public int getType() {

      return m_iType;

   }

   public void setType(final int type) {

      m_iType = type;

   }

}

package es.unex.sextante.modeler.elements;

import es.unex.sextante.dataObjects.IVectorLayer;

public class ModelElementVectorLayer

         implements

            IModelElement {

   public static final int SHAPE_TYPE_POLYGON   = IVectorLayer.SHAPE_TYPE_POLYGON;

   public static final int SHAPE_TYPE_POINT     = IVectorLayer.SHAPE_TYPE_POINT;

   public static final int SHAPE_TYPE_LINE      = IVectorLayer.SHAPE_TYPE_LINE;

   public static final int SHAPE_TYPE_UNDEFINED = -1;

   private int             m_iShapeType;

   public int getShapeType() {

      return m_iShapeType;

   }

   public void setShapeType(final int shapeType) {

      m_iShapeType = shapeType;

   }

   @Override

   public String toString() {

      return this.getClass().toString() + "," + Integer.toString(m_iShapeType);

   }

}

package es.unex.sextante.modeler.elements;

public class ModelElementBand

         implements

            IModelElement {

}

package es.unex.sextante.core;

/**

 * A task that can be monitored

 *

 * @author Victor Olaya volaya@unex.es

 *

 */

public interface IMonitorableTask {

   /**

    * Returns true if tha task has been canceled

    *

    * @return true if the task has been canceled

    */

   public boolean isCanceled();

   /**

    * Returns true is the task is finished and is not running anymore

    *

    * @return true is the task is finished and is not running anymore

    */

   public boolean isFinished();

}

package es.unex.sextante.core;

import java.util.ArrayList;

import es.unex.sextante.additionalInfo.AdditionalInfoVectorLayer;

import es.unex.sextante.dataObjects.I3DRasterLayer;

import es.unex.sextante.dataObjects.IDataObject;

import es.unex.sextante.dataObjects.ILayer;

import es.unex.sextante.dataObjects.IRasterLayer;

import es.unex.sextante.dataObjects.ITable;

import es.unex.sextante.dataObjects.IVectorLayer;

import es.unex.sextante.parameters.RasterLayerAndBand;

public abstract class AbstractInputFactory

         implements

            IInputFactory {

   public static final int SHAPE_TYPE_ANY = AdditionalInfoVectorLayer.SHAPE_TYPE_ANY;

   protected IDataObject[] m_Objects;

   public void clearDataObjects() {

      m_Objects = null;

   }

   public void removeDataObject(final String sName) {

      final ArrayList<IDataObject> list = new ArrayList<IDataObject>();

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

         if (!m_Objects[i].getName().equals(sName)) {

            list.add(m_Objects[i]);

         }

      }

      m_Objects = list.toArray(new IDataObject[0]);

   }

   public void addDataObject(final IDataObject obj) {

      final IDataObject[] newObjects = new IDataObject[m_Objects.length + 1];

      System.arraycopy(m_Objects, 0, newObjects, 0, m_Objects.length);

      newObjects[m_Objects.length] = obj;

      m_Objects = newObjects;

   }

   public void removeObject(final IDataObject obj) {

      final ArrayList<IDataObject> list = new ArrayList();

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

         if (m_Objects[i] != obj) {

            list.add(m_Objects[i]);

         }

      }

      m_Objects = list.toArray(new IDataObject[0]);

   }

   public RasterLayerAndBand[] getBands() {

      final ArrayList list = new ArrayList();

      final IRasterLayer[] layers = getRasterLayers();

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

         for (int j = 0; j < layers[i].getBandsCount(); j++) {

            final RasterLayerAndBand rab = new RasterLayerAndBand(layers[i], j);

            list.add(rab);

         }

      }

      final RasterLayerAndBand[] bands = new RasterLayerAndBand[list.size()];

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

         bands[i] = (RasterLayerAndBand) list.get(i);

      }

      return bands;

   }

   public ILayer[] getLayers() {

      final ArrayList list = new ArrayList();

      final Object[] objs = getDataObjects();

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

         if (objs[i] instanceof ILayer) {

            list.add(objs[i]);

         }

      }

      final ILayer[] layers = new ILayer[list.size()];

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

         layers[i] = (ILayer) list.get(i);

      }

      return layers;

   }

   public IRasterLayer[] getRasterLayers() {

      final ArrayList list = new ArrayList();

      final Object[] objs = getDataObjects();

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

         if (objs[i] instanceof IRasterLayer) {

            list.add(objs[i]);

         }

      }

      final IRasterLayer[] layers = new IRasterLayer[list.size()];

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

         layers[i] = (IRasterLayer) list.get(i);

      }

      return layers;

   }

   public I3DRasterLayer[] get3DRasterLayers() {

      final ArrayList list = new ArrayList();

      final Object[] objs = getDataObjects();

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

         if (objs[i] instanceof I3DRasterLayer) {

            list.add(objs[i]);

         }

      }

      final I3DRasterLayer[] layers = new I3DRasterLayer[list.size()];

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

         layers[i] = (I3DRasterLayer) list.get(i);

      }

      return layers;

   }

   public IVectorLayer[] getVectorLayers(final int shapeType) {

      final ArrayList list = new ArrayList();

      final Object[] objs = getDataObjects();

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

         if (objs[i] instanceof IVectorLayer) {

            final IVectorLayer layer = (IVectorLayer) objs[i];

            if (layer.getShapeType() != IVectorLayer.SHAPE_TYPE_WRONG) {

               if ((layer.getShapeType() == shapeType) || (shapeType == SHAPE_TYPE_ANY)) {

                  list.add(objs[i]);

               }

            }

         }

      }

      final IVectorLayer[] layers = new IVectorLayer[list.size()];

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

         layers[i] = (IVectorLayer) list.get(i);

      }

      return layers;

   }

   public ITable[] getTables() {

      final ArrayList list = new ArrayList();

      final Object[] objs = getDataObjects();

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

         if (objs[i] instanceof ITable) {

            list.add(objs[i]);

         }

      }

      final ITable[] tables = new ITable[list.size()];

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

         tables[i] = (ITable) list.get(i);

      }

      return tables;

   }

   public IDataObject[] getDataObjects() {

      return m_Objects;

   }

   public IDataObject getInputFromName(final String sName) {

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

         if (m_Objects[i].getName().equals(sName)) {

            return m_Objects[i];

         }

      }

      return null;

   }

}

package es.unex.sextante.core;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.GeometryFactory;

import es.unex.sextante.dataObjects.I3DRasterLayer;

import es.unex.sextante.dataObjects.ILayer;

import es.unex.sextante.dataObjects.IRasterLayer;

import es.unex.sextante.rasterWrappers.Grid3DCell;

import es.unex.sextante.rasterWrappers.GridCell;

/**

 * This class defines an output region (extent coordinates and cellsize)

 * 

 * @author Victor Olaya

 * 

 */

public class AnalysisExtent {

   //these values are cell border coordinates, not centered ones

   double m_dXMin      = 0;

   double m_dYMin      = 0;

   double m_dZMin      = 0;

   double m_dXMax      = 0;

   double m_dYMax      = 0;

   double m_dZMax      = 0;

   double m_dCellSize  = 1;

   double m_dCellSizeZ = 1;

   int    m_iNX;

   int    m_iNY;

   int    m_iNZ;

   public AnalysisExtent() {

   }

   /**

    * Creates a new grid extent using the extent of a layer. If it is a raster layer, it will also use its cellsize. If it is a 3d

    * raster layer, it will use its z values

    * 

    * @param layer

    *                a layer

    */

   public AnalysisExtent(final ILayer layer) {

      m_dXMin = layer.getFullExtent().getMinX();

      m_dXMax = layer.getFullExtent().getMaxX();

      m_dYMin = layer.getFullExtent().getMinY();

      m_dYMax = layer.getFullExtent().getMaxY();

      if (layer instanceof IRasterLayer) {

         final IRasterLayer rasterLayer = (IRasterLayer) layer;

         m_dCellSize = rasterLayer.getLayerGridExtent().getCellSize();

         recalculateNXAndNY();

      }

      else if (layer instanceof I3DRasterLayer) {

         final I3DRasterLayer raster3DLayer = (I3DRasterLayer) layer;

         m_dZMin = raster3DLayer.getLayerExtent().getZMin();

         m_dZMax = raster3DLayer.getLayerExtent().getZMax();

         m_dCellSizeZ = raster3DLayer.getCellSizeZ();

         recalculateNZ();

      }

   }

   /**

    * Sets a new range for X coordinates. Coordinates are not center cell ones, but border ones

    * 

    * @param dXMin

    *                the minimum x coordinate of the extent.

    * @param dXMax

    *                the maximum x coordinate of the extent

    * @param bRecalculateWithCellsize

    *                if this parameter is true, the range will be adapted to match the cellsize. Use this when you are working

    *                with raster layers. Make sure that the cellsize has been set in advance.

    */

   public void setXRange(final double dXMin,

                         final double dXMax,

                         final boolean bRecalculateWithCellsize) {

      m_dXMin = Math.min(dXMin, dXMax);

      m_dXMax = Math.max(dXMin, dXMax);

      if (bRecalculateWithCellsize) {

         recalculateNXAndNY();

      }

   }

   /**

    * Sets a new range for Y coordinates. Coordinates are not center cell ones, but border ones

    * 

    * @param dYMin

    *                the minimum Y coordinate of the extent.

    * @param dYMax

    *                the maximum Y coordinate of the extent

    * @param bRecalculateWithCellsize

    *                if this parameter is true, the range will be adapted to match the cellsize. Use this when you are working

    *                with raster layers. Make sure that the cellsize has been set in advance.

    */

   public void setYRange(final double dYMin,

                         final double dYMax,

                         final boolean bRecalculateWithCellsize) {

      m_dYMin = Math.min(dYMin, dYMax);

      m_dYMax = Math.max(dYMin, dYMax);

      if (bRecalculateWithCellsize) {

         recalculateNXAndNY();

      }

   }

   /**

    * Sets a new range for Z coordinates. Coordinates are not center cell ones, but border ones

    * 

    * @param dZMin

    *                the minimum z coordinate of the extent.

    * @param dZMax

    *                the maximum z coordinate of the extent

    * @param bRecalculateWithCellsize

    *                if this parameter is true, the range will be adapted to match the cellsize. Use this when you are working

    *                with raster layers. Make sure that the cellsize has been set in advance.

    */

   public void setZRange(final double dZMin,

                         final double dZMax,

                         final boolean bRecalculateWithCellsize) {

      m_dZMin = Math.min(dZMin, dZMax);

      m_dZMax = Math.max(dZMin, dZMax);

      if (bRecalculateWithCellsize) {

         recalculateNZ();

      }

   }

   /**

    * Returns the cellsize of this extent

    * 

    * @return the cellsize of this extent

    */

   public double getCellSize() {

      return m_dCellSize;

   }

   /**

    * Sets a new cellsize for this extent

    * 

    * @param cellSize

    *                the new cellsize

    */

   public void setCellSize(final double cellSize) {

      if (cellSize <= 0) {

        m_dCellSize = 1;

      } else  {

        m_dCellSize = cellSize;

      }

      recalculateNXAndNY();

   }

   /**

    * Returns the z cellsize of this extent

    * 

    * @return the z cellsize of this extent

    */

   public double getCellSizeZ() {

      return m_dCellSizeZ;

   }

   /**

    * Sets a new z cellsize for this extent

    * 

    * @param cellSize

    *                the new cellsize

    */

   public void setCellSizeZ(final double cellSize) {

      m_dCellSizeZ = cellSize;

      recalculateNZ();

   }

   /**

    * Returns the number of columns in the extent

    * 

    * @return the number of columns

    */

   public int getNX() {

      return m_iNX;

   }

   /**

    * Returns the number of rows in the extent

    * 

    * @return the number of rows

    */

   public int getNY() {

      return m_iNY;

   }

   /**

    * Returns the number of rows in the extent

    * 

    * @return the number of rows

    */

   public int getNZ() {

      return m_iNZ;

   }

   private void recalculateNXAndNY() {

      m_iNY = (int) Math.floor((m_dYMax - m_dYMin) / m_dCellSize);

      m_iNX = (int) Math.floor((m_dXMax - m_dXMin) / m_dCellSize);

      m_dXMax = m_dXMin + m_dCellSize * m_iNX;

      m_dYMax = m_dYMin + m_dCellSize * m_iNY;

   }

   private void recalculateNZ() {

      m_iNZ = (int) Math.floor((m_dZMax - m_dZMin) / m_dCellSizeZ);

      m_dZMax = m_dZMin + m_dCellSizeZ * m_iNZ;

   }

   /**

    * Return the minimum x coordinate of the extent. For raster layers, this is not the coordinate of the center of the left-most

    * cell, but the the coordinate of its left border

    * 

    * @return the minimum x coordinate of the extent

    */

   public double getXMin() {

      return m_dXMin;

   }

   /**

    * Return the maximum x coordinate of the extent. For raster layers, this is not the coordinate of the center of the right-most

    * cell, but the the coordinate of its right border

    * 

    * @return the maximum x coordinate of the extent

    */

   public double getXMax() {

      return m_dXMax;

   }

   /**

    * Return the minimum x coordinate of the extent. For raster layers, this is not the coordinate of the center of the lower

    * cell, but the the coordinate of its lower border

    * 

    * @return the minimum y coordinate of the extent

    */

   public double getYMin() {

      return m_dYMin;

   }

   /**

    * Return the maximum y coordinate of the extent. For raster layers, this is not the coordinate of the center of the upper

    * cell, but the the coordinate of its upper border

    * 

    * @return the maximum y coordinate of the extent

    */

   public double getYMax() {

      return m_dYMax;

   }

   /**

    * Return the minimum z coordinate of the extent. For raster layers, this is not the coordinate of the center of the lower

    * cell, but the the coordinate of its lower border

    * 

    * @return the minimum y coordinate of the extent

    */

   public double getZMin() {

      return m_dZMin;

   }

   /**

    * Return the maximum z coordinate of the extent. For raster layers, this is not the coordinate of the center of the upper

    * cell, but the the coordinate of its upper border

    * 

    * @return the maximum z coordinate of the extent

    */

   public double getZMax() {

      return m_dZMax;

   }

   /**

    * Returns the real X distance spanned by this extent

    * 

    * @return the real X distance spanned by this extent

    */

   public double getWidth() {

      return m_dXMax - m_dXMin;

   }

   /**

    * Returns the real Y distance spanned by this extent

    * 

    * @return the real Y distance spanned by this extent

    */

   public double getLength() {

      return m_dYMax - m_dYMin;

   }

   /**

    * Returns the real Z distance spanned by this extent

    * 

    * @return the real Z distance spanned by this extent

    */

   public double getHeight() {

      return m_dZMax - m_dZMin;

   }

   /**

    * Returns true if the given point falls within the area covered by this extent

    * 

    * @param x

    *                the x coordinate of the point

    * @param y

    *                the y coordinate of the point

    * @return whether the given point falls within the XY area covered by this extent

    */

   public boolean contains(final double x,

                           final double y) {

      return ((x >= m_dXMin) && (x <= m_dXMax) && (y >= m_dYMin) && (y <= m_dYMax));

   }

   /**

    * Returns true if the given point falls within the area covered by this extent

    * 

    * @param x

    *                the x coordinate of the point

    * @param y

    *                the y coordinate of the point

    * @param z

    *                the z coordinate of the point

    * 

    * @return whether the given point falls within the volume covered by this extent

    */

   public boolean contains(final double x,

                           final double y,

                           final double z) {

      return ((x >= m_dXMin) && (x <= m_dXMax) && (y >= m_dYMin) && (y <= m_dYMax) && (x >= m_dZMin) && (x <= m_dZMax));

   }

   /**

    * Returns true if the given extent matches the grid defined by this extent extent (has same size and cell boundaries match)

    * 

    * @param extent

    * @return whether the passed extent fits into this extent

    */

   public boolean fitsIn(final AnalysisExtent extent) {

      boolean bFitsX, bFitsY, bFitsZ;

      double dOffset;

      double dOffsetCols;

      double dOffsetRows;

      double dOffsetZ;

      final double MIN_DIF = 0.00001;

      if (extent.getCellSize() != this.getCellSize()) {

         return false;

      }

      dOffset = Math.abs(extent.getXMin() - this.getXMin());

      dOffsetCols = dOffset / this.getCellSize();

      bFitsX = (dOffsetCols - Math.floor(dOffsetCols + 0.5) < MIN_DIF);

      dOffset = Math.abs(extent.getYMax() - this.getYMax());

      dOffsetRows = dOffset / this.getCellSize();

      bFitsY = (Math.abs(dOffsetRows - Math.floor(dOffsetRows + 0.5)) < MIN_DIF);

      dOffset = Math.abs(extent.getZMax() - this.getZMax());

      dOffsetZ = dOffset / this.getCellSizeZ();

      bFitsZ = (Math.abs(dOffsetZ - Math.floor(dOffsetZ + 0.5)) < MIN_DIF);

      return bFitsX && bFitsY && bFitsZ;

   }

   /**

    * Returns true if this extent has the same characteristics as a given one

    * 

    * @param extent

    * @return whether this extent equals the given extent

    */

   public boolean equals(final AnalysisExtent extent) {

      return (m_dXMin == extent.getXMin()) && (m_dXMax == extent.getXMax()) && (m_dYMin == extent.getYMin())

             && (m_dYMax == extent.getYMax()) && (m_dCellSize == extent.getCellSize()) && (m_dZMin == extent.getZMin())

             && (m_dZMax == extent.getZMax()) && (m_dCellSizeZ == extent.getCellSizeZ());

   }

   /**

    * Modifies this extent to incorporate another one into its boundaries

    * 

    * @param extent

    *                the extent to add

    */

   public void addExtent(final AnalysisExtent extent) {

      m_dXMin = Math.min(extent.getXMin(), m_dXMin);

      m_dXMax = Math.max(extent.getXMax(), m_dXMax);

      m_dYMin = Math.min(extent.getYMin(), m_dYMin);

      m_dYMax = Math.max(extent.getYMax(), m_dYMax);

      m_dZMin = Math.min(extent.getZMin(), m_dZMin);

      m_dZMax = Math.max(extent.getZMax(), m_dZMax);

      m_dCellSize = Math.min(extent.getCellSize(), m_dCellSize);

      m_dCellSizeZ = Math.min(extent.getCellSizeZ(), m_dCellSizeZ);

      recalculateNXAndNY();

      recalculateNZ();

   }

   /**

    * Modifies this extent to incorporate another one into its boundaries

    * 

    * @param extent

    *                the extent to add

    */

   public void addExtent(final Rectangle2D extent) {

      m_dXMin = Math.min(extent.getMinX(), m_dXMin);

      m_dXMax = Math.max(extent.getMaxX(), m_dXMax);

      m_dYMin = Math.min(extent.getMinY(), m_dYMin);

      m_dYMax = Math.max(extent.getMaxY(), m_dYMax);

      recalculateNXAndNY();

   }

   /**

    * Converts a world coordinate to grid coordinates

    * 

    * @param pt

    *                a point in world coordinates

    * @return a grid cell with coordinates of the given point in grid coordinates referred to this grid extent

    */

   public GridCell getGridCoordsFromWorldCoords(final Point2D pt) {

      final int x = (int) Math.floor((pt.getX() - m_dXMin) / m_dCellSize);

      final int y = (int) Math.floor((m_dYMax - pt.getY()) / m_dCellSize);

      final GridCell cell = new GridCell(x, y, 0.0);

      return cell;

   }

   /**

    * Converts a world coordinate to grid coordinates

    * 

    * @param x

    *                the x coordinate of the point

    * @param y

    *                the y coordinate of the point

    * @return a grid cell representing the given point in grid coordinates referred to this grid extent

    */

   public GridCell getGridCoordsFromWorldCoords(final double x,

                                                final double y) {

      return getGridCoordsFromWorldCoords(new Point2D.Double(x, y));

   }

   public Grid3DCell getGridCoordsFromWorldCoords(final double x,

                                                  final double y,

                                                  final double z) {

      final int iX = (int) Math.floor((x - m_dXMin) / m_dCellSize);

      final int iY = (int) Math.floor((m_dYMax - y) / m_dCellSize);

      final int iZ = (int) Math.floor((z - m_dZMin) / m_dCellSizeZ);