Application: gvSIG desktop

package org.gvsig.raster.lib.buffer.impl.statistics;

import java.util.Arrays;

import java.util.Iterator;

import java.util.List;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.layers.LayerInformationBuilder;

import org.gvsig.raster.lib.buffer.api.Band;

import org.gvsig.raster.lib.buffer.api.BufferLocator;

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.Statistics;

import org.gvsig.raster.lib.buffer.api.statistics.StatisticsBand;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.task.SimpleTaskStatus;

/**

 * @author fdiaz

 *

 */

public class DefaultStatistics implements Statistics {

    StatisticsBand[] statisticsBands;

    boolean calculated;

    double[][] varCov;

    /**

     *

     */

    public DefaultStatistics() {

    }

    /**

     * @param bands

     */

    private void init(List<Band> bands) {

        statisticsBands = new StatisticsBand[bands.size()];

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

            statisticsBands[i] = new DefaultStatisticsBand(bands.get(i));

        }

        varCov = new double[statisticsBands.length][statisticsBands.length];

        calculated = false;

    }

    @Override

    public long[] getNumberOfValues() {

        if(!isCalculated()){

            throw new IllegalStateException("Not calculated statistics.");

        }

        long[] result = new long[statisticsBands.length];

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

            result[i]= statisticsBands[i].getBandLength()-statisticsBands[i].getNoDataValuesCount();

        }

        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 getMaximum() {

        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 getMinimum() {

        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[] getMedian() {

        double[] result = new double[statisticsBands.length];

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

            result[i]= statisticsBands[i].getMedian();

        }

        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 boolean isCalculated() {

        return calculated;

    }

    @Override

    public void calculate(SimpleTaskStatus status, List<Band> bands) {

        calculated = false;

        boolean isMyStatus = false;

        if (status == null) {

            status = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("Statistics");

            status.add();

            isMyStatus = true;

        } else {

            status.push();

        }

        init(bands);

        try {

            status.setIndeterminate();

            status.message("Calculating statistics");

            int count = 1;

            int maxCount = statisticsBands.length*3;

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

                status.message("Calculating statistics "+count++ +"/"+maxCount);

               if (status.isCancelled()) {

                    status.abort();

                    return;

                }

                if(!statisticsBands[i].isCalculated()){

                    statisticsBands[i].calculate(status, bands.get(i));

                }

            }

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

                status.message("Calculating statistics "+count++ +"/"+maxCount);

                if (status.isCancelled()) {

                    status.abort();

                    return;

                }

                for (int j = i; j < statisticsBands.length; j++) {

                    this.varCov[i][j] = getCovariance(status,statisticsBands[i],bands.get(i), statisticsBands[j], bands.get(j));

                }

            }

            status.setIndeterminate();

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

                status.message("Calculating statistics "+count++ +"/"+maxCount);

                if (status.isCancelled()) {

                    status.abort();

                    return;

                }

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

                    varCov[i][j] = varCov[j][i];

                }

            }

            if (isMyStatus) {

                status.terminate();

            } else {

                status.pop();

            }

            calculated = true;

        } catch (Exception e) {

            status.abort();

            throw e;

        }

    }

    private double getCovariance(SimpleTaskStatus  status, StatisticsBand statisticBand1, Band band1, StatisticsBand statisticBand2, Band band2) {

        double sigma = 0;

        int n = 0;

        int rowCount = band1.getRows();

        status.setRangeOfValues(0, rowCount);

        for (int row = 0; row < rowCount; row++) {

            status.setCurValue(row);

            for (int column = 0; column < band1.getColumns(); column++) {

                Double v1 = band1.getAsDouble(row, column);

                if (v1 != null) {

                    double factor1 = v1 - statisticBand1.getMean();

                    Double v2 = band2.getAsDouble(row, column);

                    if (v2 != null) {

                        double factor2 = v2 - statisticBand2.getMean();

                        sigma+=(factor1*factor2);

                    }

                }

                n++;

            }

        }

        return sigma/n;

    }

    @Override

    public double[][] getVarianceCovarianceMatrix() {

        return this.varCov;

    }

    @Override

    public HistogramBand[] getHistogram() {

        HistogramBand[] histogramBands = new HistogramBand[statisticsBands.length];

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

            histogramBands[i]= statisticsBands[i].getHistogramBand();

        }

        return histogramBands;

    }

    @Override

    public double[][] getTailTrimValue(double percent) {

        double[][] result = new double[statisticsBands.length][2];

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

            result[i]=statisticsBands[i].getTailTrimValue(percent);

        }

        return result;

    }

    @Override

    public double[][] getTailTrimValue(int pos) {

        double[][] result = new double[statisticsBands.length][2];

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

            result[i]=statisticsBands[i].getTailTrimValue(pos);

        }

        return result;

    }

    @Override

    public Iterator<StatisticsBand> iterator() {

        return Arrays.asList(statisticsBands).iterator();

    }

    @Override

    public String toHTMLString() {

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        LayerInformationBuilder builder = MapContextLocator.getMapContextManager().createLayerInformationBuilder();

        double[][] matrix = this.getVarianceCovarianceMatrix();

        BufferManager bufferManager = BufferLocator.getBufferManager();

        int bandCounter = 0;

        for (StatisticsBand statisticsBand : this) {

            builder.title().labelkey(i18nManager.getTranslation("_band") + " " + bandCounter);

            int dataType = statisticsBand.getDataType();

            builder.property().labelkey("_dataType").value(bufferManager.getBufferTypeName(dataType));

            Long dataCount = statisticsBand.getBandLength();

            builder.property().labelkey("_dataCount").value(dataCount.toString());

            Long noDataValuesCount = statisticsBand.getNoDataValuesCount();

            builder.property().labelkey("_noDataValuesCount").value(noDataValuesCount.toString());

            Double minimum = statisticsBand.getMinimum();

            builder.property().labelkey("_minimum").value(minimum.toString());

            Double maximum = statisticsBand.getMaximum();

            builder.property().labelkey("_maximum").value(maximum.toString());

            Double mean = statisticsBand.getMean();

            builder.property().labelkey("_mean").value(mean.toString());

            Double median = statisticsBand.getMedian();

            builder.property().labelkey("_median").value(median.toString());

            Double secondMin = statisticsBand.getSecondMin();

            builder.property().labelkey("_secondMin").value(secondMin.toString());

            Double secondMax = statisticsBand.getSecondMax();

            builder.property().labelkey("_secondMax").value(secondMax.toString());

            Double variance = statisticsBand.getVariance();

            builder.property().labelkey("_variance").value(variance.toString());

            Double standardDeviation = Math.sqrt(variance);

            builder.property().labelkey("_standard_deviation").value(standardDeviation.toString());

            double[] covariance = matrix[bandCounter];

            for (int bandCounter2 = 0; bandCounter2 < covariance.length; bandCounter2++) {

                builder.property().label(i18nManager.getTranslation("_covariance_with_band") + " " + bandCounter2)

                .value(Double.toString(covariance[bandCounter2]));

            }

            for (int bandCounter2 = 0; bandCounter2 < covariance.length; bandCounter2++) {

                Double pearson = covariance[bandCounter2]/(statisticsBand.getVariance()*statisticsBands[bandCounter2].getVariance());

                builder.property().label(i18nManager.getTranslation("_pearson_correlation_coefficient_with_band") + " " + bandCounter2)

                .value(pearson.isNaN()?"\u2015":pearson.toString());

            }

            bandCounter++;

        }

        return builder.toString();

    }

}