/ - Diff - gvSIG raster - gvSIG

          */
         public long getBandLenght();
         /**
          * Obtiene el tipo de datos de la banda
+         *
          * @return el tipo de datos de la banda
          */
         public int getDataType();
         /**
          * Obtiene el valor del segundo m?ximo
+         *
          * @return Valor del segundo m?ximo
-...
+         *
          * @return minimum
          */
         public double getMinimun();
         public double getMinimum();
         /**
          * Obtiene el valor medio
-...
          * @throws ProcessInterruptedException
          */
         public void calculate(double scale, SimpleTaskStatus status);
     //
     //    /**
     //     * Gets the number of pixels by band
     //     *
     //     * @return  the number of pixels by band
     //     */
     //    public long getNumberOfCells();
         /**
          * Gets the number of pixels by band
+         *
          * @return  the number of pixels by band
          */
         public long getNumberOfCells();
         /**
          * Devuelve la matriz de varianza-covarianza, si no se encuentra calculada se calcula
+         *
          * @return Matriz de varianza-covarianza
          */
         public double[] getVarianceCovarianceMatrix();
         /**
          * Gets histogram of the band
+         *
          * @return HistogramBand

     //     */
     //     public long[] getNegativeTable();
         /**
          * Devuelve el minimo valor del histograma
+         *
          * @return el minimo valor del histograma
          */
         public double getMinimum();
     //    /**
     //     * Devuelve el minimo valor del histograma
     //     *
     //     * @return el minimo valor del histograma
     //     */
     //    public double getMinimum();
     //
     //    /**
     //     * Devuelve el maximo valor del histograma
     //     *
     //     * @return el maximo valor del histograma
     //     */
     //    public double getMaximum();
         /**
          * Devuelve el maximo valor del histograma
+         *
          * @return el maximo valor del histograma
          */
         public double getMaximum();
         /**
          * Obtiene el n?mero de valores o clases del histograma
          * @return entero que representa el n?mero de valores o clases del histograma
          */

          */
         public double[][] getVarianceCovarianceMatrix();
         /**
          * Return the histogram.
+         *
          * @return Histogram
          */
         public Histogram getHistogram();
+    }

     //     */
     //    public boolean union(Histogram hist);
         /**
          * Obtiene la tabla de valores
+         *
          * @return la tabla de valores
          */
         public long[][] getTable();
     //    /**
     //     * Obtiene la tabla de valores
     //     *
     //     * @return la tabla de valores
     //     */
     //    public long[][] getTable();
     //
     //
     //    /**
     //     * Obtiene el histograma de la imagen negativa.
     //     *
     //     * @return el histograma de la imagen negativa.
     //     */
     //    public long[][] getNegativeTable();
         /**
          * Obtiene el histograma de la imagen negativa.
+         *
          * @return el histograma de la imagen negativa.
          */
         public long[][] getNegativeTable();
     //    /**
     //     * Devuelve el minimo valor del histograma
     //     *
-...
     //     */
     //    public double getMaximum();
         /**
          * Obtiene el n?mero de valores o clases del histograma
          * @return entero que representa el n?mero de valores o clases del histograma
          */
         public int getNumValues();
     //    /**
     //     * Obtiene el n?mero de valores o clases del histograma
     //     * @return entero que representa el n?mero de valores o clases del histograma
     //     */
     //    public int getNumValues();
     //
     //    /**
     //     * Devuelve si un histograma esta en un rango RGB aceptable
     //     *
     //     * @return si un histograma esta en un rango RGB aceptable
     //     */
     //    public boolean isInRangeRGB();
         /**
          * Devuelve si un histograma esta en un rango RGB aceptable
+         *
          * @return si un histograma esta en un rango RGB aceptable
          */
         public boolean isInRangeRGB();
     //    /**
     //     * Calcula las estad?sticas.
     //     *

     package org.gvsig.raster.lib.buffer.impl.statistics;
     import org.gvsig.raster.lib.buffer.api.statistics.StatisticsBand;
     /**
      * @author fdiaz
+     *
      */
     public class VarianceOperation implements StatisticalOperation {
         double sigma;
         double sigmaSquare;
         long n;
         double mean;
         double variance;
         /**
          * Arithmetic mean
          */
         public VarianceOperation() {
             sigma = 0;
             sigmaSquare = 0;
             n = 0;
+        }
         @Override
         public void pre() {
             //do nothing
+            }
         @Override
         public void addValue(Number value) {
             double doubleValue = value.doubleValue();
             sigma += doubleValue;
             sigmaSquare += doubleValue*doubleValue;
             n++;
+        }
         @Override
         public void post() {
             mean = sigma/n;
             variance = sigmaSquare/n - (mean*mean);
+        }
         @Override
         public Object getResult() {
             return variance;
+        }
+    }

     package org.gvsig.raster.lib.buffer.impl.statistics;
     import java.util.ArrayList;
     import java.util.List;
     import org.gvsig.raster.lib.buffer.api.Band;
     import org.gvsig.raster.lib.buffer.api.BufferManager;
     import org.gvsig.raster.lib.buffer.api.statistics.HistogramBand;
     import org.gvsig.raster.lib.buffer.api.statistics.HistogramClass;
     import org.gvsig.raster.lib.buffer.api.statistics.StatisticsBand;
     /**
      * @author fdiaz
+     *
      */
     public class HistogramOperation implements StatisticalOperation {
         private StatisticsBand statisticsBand;
         private List<HistogramClass> histogramClasses;
         private HistogramBand histogramBand;
         private Band band;
         public HistogramOperation(StatisticsBand statisticsBand, Band band) {
             this.statisticsBand = statisticsBand;
             this.band = band;
+        }
         @Override
         public void preOperation(StatisticsBand statisticsBand) {
             // TODO Auto-generated method stub
         public void pre() {
             int dataType = this.statisticsBand.getDataType();
             if(dataType == BufferManager.TYPE_DOUBLE || dataType == BufferManager.TYPE_FLOAT){
                 calculateHistogramClasses();
                 histogramBand = new DefaultHistogramBand(band, this.histogramClasses);
             } else {
                 histogramBand = new DefaultHistogramBand(band);
+            }
+        }
         @Override
         public void executionOperation(Object value) {
             // TODO Auto-generated method stub
         private void calculateHistogramClasses() {
             int classesNumber = new Double(Math.ceil(Math.sqrt(this.statisticsBand.getBandLenght()))).intValue();
             histogramClasses = new ArrayList<HistogramClass>(classesNumber);
             double range = this.statisticsBand.getMaximum()-this.statisticsBand.getMinimum();
             double widthInterval = range/classesNumber;
             double minInterval = this.statisticsBand.getMinimum();
             double maxInterval; // = this.statisticsBand.getMaximum();
             for(int i=0; i<classesNumber-1; i++){
                 maxInterval = minInterval+widthInterval;
                 DefaultHistogramClass histogramClass = new DefaultHistogramClass(minInterval, maxInterval);
                 histogramClass.setValue(0);
                 histogramClasses.add(histogramClass);
                 minInterval = maxInterval;
+            }
             DefaultHistogramClass histogramClass = new DefaultHistogramClass(minInterval, this.statisticsBand.getMaximum());
             histogramClasses.add(histogramClass);
+        }
         @Override
         public void postOperation(StatisticsBand statisticsBand) {
             // TODO Auto-generated method stub
         public void addValue(Number value) {
            ((DefaultHistogramBand)histogramBand).addValue(value.doubleValue());
+        }
         @Override
         public void post() {
             // do nothing
+        }
         @Override
         public Object getResult() {
             // TODO Auto-generated method stub
             return null;
             return histogramBand;
+        }
+    }

     package org.gvsig.raster.lib.buffer.impl.statistics;
     import java.util.List;
     import org.gvsig.raster.lib.buffer.api.Band;
     import org.gvsig.raster.lib.buffer.api.statistics.Histogram;
     import org.gvsig.raster.lib.buffer.api.statistics.HistogramBand;
     import org.gvsig.raster.lib.buffer.api.statistics.Statistics;
     import org.gvsig.raster.lib.buffer.api.statistics.StatisticsBand;
     import org.gvsig.tools.task.SimpleTaskStatus;
     /**
      * @author fdiaz
+     *
      */
     public class DefaultStatistics implements Statistics {
         StatisticsBand[] statisticsBands;
         List<Band> bands;
         /**
+         *
          */
         public DefaultStatistics( List<Band> bands) {
             this.bands = bands;
             statisticsBands = new StatisticsBand[bands.size()];
+        }
         @Override
         public long[] getNumberOfValues() {
             long[] result = new long[statisticsBands.length];
             for (int i = 0; i < statisticsBands.length; i++) {
                 result[i]= statisticsBands[i].getBandLenght();
+            }
             return result;
+        }
         @Override
         public double[] getMax() {
             double[] result = new double[statisticsBands.length];
             for (int i = 0; i < statisticsBands.length; i++) {
                 result[i]= statisticsBands[i].getMaximum();
+            }
             return result;
+        }
         @Override
         public double[] getSecondMax() {
             double[] result = new double[statisticsBands.length];
             for (int i = 0; i < statisticsBands.length; i++) {
                 result[i]= statisticsBands[i].getSecondMax();
+            }
             return result;
+        }
         @Override
         public double[] getSecondMin() {
             double[] result = new double[statisticsBands.length];
             for (int i = 0; i < statisticsBands.length; i++) {
                 result[i]= statisticsBands[i].getSecondMin();
+            }
             return result;
+        }
         @Override
         public double getMaximun() {
             double result = Double.NEGATIVE_INFINITY;
             for (int i = 0; i < statisticsBands.length; i++) {
                 double max = statisticsBands[i].getMaximum();
                 if(result<max){
                     result = max;
+                }
+            }
             return result;
+        }
         @Override
         public double getMinimun() {
             double result = Double.POSITIVE_INFINITY;
             for (int i = 0; i < statisticsBands.length; i++) {
                 double min = statisticsBands[i].getMinimum();
                 if(result>min){
                     result = min;
+                }
+            }
             return result;
+        }
         @Override
         public double[] getMean() {
             double[] result = new double[statisticsBands.length];
             for (int i = 0; i < statisticsBands.length; i++) {
                 result[i]= statisticsBands[i].getMean();
+            }
             return result;
+        }
         @Override
         public double[] getMin() {
             double[] result = new double[statisticsBands.length];
             for (int i = 0; i < statisticsBands.length; i++) {
                 result[i]= statisticsBands[i].getMinimum();
+            }
             return result;
+        }
         @Override
         public double[] getVariance() {
             double[] result = new double[statisticsBands.length];
             for (int i = 0; i < statisticsBands.length; i++) {
                 result[i]= statisticsBands[i].getVariance();
+            }
             return result;
+        }
         @Override
         public int getBandCount() {
             return statisticsBands.length;
+        }
         @Override
         public Object getTailTrimValue(double percent) {
             // TODO Auto-generated method stub
             return null;
+        }
         @Override
         public Object[] getTailTrimValue(int pos) {
             // TODO Auto-generated method stub
             return null;
+        }
         @Override
         public int getTailTrimCount() {
             // TODO Auto-generated method stub
             return 0;
+        }
         @Override
         public boolean isCalculated() {
             // TODO Auto-generated method stub
             return false;
+        }
         @Override
         public void calculate(double scale, SimpleTaskStatus status) {
             // TODO Auto-generated method stub
+        }
         @Override
         public long[] getNumberOfCells() {
             // TODO Auto-generated method stub
             return null;
+        }
         @Override
         public double[][] getVarianceCovarianceMatrix() {
     //        double dSum[][] = new double[statisticsBands.length][statisticsBands.length];
     //        double iValues[][] = new double[statisticsBands.length][statisticsBands.length];
     //        double[][] varCov = new double[statisticsBands.length][statisticsBands.length];
     //
     //        for (int iBand = 0; iBand < statisticsBands.length; iBand++)
     //            for (int jBand = 0; jBand < statisticsBands.length; jBand++){
     //                dSum[iBand][jBand] = 0;
     //                iValues[iBand][jBand] = 0;
     //        }
     //
     //                for (int i = 0; i < statisticsBands.length; i++) {
     //                    for (int j = i; j < statisticsBands.length; j++) {
     //                            valorBandai = valorBandai - mean[i];
     //                            valorBandaj = valorBandaj - mean[j];
     //                            dSum[i][j] += valorBandai*valorBandaj;
     //                            iValues[i][j]++;
     //                        }
     //                    }
     //                }
     //            }
     //        }
     //
     //        // Asigno el valor a la matriz
     //        for (int iBand = 0; iBand < statisticsBands.length; iBand++)
     //            for (int jBand = 0; jBand < statisticsBands.length; jBand++)
     //                if (iValues[iBand][jBand] > 1)
     //                    varCov[iBand][jBand] = dSum[iBand][jBand] / (double)(iValues[iBand][jBand]);
     //                else
     //                    varCov[iBand][jBand] = roi.getStore().getNoDataValue().getValue().doubleValue();
     //
     //        // Completar parte simetrica de la matriz
     //        for (int i = 0; i < statisticsBands.length; i++) {
     //            for (int j = 0; j < statisticsBands.length; j++) {
     //                if(j < i)
     //                    varCov[i][j] = varCov[j][i];
     //            }
     //        }
             // TODO Auto-generated method stub
             return null;
+        }
         @Override
         public Histogram getHistogram() {
             HistogramBand[] histogramBands = new HistogramBand[statisticsBands.length];
             for (int i = 0; i < statisticsBands.length; i++) {
                 histogramBands[i]= statisticsBands[i].getHistogramBand();
+            }
             Histogram histogram = new DefaultHistogram(histogramBands);
             return histogram;
+        }
+    }

     package org.gvsig.raster.lib.buffer.impl.statistics;
     /**
      * @author fdiaz
+     *
      */
     public class SecondMinOperation implements StatisticalOperation {
         double min;
         double secondMin;
         /**
          * Arithmetic mean
          */
         public SecondMinOperation() {
             min = Double.POSITIVE_INFINITY;
             secondMin = Double.POSITIVE_INFINITY;
+        }
         @Override
         public void pre() {
             // do nothing
+        }
         @Override
         public void addValue(Number value) {
             if (value.doubleValue() < min) {
                 secondMin = min;
                 min = value.doubleValue();
+            }
+        }
         @Override
         public void post() {
             // do nothing
+        }
         @Override
         public Object getResult() {
             return secondMin;
+        }
+    }

     package org.gvsig.raster.lib.buffer.impl.statistics;
     import org.gvsig.raster.lib.buffer.api.statistics.StatisticsBand;
     /**
      * @author fdiaz
+     *
      */
     public class MeanOperation implements StatisticalOperation {
         double sigma;
         long n;
         double mean;
         /**
          * Arithmetic mean
          */
         public MeanOperation() {
             sigma = 0;
             n = 0;
+        }
         @Override
         public void pre() {
             // do nothing
+        }
         @Override
         public void addValue(Number value) {
             sigma += value.doubleValue();
             n++;
+        }
         @Override
         public void post() {
             mean = sigma / n;
+        }
         @Override
         public Object getResult() {
             return mean;
+        }
+    }

     package org.gvsig.raster.lib.buffer.impl.statistics;
     import java.util.Iterator;
     import org.gvsig.raster.lib.buffer.api.Buffer;
     import org.gvsig.raster.lib.buffer.api.statistics.Histogram;
     import org.gvsig.raster.lib.buffer.api.statistics.HistogramBand;
     /**
      * @author fdiaz
+     *
      */
     public class DefaultHistogram implements Histogram {
         private HistogramBand[] histogramBands;
         /**
          * @param histogramBands
          */
         public DefaultHistogram(HistogramBand[] histogramBands) {
             this.histogramBands = histogramBands;
+        }
         @Override
         public Iterator<HistogramBand> iterator() {
             // TODO Auto-generated method stub
             return null;
+        }
         @Override
         public int size() {
             return histogramBands.length;
+        }
         @Override
         public HistogramBand get(int band) {
             return histogramBands[band];
+        }
     //    @Override
     //    public long[][] getTable() {
     //        table = new long[histogramBands.length][]
     //        // TODO Auto-generated method stub
     //        return null;
     //    }
     //
     //    @Override
     //    public long[][] getNegativeTable() {
     //        // TODO Auto-generated method stub
     //        return null;
     //    }
     //    @Override
     //    public int getNumValues() {
     //        // TODO Auto-generated method stub
     //        return 0;
     //    }
     //
     //    @Override
     //    public boolean isInRangeRGB() {
     //        // TODO Auto-generated method stub
     //        return false;
     //    }
+    }

     package org.gvsig.raster.lib.buffer.impl.statistics;
     /**
      * @author fdiaz
+     *
      */
     public class SecondMaxOperation implements StatisticalOperation {
         double max;
         double secondMax;
         /**
          * Arithmetic mean
          */
         public SecondMaxOperation() {
             max = Double.NEGATIVE_INFINITY;
             secondMax = Double.NEGATIVE_INFINITY;
+        }
         @Override
         public void pre() {
             // do nothing
+        }
         @Override
         public void addValue(Number value) {
             if (value.doubleValue() > max) {
                 secondMax = max;
                 max = value.doubleValue();
+            }
+        }
         @Override
         public void post() {
             // do nothing
+        }
         @Override
         public Object getResult() {
             return secondMax;
+        }
+    }

     import org.gvsig.raster.lib.buffer.api.statistics.StatisticsBand;
     import org.gvsig.tools.task.SimpleTaskStatus;
     /**
      * @author fdiaz
+     *
      */
     public class DefaultStatisticsBand implements StatisticsBand{
         Band band;
         long bandLength;
         double secondMax;
         boolean calculated;
         //TODO el resto de datos
         private double mean;
         private double max;
         private double secondMax;
         private double min;
         private double secondMin;
         private double variance;
         private HistogramBand histogramBand;
         /**
          * @param band
          */
         public DefaultStatisticsBand(Band band) {
             this.band=band;
             this.calculated=false;
-...
         @Override
         public void calculate(double scale, SimpleTaskStatus status) {
             calculated = false;
             MeanOperation meanOperation = new MeanOperation();
             MaxOperation maxOperation = new MaxOperation();
             MinOperation minOperation = new MinOperation();
             SecondMaxOperation secondMaxOperation = new SecondMaxOperation();
             SecondMinOperation secondMinOperation = new SecondMinOperation();
             VarianceOperation varianceOperation = new VarianceOperation();
             //TODO: CovarianceOperation
             meanOperation.pre();
             maxOperation.pre();
             minOperation.pre();
             secondMaxOperation.pre();
             secondMinOperation.pre();
             varianceOperation.pre();
             for(int row=0; row<band.getRows(); row++){
                 for(int column=0; column<band.getColumns(); column++){
                     Object obj = band.get(row, column);
                     if(obj instanceof Number){
                         double value = ((Number)obj).doubleValue();
                         meanOperation.addValue(value);
                         maxOperation.addValue(value);
                         minOperation.addValue(value);
                         secondMaxOperation.addValue(value);
                         secondMinOperation.addValue(value);
                         varianceOperation.addValue(value);
+                    }
+                }
+            }
             meanOperation.post();
             maxOperation.post();
             minOperation.post();
             secondMaxOperation.post();
             secondMinOperation.post();
             varianceOperation.post();
             this.mean = ((Number)meanOperation.getResult()).doubleValue();
             this.max = ((Number)maxOperation.getResult()).doubleValue();
             this.min = ((Number)minOperation.getResult()).doubleValue();
             this.secondMax = ((Number)secondMaxOperation.getResult()).doubleValue();
             this.secondMin = ((Number)secondMinOperation.getResult()).doubleValue();
             this.variance = ((Number)varianceOperation.getResult()).doubleValue();
             HistogramOperation histogramOperation = new HistogramOperation(this, this.band);
             histogramOperation.pre();
             for(int row=0; row<band.getRows(); row++){
                 for(int column=0; column<band.getColumns(); column++){
                     Object obj = band.get(row, column);
                     if(obj instanceof Number){
                         double value = ((Number)obj).doubleValue();
                         histogramOperation.addValue(value);
+                    }
+                }
+            }
             histogramOperation.post();
             this.histogramBand = ((HistogramBand)histogramOperation.getResult());
             status.terminate();
             calculated=true;
+        }
         @Override
         public int getDataType() {
             return this.band.getDataType();
+        }
         @Override
         public long getBandLenght() {
             // TODO Auto-generated method stub
             return 0;
             return band.getRows()*band.getColumns();
+        }
         @Override
         public double getSecondMax() {
             // TODO Auto-generated method stub
             return 0;
             //TODO ??? y si no est? calculado???
             return this.secondMax;
+        }
         @Override
         public double getSecondMin() {
             // TODO Auto-generated method stub
             return 0;
             return this.secondMin;
+        }
         @Override
         public double getMaximum() {
             // TODO Auto-generated method stub
             return 0;
             return this.max;
+        }
         @Override
         public double getMinimun() {
             // TODO Auto-generated method stub
             return 0;
         public double getMinimum() {
             return this.min;
+        }
         @Override
         public double getMean() {
             // TODO Auto-generated method stub
             return 0;
             return this.mean;
+        }
         @Override
         public double getVariance() {
             // TODO Auto-generated method stub
             return 0;
             return this.variance;
+        }
         @Override
-...
             return 0;
+        }
         @Override
         public long getNumberOfCells() {
             // TODO Auto-generated method stub
             return 0;
+        }
     //    @Override
     //    public long getNumberOfCells() {
     //        // TODO Auto-generated method stub
     //        return 0;
     //    }
         @Override
         public double[] getVarianceCovarianceMatrix() {
             // TODO Auto-generated method stub
             return null;
         public HistogramBand getHistogramBand() {
             return this.histogramBand;
+        }
         @Override
         public HistogramBand getHistogramBand() {
             // TODO Auto-generated method stub
             return null;
+        }
+    }

     package org.gvsig.raster.lib.buffer.impl.statistics;
     /**
      * @author fdiaz
+     *
      */
     public class MinOperation implements StatisticalOperation {
         double min;
         /**
          * Arithmetic mean
          */
         public MinOperation() {
             min = Double.POSITIVE_INFINITY;
+        }
         @Override
         public void pre() {
             // do nothing
+        }
         @Override
         public void addValue(Number value) {
             if (value.doubleValue() < min) {
                 min = value.doubleValue();
+            }
+        }
         @Override
         public void post() {
             // do nothing
+        }
         @Override
         public Object getResult() {
             return min;
+        }
+    }

         /**
          * Operations done before processing
          * @param statisticsBand
          */
         public void preOperation(StatisticsBand statisticsBand);
         public void pre();
         /**
          * Operations done during processing
          * @param value
          */
         public void executionOperation(Object value);
         public void addValue(Number value);
         /**
          * Operations done after processing
          * @param statisticsBand
          */
         public void postOperation(StatisticsBand statisticsBand);
         public void post();
         /**
          * Gets the results after processing.

     package org.gvsig.raster.lib.buffer.impl.statistics;
     import org.gvsig.raster.lib.buffer.api.statistics.StatisticsBand;
     /**
      * @author fdiaz
+     *
      */
     public class MaxOperation implements StatisticalOperation {
         double max;
         /**
          * Arithmetic mean
          */
         public MaxOperation() {
             max = Double.NEGATIVE_INFINITY;
+        }
         @Override
         public void pre() {
             //do nothing
+        }
         @Override
         public void addValue(Number value) {
             if(value.doubleValue() > max){
                 max = value.doubleValue();
+            }
+        }
         @Override
         public void post() {
             //do nothing
+        }
         @Override
         public Object getResult() {
             return max;
+        }
+    }

     package org.gvsig.raster.lib.buffer.impl.statistics;
     import java.util.ArrayList;
     import java.util.Collections;
     import java.util.List;
     import org.gvsig.raster.lib.buffer.api.Band;
     import org.gvsig.raster.lib.buffer.api.statistics.HistogramBand;
     import org.gvsig.raster.lib.buffer.api.statistics.HistogramClass;
     import org.gvsig.tools.task.SimpleTaskStatus;
     /**
      * @author fdiaz
+     *
      */
     public class DefaultHistogramBand implements HistogramBand {
         Band band;
         List<HistogramClass> histogramClasses;
         double max;
         double min;
         public DefaultHistogramBand(Band band){
             this.band=band;
             this.histogramClasses=new ArrayList<HistogramClass>();
+        }
         public DefaultHistogramBand(Band band, List<HistogramClass> histogramClasses){
             this.band=band;
             this.histogramClasses=histogramClasses;
             Collections.sort(this.histogramClasses);
+        }
         @Override
         public int getBandLenght() {
             return this.band.getRows()*this.band.getColumns();
-...
+            }
             return frequencies;
+        }
     //
     //    @Override
     //    public double getMinimum() {
     //        return min;
     //    }
     //
     //    @Override
     //    public double getMaximum() {
     //        return max;
     //    }
         @Override
         public double getMinimum() {
             return min;
+        }
         @Override
         public double getMaximum() {
             return max;
+        }
         @Override
         public int getNumValues() {
             return histogramClasses.size();
+        }
-...
             return 0;
+        }
         public void addValue(double value){
             HistogramClass histogramClass = getHistogramClass(value);
             if(histogramClass == null){
                 histogramClass = new DefaultHistogramClass(value, value);
                 histogramClass.setValue(1);
                 histogramClasses.add(histogramClass);
                 Collections.sort(histogramClasses);
             } else {
                 histogramClass.increment(1);
+            }
+        }
+    }

Application: gvSIG desktop » gvSIG raster

Revision 5482