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-02-23 00:34:19

package es.unex.sextante.hydrology.isocrones;

import java.awt.geom.Point2D;

import es.unex.sextante.additionalInfo.AdditionalInfoNumericalValue;

import es.unex.sextante.core.GeoAlgorithm;

import es.unex.sextante.core.AnalysisExtent;

import es.unex.sextante.core.Sextante;

import es.unex.sextante.dataObjects.IRasterLayer;

import es.unex.sextante.exceptions.GeoAlgorithmExecutionException;

import es.unex.sextante.exceptions.RepeatedParameterNameException;

import es.unex.sextante.rasterWrappers.GridCell;

public class IsocronesAlgorithm

         extends

            GeoAlgorithm {

   private final static int   m_iOffsetX[] = { 0, 1, 1, 1, 0, -1, -1, -1 };

   private final static int   m_iOffsetY[] = { 1, 1, 0, -1, -1, -1, 0, 1 };

   public static final String DEM          = "DEM";

   public static final String NETWORK      = "NETWORK";

   public static final String OUTLET       = "OUTLET";

   public static final String TIME         = "TIME";

   public static final String RATIO        = "RATIO";

   private int                m_iNX, m_iNY;

   private double             m_dSpeed;

   private double             m_dRatio;

   private IRasterLayer       m_DEM        = null;

   private IRasterLayer       m_Network    = null;

   private IRasterLayer       m_TimeOut;

   private GridCell           m_Outlet;

   @Override

   public boolean processAlgorithm() throws GeoAlgorithmExecutionException {

      m_DEM = m_Parameters.getParameterValueAsRasterLayer(DEM);

      m_Network = m_Parameters.getParameterValueAsRasterLayer(NETWORK);

      final Point2D pt = m_Parameters.getParameterValueAsPoint(OUTLET);

      final AnalysisExtent gridExtent = new AnalysisExtent(m_DEM);

      m_DEM.setWindowExtent(gridExtent);

      m_TimeOut = getNewRasterLayer(TIME, Sextante.getText("Time_to_outlet__h"), IRasterLayer.RASTER_DATA_TYPE_FLOAT, gridExtent);

      m_TimeOut.assign(0.0);

      m_Outlet = gridExtent.getGridCoordsFromWorldCoords(pt);

      if (m_Network != null) {

         m_Network.setWindowExtent(gridExtent);

      }

      m_iNX = m_DEM.getNX();

      m_iNY = m_DEM.getNY();

      m_dSpeed = 1.0;

      m_dRatio = 1.0;

      calculateTimeOfConcentration();

      m_dRatio = m_Parameters.getParameterValueAsDouble(RATIO);

      calculateTimeOut();

      m_TimeOut.setNoDataValue(0.0);

      return !m_Task.isCanceled();

   }

   @Override

   public void defineCharacteristics() {

      setName(Sextante.getText("Time_to_outlet"));

      setGroup(Sextante.getText("Basic_hydrological_analysis"));

      setUserCanDefineAnalysisExtent(false);

      setIsDeterminatedProcess(false);

      try {

         m_Parameters.addInputRasterLayer(DEM, Sextante.getText("Elevation"), true);

         m_Parameters.addInputRasterLayer(NETWORK, Sextante.getText("Channel_network"), false);

         m_Parameters.addNumericalValue(RATIO, Sextante.getText("speed_ratio__channel_-_overland"), 10,

                  AdditionalInfoNumericalValue.NUMERICAL_VALUE_DOUBLE);

         m_Parameters.addPoint(OUTLET, Sextante.getText("Outlet_point"));

         addOutputRasterLayer(TIME, Sextante.getText("Time_to_outlet"));

      }

      catch (final RepeatedParameterNameException e) {

         Sextante.addErrorToLog(e);

      }

   }

   private void calculateTimeOfConcentration() {

      int x, y;

      double dValue;

      final GridCell highestCell = new GridCell(0, 0, Double.NEGATIVE_INFINITY);

      writeTimeOut(m_Outlet.getX(), m_Outlet.getY(), m_Outlet.getX(), m_Outlet.getY());

      for (y = 0; y < m_iNY; y++) {

         for (x = 0; x < m_iNX; x++) {

            dValue = m_TimeOut.getCellValueAsDouble(x, y);

            if (!m_TimeOut.isNoDataValue(dValue)) {

               if (dValue > highestCell.getValue()) {

                  highestCell.setX(x);

                  highestCell.setY(y);

                  highestCell.setValue(dValue);

               }

            }

         }

      }

      final double dH1 = m_DEM.getCellValueAsDouble(m_Outlet.getX(), m_Outlet.getY());

      final double dH2 = m_DEM.getCellValueAsDouble(highestCell.getX(), highestCell.getY());

      final double dConcTime = Math.pow(0.87 * Math.pow(highestCell.getValue() / 1000., 3) / (dH2 - dH1), 0.385);

      m_dSpeed = highestCell.getValue() / dConcTime;

   }

   private void calculateTimeOut() {

      m_TimeOut.assign(0.0);

      writeTimeOut(m_Outlet.getX(), m_Outlet.getY(), m_Outlet.getX(), m_Outlet.getY());

   }

   private void writeTimeOut(final int iX1,

                             final int iY1,

                             final int iX2,

                             final int iY2) {

      int i;

      int ix, iy;

      int iDirection;

      double dDist = 1;

      double dTime;

      double dValue;

      if (m_Task.isCanceled()) {

         return;

      }

      dValue = m_DEM.getCellValueAsDouble(iX1, iY1);

      if (!m_DEM.isNoDataValue(dValue)) {

         if ((iX1 == iX2) && (iY1 == iY2)) {

            dDist = 0;

         }

         else if (Math.abs(iX1 - iX2 + iY1 - iY2) == 1) {

            dDist = m_DEM.getDistToNeighborInDir(0);

         }

         else {

            dDist = m_DEM.getDistToNeighborInDir(1);

         }

         dTime = dDist / m_dSpeed;

         if (m_Network != null) {

            dValue = m_Network.getCellValueAsDouble(iX1, iY1);

            if (m_Network.isNoDataValue(dValue) || (dValue == 0)) {

               dTime *= m_dRatio;

            }

         }

         dTime += m_TimeOut.getCellValueAsDouble(iX2, iY2);

         m_TimeOut.setCellValue(iX1, iY1, dTime);

         for (i = 0; i < 8; i++) {

            ix = iX1 + m_iOffsetX[i];

            iy = iY1 + m_iOffsetY[i];

            dValue = m_DEM.getCellValueAsDouble(ix, iy);

            if (!m_DEM.isNoDataValue(dValue)) {

               iDirection = m_DEM.getDirToNextDownslopeCell(ix, iy);

               if (iDirection >= 0) {

                  if ((i + 4) % 8 == iDirection) {

                     writeTimeOut(ix, iy, iX1, iY1);

                  }

               }

            }

         }

      }

   }

}

package es.unex.sextante.hydrology.burnStreams;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.Geometry;

import es.unex.sextante.additionalInfo.AdditionalInfoNumericalValue;

import es.unex.sextante.additionalInfo.AdditionalInfoVectorLayer;

import es.unex.sextante.core.AnalysisExtent;

import es.unex.sextante.core.GeoAlgorithm;

import es.unex.sextante.core.Sextante;

import es.unex.sextante.dataObjects.IFeatureIterator;

import es.unex.sextante.dataObjects.IRasterLayer;

import es.unex.sextante.dataObjects.IVectorLayer;

import es.unex.sextante.exceptions.GeoAlgorithmExecutionException;

import es.unex.sextante.exceptions.RepeatedParameterNameException;

import es.unex.sextante.rasterWrappers.GridCell;

public class BurnStreamsAlgorithm

         extends

            GeoAlgorithm {

   public static final String  STREAMS          = "STREAMS";

   public static final String  DEM              = "DEM";

   public static final String  RESULT           = "RESULT";

   public static final String  DEPTH            = "DEPTH";

   private static final double SMALL_DIFFERENCE = 0.05;

   private IRasterLayer        m_DEM;

   private IRasterLayer        m_Result;

   private double              m_dLastZ;

   private double              m_dDepth;

   private boolean             m_bFoundValidCell;

   @Override

   public boolean processAlgorithm() throws GeoAlgorithmExecutionException {

      m_dDepth = m_Parameters.getParameterValueAsDouble(DEPTH);

      final IVectorLayer lines = m_Parameters.getParameterValueAsVectorLayer(STREAMS);

      m_DEM = m_Parameters.getParameterValueAsRasterLayer(DEM);

      m_DEM.setFullExtent();

      final AnalysisExtent extent = m_DEM.getWindowGridExtent();

      m_Result = getNewRasterLayer(RESULT, Sextante.getText("Modified_DEM"), IRasterLayer.RASTER_DATA_TYPE_DOUBLE, extent);

      m_Result.assign(m_DEM);

      int iShape = 0;

      final int iShapeCount = lines.getShapesCount();

      final IFeatureIterator iterator = lines.iterator();

      while (iterator.hasNext() && setProgress(iShape, iShapeCount)) {

         final Geometry line = iterator.next().getGeometry();

         for (int i = 0; i < line.getNumGeometries(); i++) {

            processLine(line.getGeometryN(i));

         }

         iShape++;

      }

      iterator.close();

      return !m_Task.isCanceled();

   }

   @Override

   public void defineCharacteristics() {

      setName(Sextante.getText("Burn_streams"));

      setGroup(Sextante.getText("Basic_hydrological_analysis"));

      setUserCanDefineAnalysisExtent(false);

      try {

         m_Parameters.addInputVectorLayer(STREAMS, Sextante.getText("Channel_network"),

                  AdditionalInfoVectorLayer.SHAPE_TYPE_LINE, true);

         m_Parameters.addInputRasterLayer(DEM, Sextante.getText("Elevation"), true);

         m_Parameters.addNumericalValue(DEPTH, Sextante.getText("Depth"), AdditionalInfoNumericalValue.NUMERICAL_VALUE_DOUBLE,

                  10, 0, Double.MAX_VALUE);

         addOutputRasterLayer(RESULT, Sextante.getText("Modified_DEM"));

      }

      catch (final RepeatedParameterNameException e) {

         Sextante.addErrorToLog(e);

      }

   }

   private void processLine(final Geometry line) {

      double x, y, x2, y2;

      final Coordinate[] coords = line.getCoordinates();

      m_bFoundValidCell = false;

      for (int i = 0; i < coords.length - 1; i++) {

         x = coords[i].x;

         y = coords[i].y;

         x2 = coords[i + 1].x;

         y2 = coords[i + 1].y;

         processSegment(x, y, x2, y2);

      }

   }

   private void processSegment(double x,

                               double y,

                               final double x2,

                               final double y2) {

      double dx, dy, d, n;

      dx = Math.abs(x2 - x);

      dy = Math.abs(y2 - y);

      if ((dx > 0.0) || (dy > 0.0)) {

         if (dx > dy) {

            dx /= m_DEM.getWindowCellSize();

            n = dx;

            dy /= dx;

            dx = m_DEM.getWindowCellSize();

         }

         else {

            dy /= m_DEM.getWindowCellSize();

            n = dy;

            dx /= dy;

            dy = m_DEM.getWindowCellSize();

         }

         if (x2 < x) {

            dx = -dx;

         }

         if (y2 < y) {

            dy = -dy;

         }

         for (d = 0.0; d <= n; d++, x += dx, y += dy) {

            addPoint(x, y);

         }

      }

   }

   private void addPoint(final double x,

                         final double y) {

      final GridCell cell = m_DEM.getWindowGridExtent().getGridCoordsFromWorldCoords(x, y);

      final int iX = cell.getX();

      final int iY = cell.getY();

      final double z = m_DEM.getCellValueAsDouble(iX, iY) /*- m_dDepth*/;

      if (m_DEM.isNoDataValue(z)) {

         return;

      }

      if (!m_bFoundValidCell) {

         m_dLastZ = z - m_dDepth;

         m_bFoundValidCell = true;

      }

      //if (z >= m_dLastZ) {

      m_dLastZ -= SMALL_DIFFERENCE;

      //}

      m_Result.setCellValue(iX, iY, m_dLastZ);

   }

}

package es.unex.sextante.hydrology.hydroModel;

import java.awt.geom.Point2D;

import java.util.ArrayList;

import com.vividsolutions.jts.geom.Coordinate;

import es.unex.sextante.additionalInfo.AdditionalInfoMultipleInput;

import es.unex.sextante.additionalInfo.AdditionalInfoNumericalValue;

import es.unex.sextante.additionalInfo.AdditionalInfoVectorLayer;

import es.unex.sextante.core.GeoAlgorithm;

import es.unex.sextante.core.AnalysisExtent;

import es.unex.sextante.core.Sextante;

import es.unex.sextante.dataObjects.IFeature;

import es.unex.sextante.dataObjects.IFeatureIterator;

import es.unex.sextante.dataObjects.IRasterLayer;

import es.unex.sextante.dataObjects.IRecord;

import es.unex.sextante.dataObjects.IRecordsetIterator;

import es.unex.sextante.dataObjects.ITable;

import es.unex.sextante.dataObjects.IVectorLayer;

import es.unex.sextante.exceptions.GeoAlgorithmExecutionException;

import es.unex.sextante.exceptions.OptionalParentParameterException;

import es.unex.sextante.exceptions.RepeatedParameterNameException;

import es.unex.sextante.exceptions.UndefinedParentParameterNameException;

import es.unex.sextante.exceptions.UnsupportedOutputChannelException;

import es.unex.sextante.hydrology.modelling.Hydrograph;

import es.unex.sextante.hydrology.modelling.Hyetograph;

public class HydroModelAlgorithm

         extends

            GeoAlgorithm {

   public static final String TABLES               = "TABLES";

   public static final String TIMEOUT              = "TIMEOUT";

   public static final String CN                   = "CN";

   public static final String INTERVALHYDRO        = "INTERVALHYDRO";

   public static final String INTERVALHYETO        = "INTERVALHYETO";

   public static final String FIELD                = "FIELD";

   public static final String STATIONS             = "STATIONS";

   private int                m_iNX, m_iNY;

   private int                m_iIntervalHydro;

   private int                m_iIntervalHyeto;

   private IRasterLayer       m_TimeOut            = null;

   private IRasterLayer       m_CN                 = null;

   private ArrayList          m_Hydrographs;

   private Hyetograph         m_Hyetogram[][];

   private ArrayList          m_Tables;

   private int                m_iTableNameField;

   private boolean            m_bHyetoNamesCreated = false;

   private String[]           m_sHyetoNames;

   @Override

   public boolean processAlgorithm() throws GeoAlgorithmExecutionException {

      m_TimeOut = m_Parameters.getParameterValueAsRasterLayer(TIMEOUT);

      m_CN = m_Parameters.getParameterValueAsRasterLayer(CN);

      m_iIntervalHydro = m_Parameters.getParameterValueAsInt(INTERVALHYDRO) * 60;

      m_iIntervalHyeto = m_Parameters.getParameterValueAsInt(INTERVALHYETO) * 60;

      m_iTableNameField = m_Parameters.getParameterValueAsInt(FIELD);

      m_TimeOut.setFullExtent();

      m_CN.setWindowExtent(m_TimeOut.getWindowGridExtent());

      m_iNX = m_TimeOut.getNX();

      m_iNY = m_TimeOut.getNY();

      if (createHyetographs()) {

         calculateHydrographs();

         documentHydrographs();

      }

      else {

         throw new GeoAlgorithmExecutionException(Sextante.getText("Hyetographs_are_not_consistent"));

      }

      return !m_Task.isCanceled();

   }

   @Override

   public void defineCharacteristics() {

      setName(Sextante.getText("A_simple_hydrological_model"));

      setGroup(Sextante.getText("Indices_and_other_hydrological_parameters"));

      setUserCanDefineAnalysisExtent(false);

      try {

         m_Parameters.addInputRasterLayer(TIMEOUT, Sextante.getText("Time_to_outlet"), true);

         m_Parameters.addInputRasterLayer(CN, Sextante.getText("N\u00famero_de_Curva"), true);

         m_Parameters.addInputVectorLayer(STATIONS, Sextante.getText("Estaciones"), AdditionalInfoVectorLayer.SHAPE_TYPE_POINT,

                  true);

         m_Parameters.addTableField(FIELD, Sextante.getText("Nombre_de_tabla_con_hietograma"), STATIONS);

         m_Parameters.addMultipleInput(TABLES, Sextante.getText("Tables"), AdditionalInfoMultipleInput.DATA_TYPE_TABLE, true);

         m_Parameters.addNumericalValue(INTERVALHYDRO, Sextante.getText("Intervalo_en_hidrogramas__minutos"),

                  AdditionalInfoNumericalValue.NUMERICAL_VALUE_INTEGER, 10, 1, Integer.MAX_VALUE);

         m_Parameters.addNumericalValue(INTERVALHYETO, Sextante.getText("Intervalo_en_hietogramas__minutos"),

                  AdditionalInfoNumericalValue.NUMERICAL_VALUE_INTEGER, 30, 1, Integer.MAX_VALUE);

      }

      catch (final RepeatedParameterNameException e) {

         Sextante.addErrorToLog(e);

      }

      catch (final UndefinedParentParameterNameException e) {

         Sextante.addErrorToLog(e);

      }

      catch (final OptionalParentParameterException e) {

         Sextante.addErrorToLog(e);

      }

   }

   private boolean createHyetographs() {

      int iPoint = 0;

      try {

         final IVectorLayer stations = m_Parameters.getParameterValueAsVectorLayer(STATIONS);

         m_Hyetogram = new Hyetograph[stations.getShapesCount()][];

         final IFeatureIterator iter = stations.iterator();

         while (iter.hasNext()) {

            final IFeature feature = iter.next();

            final String sTableName = feature.getRecord().getValue(m_iTableNameField).toString();

            final Coordinate c = feature.getGeometry().getCoordinate();

            m_Hyetogram[iPoint] = getHyetogramsFromTable(c.x, c.y, sTableName);

            iPoint++;

         }

         iter.close();

         return checkHyetogramsConsistency();

      }

      catch (final Exception e) {

         Sextante.addErrorToLog(e);

         return false;

      }

   }

   private boolean checkHyetogramsConsistency() {

      try {

         final int iIntervals = m_Hyetogram[0][0].getIntervals();

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

            if (m_Hyetogram[i].length != m_Hyetogram[0].length) {

               return false;

            }

            if (iIntervals != m_Hyetogram[i][0].getIntervals()) {

               return false;

            }

            for (final Hyetograph[] element : m_Hyetogram) {

               if (element[i] == null) {

                  return false;

               }

            }

         }

         return true;

      }

      catch (final Exception e) {

         return false;

      }

   }

   private Hyetograph[] getHyetogramsFromTable(final double x,

                                               final double y,

                                               final String sName) {

      try {

         final ITable table = getTableFromName(sName);

         if (table != null) {

            final int iCount = table.getFieldCount();

            if (iCount <= 0) {

               return null;

            }

            if (!m_bHyetoNamesCreated) {

               m_bHyetoNamesCreated = true;

               m_sHyetoNames = new String[iCount];

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

                  m_sHyetoNames[i] = table.getFieldName(i);

               }

            }

            final Hyetograph hyetos[] = new Hyetograph[iCount];

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

               final double dHyeto[] = new double[(int) table.getRecordCount()];

               final IRecordsetIterator iter = table.iterator();

               int j = 0;

               while (iter.hasNext()) {

                  final IRecord record = iter.next();

                  String s = record.getValue(i).toString();

                  s = s.replaceAll("'", "");

                  try {

                     dHyeto[j] = Double.parseDouble(s);

                  }

                  catch (final NumberFormatException nfe) {

                     dHyeto[j] = 0;

                  }

                  j++;

               }

               hyetos[i] = new Hyetograph(dHyeto, this.m_iIntervalHyeto);

               hyetos[i].setName(sName + table.getFieldName(i));

               hyetos[i].setCoords(new Point2D.Double(x, y));

            }

            return hyetos;

         }

         else {

            return null;

         }

      }

      catch (final Exception e) {

         return null;

      }

   }

   private ITable getTableFromName(final String sName) {

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

         final ITable table = (ITable) m_Tables.get(i);

         if (table.getName().equals(sName)) {

            return table;

         }

      }

      return null;

   }

   private void calculateHydrographs() throws UnsupportedOutputChannelException {

      int i, j, k;

      int x, y;

      int iLength;

      int iRatio;

      int iIndex;

      int iIntervalsHyeto, iIntervalsHydro;

      double hydData[];

      double dRain;

      double dTimeOut;

      double dRunoff;

      double dAccRunoff;

      final double dRunoff2Volume = m_TimeOut.getWindowCellSize() * m_TimeOut.getWindowCellSize() / 1000.0;

      IRasterLayer swap;

      IRasterLayer accRainGrid;

      IRasterLayer accRunoffGrid;

      IRasterLayer runoffGrid;

      m_Hydrographs = new ArrayList();

      final AnalysisExtent extent = m_TimeOut.getWindowGridExtent();

      accRainGrid = getTempRasterLayer(IRasterLayer.RASTER_DATA_TYPE_FLOAT, extent);

      accRunoffGrid = getTempRasterLayer(IRasterLayer.RASTER_DATA_TYPE_FLOAT, extent);

      runoffGrid = getTempRasterLayer(IRasterLayer.RASTER_DATA_TYPE_FLOAT, extent);

      iLength = m_Hyetogram[0][0].getDuration();

      iIntervalsHyeto = m_Hyetogram[0][0].getIntervals();

      iRatio = m_iIntervalHyeto / m_iIntervalHydro;

      iIntervalsHydro = (int) ((iLength + m_TimeOut.getMaxValue() * 3600) / m_iIntervalHydro) + 1;

      for (i = 0; i < m_Hyetogram[0].length; i++) {//for each return period

         accRainGrid.assign(0.0);

         accRunoffGrid.assign(0.0);

         runoffGrid.assign(0.0);

         hydData = new double[iIntervalsHydro];

         for (j = 0; j < iIntervalsHydro; j++) {

            hydData[j] = 0;

         }

         this.setProgressText(Sextante.getText("Calculando_hidrograma") + "(" + m_sHyetoNames[i] + ")");

         for (j = 0; j < iIntervalsHyeto; j++) {

            for (y = 0; y < m_iNY; y++) {

               for (x = 0; x < m_iNX; x++) {

                  dTimeOut = m_TimeOut.getCellValueAsDouble(x, y);

                  if (!m_TimeOut.isNoDataValue(dTimeOut) && (dTimeOut > 0)) {

                     dRain = getRainfall(i, extent.getWorldCoordsFromGridCoords(x, y), j * m_iIntervalHyeto, m_iIntervalHyeto);

                     if (dRain > 0) {

                        accRainGrid.addToCellValue(x, y, dRain);

                     }

                  }

               }

            }

            calculateRunoffGrid(runoffGrid, accRainGrid);

            for (y = 1; y < m_iNY; y++) {

               for (x = 0; x < m_iNX; x++) {

                  dTimeOut = m_TimeOut.getCellValueAsDouble(x, y);

                  if (!m_TimeOut.isNoDataValue(dTimeOut) && (dTimeOut > 0)) {

                     iIndex = (int) ((dTimeOut * 3600 + j * m_iIntervalHyeto) / m_iIntervalHydro);

                     dRunoff = runoffGrid.getCellValueAsDouble(x, y);

                     dAccRunoff = accRunoffGrid.getCellValueAsDouble(x, y);

                     dRunoff -= dAccRunoff;

                     if (dRunoff > 0) {

                        for (k = 0; k < iRatio; k++) {

                           hydData[iIndex] += dRunoff;

                        }

                     }

                  }

               }

            }

            swap = runoffGrid;

            runoffGrid = accRunoffGrid;

            accRunoffGrid = swap;

            setProgress(j, iIntervalsHyeto);

         }

         for (j = 0; j < iIntervalsHydro; j++) {

            hydData[j] = hydData[j] * dRunoff2Volume / iRatio / m_iIntervalHydro;

         }

         final Hydrograph hyd = new Hydrograph(hydData, m_iIntervalHydro);

         hyd.setName(m_Hyetogram[0][i].getName());

         m_Hydrographs.add(hyd);

      }

   }

   private double getRainfall(final int iSerie,

                              final Point2D pt,

                              final int iInitTime,

                              final int iInterval) {

      double dTotalRainfall = 0;

      double dTotalWeight = 0;

      for (final Hyetograph[] element : m_Hyetogram) {

         final Point2D coords = element[iSerie].getCoords();

         final double dWeight = 1. / Math.pow(coords.distance(pt), 2.);

         final double dRainfall = element[iSerie].getRainfall(iInitTime, iInterval) * dWeight;

         dTotalRainfall += dRainfall;

         dTotalWeight += dWeight;

      }

      return dTotalRainfall / dTotalWeight;

   }

   private void documentHydrographs() throws UnsupportedOutputChannelException {

      int i, j;

      double flow[];

      Hydrograph hydro;

      String sTableDescription;

      String sTableName;

      final String sFields[] = { "T", "Q" };

      final Object[] values = new Object[2];

      final Class[] types = { Integer.class, Double.class };

      ITable driver;

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

         hydro = (Hydrograph) m_Hydrographs.get(i);

         sTableName = "HYDROGRAPH" + Integer.toString(i);

         sTableDescription = "Hidrograma (" + m_sHyetoNames[i] + ")";

         driver = getNewTable(sTableName, sTableDescription, types, sFields);

         flow = hydro.getFlowArray();

         for (j = 0; j < hydro.getLengthInIntervals(); j++) {

            values[0] = new Integer(j * hydro.getTimeInterval());

            values[1] = new Double(flow[j]);

            driver.addRecord(values);

         }

         setProgress(i, m_Hydrographs.size());

      }

   }

   private double getRunoff(final double dRainfall, //in mm

                            final double dCN) {

      double dS;

      double dRunoff;

      dS = (25400.0 / dCN) - 254.0;

      if (dRainfall < (0.2 * dS)) {

         return 0;

      }

      dRunoff = Math.pow(dRainfall - 0.2 * dS, 2.0) / (dRainfall + 0.8 * dS);

      return dRunoff;

   }

   private void calculateRunoffGrid(final IRasterLayer runoff,

                                    final IRasterLayer rainfall) {

      int x, y;

      double dCN;

      double dRunoff;

      double dRainfall;

      double dMean = 0;

      int i = 0;

      for (y = 0; y < m_iNY; y++) {

         for (x = 0; x < m_iNX; x++) {

            dCN = m_CN.getCellValueAsDouble(x, y);

            dRainfall = rainfall.getCellValueAsDouble(x, y);

            if (!m_CN.isNoDataValue(dCN) && (dRainfall != 0.0)) {

               i++;

               dRunoff = getRunoff(dRainfall, dCN);

               runoff.setCellValue(x, y, dRunoff);

               dMean += dRunoff;

            }

         }

      }

      dMean /= (i);

      dMean += 1;

   }

   @Override

   public boolean isSuitableForModelling() {

      return false;

   }

}

package es.unex.sextante.hydrology.heightOverChannelNetwork;

import es.unex.sextante.additionalInfo.AdditionalInfoNumericalValue;

import es.unex.sextante.core.GeoAlgorithm;

import es.unex.sextante.core.AnalysisExtent;

import es.unex.sextante.core.OutputObjectsSet;

import es.unex.sextante.core.ParametersSet;

import es.unex.sextante.core.Sextante;

import es.unex.sextante.dataObjects.IRasterLayer;

import es.unex.sextante.exceptions.GeoAlgorithmExecutionException;

import es.unex.sextante.exceptions.RepeatedParameterNameException;

import es.unex.sextante.gridTools.closeGaps.CloseGapsAlgorithm;

import es.unex.sextante.rasterWrappers.GridWrapper;

public class HeightOverChannelNetworkAlgorithm

         extends

            GeoAlgorithm {

   public static final String DEM        = "DEM";

   public static final String NETWORK    = "NETWORK";

   public static final String HEIGHTOVER = "HEIGHTOVER";

   public static final String THRESHOLD  = "THRESHOLD";

   private int                m_iNX, m_iNY;

   private IRasterLayer       m_DEM      = null;

   private IRasterLayer       m_Network  = null;

   private IRasterLayer       m_Diff;

   private double             m_dThreshold;

   @Override

   public boolean processAlgorithm() throws GeoAlgorithmExecutionException {

      m_DEM = m_Parameters.getParameterValueAsRasterLayer(DEM);

      m_Network = m_Parameters.getParameterValueAsRasterLayer(NETWORK);

      m_dThreshold = m_Parameters.getParameterValueAsDouble(THRESHOLD);

      m_Diff = getNewRasterLayer(HEIGHTOVER, Sextante.getText("Elevation_over_channel_network"),

               IRasterLayer.RASTER_DATA_TYPE_FLOAT);

      m_Diff.setNoDataValue(-1.0);

      //m_Diff.assignNoData();

      final AnalysisExtent extent = m_Diff.getWindowGridExtent();

      m_DEM.setWindowExtent(extent);

      m_Network.setWindowExtent(extent);

      m_Network.setInterpolationMethod(GridWrapper.INTERPOLATION_NearestNeighbour);

      m_iNX = m_DEM.getNX();

      m_iNY = m_DEM.getNY();

      return interpolateSurfaceAndSubstract();

   }

   @Override

   public void defineCharacteristics() {

      setName(Sextante.getText("Elevation_over_channel_network"));

      setGroup(Sextante.getText("Indices_and_other_hydrological_parameters"));

      setUserCanDefineAnalysisExtent(true);

      try {

         m_Parameters.addInputRasterLayer(DEM, Sextante.getText("Elevation"), true);

         m_Parameters.addInputRasterLayer(NETWORK, Sextante.getText("Channel_network"), true);

         m_Parameters.addNumericalValue(THRESHOLD, Sextante.getText("Tension_threshold"), 0.1,

                  AdditionalInfoNumericalValue.NUMERICAL_VALUE_DOUBLE);

         addOutputRasterLayer(HEIGHTOVER, Sextante.getText("Elevation_over_channel_network"));

      }

      catch (final RepeatedParameterNameException e) {

         Sextante.addErrorToLog(e);

      }

   }

   private boolean interpolateSurfaceAndSubstract() throws GeoAlgorithmExecutionException {

      int x, y;

      double dValue, dValue2;

      for (y = 0; y < m_iNY; y++) {

         for (x = 0; x < m_iNX; x++) {

            dValue = m_Network.getCellValueAsDouble(x, y);

            if ((dValue != 0) && !m_Network.isNoDataValue(dValue)) {

               dValue = m_DEM.getCellValueAsDouble(x, y);

               m_Diff.setCellValue(x, y, dValue);

            }

            else {

               m_Diff.setNoData(x, y);

            }

         }

      }

      final CloseGapsAlgorithm alg = new CloseGapsAlgorithm();

      final ParametersSet ps = alg.getParameters();

      //IRasterLayer layer = m_Diff.getRasterLayer(" ",  getAlgorithmProjection());

      ps.getParameter(CloseGapsAlgorithm.INPUT).setParameterValue(m_Diff);

      ps.getParameter(CloseGapsAlgorithm.THRESHOLD).setParameterValue(new Double(m_dThreshold));

      if (alg.execute(this.m_Task, this.m_OutputFactory)) {

         final OutputObjectsSet output = alg.getOutputObjects();

         final IRasterLayer networkHeight = (IRasterLayer) output.getOutput("RESULT").getOutputObject();

         networkHeight.open();

         for (y = 0; (y < m_iNY) && setProgress(y, m_iNY); y++) {

            for (x = 0; x < m_iNX; x++) {

               dValue = m_DEM.getCellValueAsDouble(x, y);

               dValue2 = networkHeight.getCellValueAsDouble(x, y);

               if (m_DEM.isNoDataValue(dValue) || networkHeight.isNoDataValue(dValue2)) {

                  m_Diff.setNoData(x, y);

               }

               else {

                  m_Diff.setCellValue(x, y, dValue - dValue2);

               }

            }

         }

         networkHeight.close();

         return !m_Task.isCanceled();

      }

      else {

         return false;

      }

   }

}

package es.unex.sextante.hydrology.watersheds;

import java.util.ArrayList;

import java.util.Arrays;

import es.unex.sextante.additionalInfo.AdditionalInfoNumericalValue;

import es.unex.sextante.core.GeoAlgorithm;

import es.unex.sextante.core.AnalysisExtent;

import es.unex.sextante.core.Sextante;

import es.unex.sextante.dataObjects.IRasterLayer;

import es.unex.sextante.exceptions.GeoAlgorithmExecutionException;

import es.unex.sextante.exceptions.RepeatedParameterNameException;

import es.unex.sextante.rasterWrappers.GridCell;

public class WatershedsAlgorithm

         extends

            GeoAlgorithm {

   private static final int   NO_BASIN     = -1;

   private final static int   m_iOffsetX[] = { 0, 1, 1, 1, 0, -1, -1, -1 };

   private final static int   m_iOffsetY[] = { 1, 1, 0, -1, -1, -1, 0, 1 };

   public static final String DEM          = "DEM";

   public static final String NETWORK      = "NETWORK";

   public static final String MINSIZE      = "MINSIZE";

   public static final String WATERSHEDS   = "WATERSHEDS";

   private int                m_iBasins;

   private int                m_iNX, m_iNY;

   private int                m_iMinSize;

   private IRasterLayer       m_DEM        = null;

   private IRasterLayer       m_Network    = null;

   private IRasterLayer       m_Basins;

   private IRasterLayer       m_Directions;

   @Override

   public boolean processAlgorithm() throws GeoAlgorithmExecutionException {

      m_DEM = m_Parameters.getParameterValueAsRasterLayer(DEM);

      m_Network = m_Parameters.getParameterValueAsRasterLayer(NETWORK);

      m_iMinSize = m_Parameters.getParameterValueAsInt(MINSIZE);

      m_Basins = getNewRasterLayer(WATERSHEDS, Sextante.getText("Watersheds"), IRasterLayer.RASTER_DATA_TYPE_INT);

      m_Basins.setNoDataValue(NO_BASIN);

      m_Basins.assignNoData();

      final AnalysisExtent extent = m_Basins.getWindowGridExtent();

      m_DEM.setFullExtent();

      m_Network.setWindowExtent(extent);

      m_Directions = getTempRasterLayer(IRasterLayer.RASTER_DATA_TYPE_INT, extent);

      m_iNX = m_DEM.getNX();

      m_iNY = m_DEM.getNY();

      calculateBasins();

      return !m_Task.isCanceled();

   }

   @Override

   public void defineCharacteristics() {

      setName(Sextante.getText("Watersheds"));

      setGroup(Sextante.getText("Basic_hydrological_analysis"));

      setUserCanDefineAnalysisExtent(true);

      try {

         m_Parameters.addInputRasterLayer(DEM, Sextante.getText("Elevation"), true);

         m_Parameters.addInputRasterLayer(NETWORK, Sextante.getText("Channel_network"), true);

         m_Parameters.addNumericalValue(MINSIZE, Sextante.getText("Minimum_watershed_size__cells"), 0,

                  AdditionalInfoNumericalValue.NUMERICAL_VALUE_INTEGER);

         addOutputRasterLayer(WATERSHEDS, Sextante.getText("Watersheds"));

      }

      catch (final RepeatedParameterNameException e) {

         Sextante.addErrorToLog(e);

      }

   }

   private void calculateBasins() {

      int i;

      int x, y;

      int iBasins;

      prepareDirectionsLayer();

      final ArrayList outletsArrayList = getOutlets();

      final Object[] outlets = outletsArrayList.toArray();

      Arrays.sort(outlets);

      m_iBasins = 0;

      for (i = outlets.length - 1; (i >= 0) && setProgress(outlets.length - i, outlets.length); i--) {

         m_iBasins++;

         x = ((GridCell) outlets[i]).getX();

         y = ((GridCell) outlets[i]).getY();

         if (getBasin(x, y) < m_iMinSize) {

            iBasins = m_iBasins - 1;

            m_iBasins = NO_BASIN;

            getBasin(x, y);

            m_iBasins = iBasins;

         }

      }

   }

   private void prepareDirectionsLayer() {

      int x, y;

      int iDir;

      for (y = 0; (y < m_iNY) && setProgress(y, m_iNY); y++) {

         for (x = 0; x < m_iNX; x++) {

            iDir = m_DEM.getDirToNextDownslopeCell(x, y, false);

            if (iDir < 0) {

               m_Directions.setCellValue(x, y, -1.0);

            }

            else {

               m_Directions.setCellValue(x, y, ((iDir + 4) % 8));

            }

         }

      }

   }

   private ArrayList getOutlets() {

      int x, y;

      final ArrayList outlets = new ArrayList();

      for (y = 0; (y < m_iNY) && setProgress(y, m_iNY); y++) {

         for (x = 0; x < m_iNX; x++) {

            addOutlet(x, y, outlets);

         }

      }

      return outlets;

   }

   private void addOutlet(final int x,

                          final int y,

                          final ArrayList outlets) {

      int i;

      int ix, iy;

      int iUpslopeX = 0, iUpslopeY = 0;

      int iUpslopeRiverCells = 0;

      double dUpslopeZ = 0;

      int iNetwork = m_Network.getCellValueAsInt(x, y);

      final int iDir = m_Directions.getCellValueAsInt(x, y);

      final double dZ = m_DEM.getCellValueAsDouble(x, y);

      final int iNextCellX = x + m_iOffsetX[(iDir + 4) % 8];

      final int iNextCellY = y + m_iOffsetY[(iDir + 4) % 8];

      final int iNextCellNetwork = m_Network.getCellValueAsInt(iNextCellX, iNextCellY);

      if (m_Network.isNoDataValue(iNetwork) || (iNetwork == 0)) { //not a river cell

         return;

      }

      if (m_Network.isNoDataValue(iNextCellNetwork) || (iNextCellNetwork == 0)) { //border river cell

         outlets.add(new GridCell(x, y, dZ));

      }

      else if (iNetwork < 0) { // user defined outlet

         outlets.add(new GridCell(x, y, dZ));

         return;

      }

      else if ((iDir == -1) && !m_DEM.isNoDataValue(dZ)) { //border cell, limits with no data or with grid boundaries

         outlets.add(new GridCell(x, y, dZ));

      }

      else {

         for (i = 0; i < 8; i++) {

            ix = x + m_iOffsetX[i];

            iy = y + m_iOffsetY[i];

            if (m_Directions.getCellValueAsInt(ix, iy) == i) {

               iNetwork = m_Network.getCellValueAsInt(ix, iy);

               if ((iNetwork > 0) && !m_Network.isNoDataValue(iNetwork)) {

                  if (iUpslopeRiverCells > 0) {

                     if (iUpslopeRiverCells == 1) {

                        outlets.add(new GridCell(iUpslopeX, iUpslopeY, dUpslopeZ));

                     }

                     outlets.add(new GridCell(ix, iy, m_DEM.getCellValueAsDouble(ix, iy)));

                  }

                  else {

                     iUpslopeX = ix;

                     iUpslopeY = iy;

                     dUpslopeZ = m_DEM.getCellValueAsDouble(x, y);

                  }

                  iUpslopeRiverCells++;

               }

            }

         }

      }

   }

   private int getBasin(final int x,

                        final int y) {

      int i, ix, iy, nCells = 1;

      final int iBasin = m_Basins.getCellValueAsInt(x, y);

      final int iDir = m_Directions.getCellValueAsInt(x, y);

      if ((iBasin == NO_BASIN) && !m_Directions.isNoDataValue(iDir)) {

         m_Basins.setCellValue(x, y, m_iBasins);

         for (i = 0, nCells = 1; i < 8; i++) {

            ix = x + m_iOffsetX[i];

            iy = y + m_iOffsetY[i];

            if ((m_Directions.getCellValueAsInt(ix, iy) == i) && (m_Basins.getCellValueAsInt(ix, iy) == NO_BASIN)) {

               nCells += getBasin(ix, iy);

            }

         }

         return nCells;

      }

      return 0;

   }

}

package es.unex.sextante.hydrology.createExclusionAreas;

import java.awt.Point;

import java.awt.geom.Point2D;

import java.util.ArrayList;

import es.unex.sextante.core.GeoAlgorithm;

import es.unex.sextante.core.Sextante;

import es.unex.sextante.dataObjects.IRasterLayer;

import es.unex.sextante.exceptions.GeoAlgorithmExecutionException;

import es.unex.sextante.exceptions.RepeatedParameterNameException;

import es.unex.sextante.rasterWrappers.GridCell;

public class CreateExclusionAreasAlgorithm

         extends

            GeoAlgorithm {

   private final static int   m_iOffsetX[] = { 0, 1, 1, 1, 0, -1, -1, -1 };

   private final static int   m_iOffsetY[] = { 1, 1, 0, -1, -1, -1, 0, 1 };

   public static final String RESULT       = "RESULT";

   public static final String OUTLET_POINT = "OUTLET_POINT";

   public static final String INPUT        = "INPUT";

   int                        m_iNX, m_iNY;

   IRasterLayer               m_Grid;

   boolean                    m_IsCellAlreadyVisited[][];

   private IRasterLayer       m_ExclusionAreas;

   @Override

   public void defineCharacteristics() {

      setName(Sextante.getText("CreateExclusionAreas"));

      setGroup(Sextante.getText("Basic_hydrological_analysis"));

      setUserCanDefineAnalysisExtent(false);

      try {

         m_Parameters.addInputRasterLayer(INPUT, Sextante.getText("Layer"), true);

         m_Parameters.addPoint(OUTLET_POINT, Sextante.getText("Outlet_point"));

         addOutputRasterLayer(RESULT, Sextante.getText("Result"), 0);

      }

      catch (final RepeatedParameterNameException e) {

         Sextante.addErrorToLog(e);

      }

   }

   @Override

   public boolean processAlgorithm() throws GeoAlgorithmExecutionException {

      m_Grid = m_Parameters.getParameterValueAsRasterLayer(INPUT);

      m_Grid.setFullExtent();

      m_Grid.setInterpolationMethod(IRasterLayer.INTERPOLATION_NearestNeighbour);

      m_iNX = m_Grid.getNX();

      m_iNY = m_Grid.getNY();

      m_IsCellAlreadyVisited = new boolean[m_iNX][m_iNY];

      m_ExclusionAreas = getNewRasterLayer(RESULT, Sextante.getText("ExclusionAreas"), IRasterLayer.RASTER_DATA_TYPE_INT,

               m_Grid.getLayerGridExtent());

      m_ExclusionAreas.assign(m_Grid);

      m_ExclusionAreas.setNoDataValue(0.0);

      final Point2D pt = m_Parameters.getParameterValueAsPoint(OUTLET_POINT);

      final GridCell cell = m_Grid.getLayerGridExtent().getGridCoordsFromWorldCoords(pt);

      exclude(cell.getX(), cell.getY());

      m_ExclusionAreas.setNoData(cell.getX(), cell.getY());

      return !m_Task.isCanceled();

   }

   private void exclude(int x,

                        int y) {

      int x2, y2;

      int iInitClass;

      int iPt;

      int n;

      int iClass;

      double dArea = 0;

      ArrayList centralPoints = new ArrayList();

      ArrayList adjPoints = new ArrayList();

      Point point;

      iInitClass = m_Grid.getCellValueAsInt(x, y);

      centralPoints.add(new Point(x, y));

      m_IsCellAlreadyVisited[x][y] = true;

      while ((centralPoints.size() != 0) && !m_Task.isCanceled()) {

         for (iPt = 0; iPt < centralPoints.size(); iPt++) {

            dArea += m_Grid.getWindowCellSize() * m_Grid.getWindowCellSize();

            point = (Point) centralPoints.get(iPt);

            x = point.x;

            y = point.y;

            double dClass = m_Grid.getCellValueAsInt(x, y);

            if (!m_Grid.isNoDataValue(dClass)) {

               for (n = 0; n < 8; n++) {

                  x2 = x + m_iOffsetX[n];

                  y2 = y + m_iOffsetY[n];

                  dClass = m_Grid.getCellValueAsDouble(x2, y2);

                  if (!m_Grid.isNoDataValue(dClass)) {

                     iClass = (int) dClass;

                     if (m_IsCellAlreadyVisited[x2][y2] == false) {

                        if (iInitClass == iClass) {

                           m_IsCellAlreadyVisited[x2][y2] = true;

                           adjPoints.add(new Point(x2, y2));

                           m_ExclusionAreas.setNoData(x2, y2);

                        }

                     }

                  }

               }

            }

         }

         centralPoints = adjPoints;

         System.out.println(centralPoints.size());

         adjPoints = new ArrayList();

      }

      m_ExclusionAreas.setNoData(x, y);

   }

}

package es.unex.sextante.hydrology.distToChannelNetwork;

import java.util.ArrayList;

import es.unex.sextante.core.GeoAlgorithm;

import es.unex.sextante.core.AnalysisExtent;

import es.unex.sextante.core.Sextante;

import es.unex.sextante.dataObjects.IRasterLayer;

import es.unex.sextante.exceptions.GeoAlgorithmExecutionException;

import es.unex.sextante.exceptions.RepeatedParameterNameException;

import es.unex.sextante.rasterWrappers.GridCell;

import es.unex.sextante.rasterWrappers.GridWrapper;

public class DistToChannelNetworkAlgorithm

         extends

            GeoAlgorithm {

   private final static int   m_iOffsetX[] = { 0, 1, 1, 1, 0, -1, -1, -1 };

   private final static int   m_iOffsetY[] = { 1, 1, 0, -1, -1, -1, 0, 1 };

   public static final String DEM          = "DEM";

   public static final String NETWORK      = "NETWORK";

   public static final String DIST         = "DIST";

   private int                m_iNX, m_iNY;

   private IRasterLayer       m_DEM        = null;

   private IRasterLayer       m_Network    = null;

   private IRasterLayer       m_Dist;

   private IRasterLayer       m_Directions;

   private ArrayList          m_AdjPoints;

   private ArrayList          m_CentralPoints;

   @Override

   public boolean processAlgorithm() throws GeoAlgorithmExecutionException {

      m_DEM = m_Parameters.getParameterValueAsRasterLayer(DEM);

      m_Network = m_Parameters.getParameterValueAsRasterLayer(NETWORK);

      m_Dist = getNewRasterLayer(DIST, Sextante.getText("Distance_to_channel_network"), IRasterLayer.RASTER_DATA_TYPE_DOUBLE);

      m_Dist.setNoDataValue(-1.0);

      m_Dist.assignNoData();

      final AnalysisExtent extent = m_Dist.getWindowGridExtent();

      m_DEM.setWindowExtent(extent);

      m_Network.setWindowExtent(extent);

      m_Network.setInterpolationMethod(GridWrapper.INTERPOLATION_NearestNeighbour);

      m_Directions = getTempRasterLayer(IRasterLayer.RASTER_DATA_TYPE_INT, extent);

      m_iNX = m_DEM.getNX();

      m_iNY = m_DEM.getNY();

      prepareInitData();

      calculateDistance();

      return !m_Task.isCanceled();

   }

   @Override

   public void defineCharacteristics() {

      setName(Sextante.getText("Distance_to_channel_network"));

      setGroup(Sextante.getText("Indices_and_other_hydrological_parameters"));

      setUserCanDefineAnalysisExtent(true);

      setIsDeterminatedProcess(false);

      try {

         m_Parameters.addInputRasterLayer(DEM, Sextante.getText("Elevation"), true);

         m_Parameters.addInputRasterLayer(NETWORK, Sextante.getText("Channel_network"), true);

         addOutputRasterLayer(DIST, Sextante.getText("Distance_to_channel_network"));

      }

      catch (final RepeatedParameterNameException e) {

         Sextante.addErrorToLog(e);

      }

   }