Application: gvSIG desktop

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

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

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;

/**

 * @author fdiaz

 *

 */

public class DefaultHistogramBand implements HistogramBand {

    Band band;

    List<HistogramClass> histogramClasses;

    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 long getNumValues() {

        long count = 0;

        for (Iterator iterator = histogramClasses.iterator(); iterator.hasNext();) {

            HistogramClass histogramClass = (HistogramClass) iterator.next();

            count += histogramClass.getValue();

        }

        return count;

    }

    @Override

    public int getDataType() {

        return this.band.getDataType();

    }

    @Override

    public long getHistogramValue(double value) {

        HistogramClass histogramClass=getHistogramClass(value);

        if (histogramClass==null){

            return 0;

        }else{

            return histogramClass.getValue();

        }

    }

    private HistogramClass getHistogramClass(double value){

        for (HistogramClass histogramClass: histogramClasses){

            if (histogramClass.isIn(value)){

                return histogramClass;

            }

        }

        if(histogramClasses.size() == 0){

            return null;

        }

        HistogramClass lastHistogramClass = histogramClasses.get(histogramClasses.size()-1);

        if(lastHistogramClass.getMax() == value){

            return lastHistogramClass;

        }

        return null;

    }

    @Override

    public boolean union(HistogramBand hist) {

        //First we must check that histograms are compatible

        if (this.getNumClasses()==hist.getNumClasses()){

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

                if ( this.getIntervalMin(i)!=hist.getIntervalMin(i) ||

                    this.getIntervalMax(i)!=hist.getIntervalMax(i)){

                    return false;

                }

            }

        }else{

            return false;

        }

        //Once checked compatibility, values are added

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

            histogramClasses.get(i).increment(hist.getValueCount(i));

        }

        return true;

    }

    @Override

    public long[] getFrequencies() {

        Integer dataType = getDataType();

        int size;

        int rangeMin;

        int rangeMax;

        switch (dataType) {

        case BufferManager.TYPE_BYTE:

            rangeMin = 0;

            rangeMax = 255;

            size = 256;

            break;

        case BufferManager.TYPE_SHORT:

            rangeMin = Short.MIN_VALUE;

            rangeMax = Short.MAX_VALUE;

            size = rangeMax-rangeMin+1;

            break;

        case BufferManager.TYPE_USHORT:

            rangeMin = 0;

            rangeMax = Math.abs(Short.MIN_VALUE) + Short.MAX_VALUE;

            size = rangeMax-rangeMin+1;

            break;

        case BufferManager.TYPE_INT:

            rangeMin = Integer.MIN_VALUE;

            rangeMax = Integer.MAX_VALUE;

            size = rangeMax-rangeMin+1;

            break;

        default:

            throw new IllegalArgumentException("Can't process type '" + dataType + "'");

        }

        long[] table = new long[size];

            for (int j = 0; j < table.length; j++) {

                table[j] = getHistogramValue(j);

            }

        return table;

    }

    @Override

    public int getNumClasses() {

        return histogramClasses.size();

    }

    @Override

    public long getValueCount(int interval) {

        return histogramClasses.get(interval).getValue();

    }

    @Override

    public double getIntervalMin(int interval) {

        return histogramClasses.get(interval).getMin();

    }

    @Override

    public double getIntervalMax(int interval) {

        return histogramClasses.get(interval).getMax();

    }

    @Override

    public double getMedian() {

        double halfn=(getNumValues())/2d;

        return getUmpteenth(halfn);

    }

    /**

     * Obtiene el en?simo valor

     * @param n

     * @return

     */

    private double getUmpteenth(double n) {

        long contValues = 0;

        if (this.getDataType() == BufferManager.TYPE_FLOAT

            || this.getDataType() == BufferManager.TYPE_DOUBLE) { // Valores no

                                                                  // discretos

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

                HistogramClass histogramClass = histogramClasses.get(i);

                long anteriorCont = contValues;

                if (n == contValues) {

                    return histogramClass.getMin();

                }

                contValues += histogramClass.getValue();

                if (n == contValues) {

                    return histogramClass.getMax();

                }

                if (n < contValues) {

                    double median;

                    double nM = n; // getBandLenght() / 2;

                    double nA = anteriorCont;

                    double fI = histogramClass.getValue();

                    double interval = histogramClass.getMax() - histogramClass.getMin();

                    double min = histogramClass.getMin();

                    median = min + ((nM - nA) / fI) * interval;

                    return median;

                }

            }

        } else { // Valores discretos

            double antMax = Double.NEGATIVE_INFINITY;

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

                HistogramClass histogramClass = histogramClasses.get(i);

                if (n == contValues) {

                    return (histogramClass.getMin() + antMax) / 2;

                }

                contValues += histogramClass.getValue();

                if (n < contValues) {

                    return histogramClass.getMin();

                }

                antMax = histogramClass.getMax();

            }

        }

        return 0;

    }

    /**

     * Adds value to histogram

     *

     * @param value

     */

    public void addValue(double value){

        HistogramClass histogramClass = getHistogramClass(value);

        if(histogramClass == null){

            histogramClass = new DefaultHistogramClass(value, value);

            histogramClass.setValue(1);

            histogramClasses.add(histogramClass);

            // So that the list is always sorted

            Collections.sort(histogramClasses);

        } else {

            histogramClass.increment(1);

        }

    }

    @Override

    public double[] getTailTrimValue(double percent) {

        if(percent>100 || percent <0){

            StringBuilder builder = new StringBuilder();

            builder.append("Percent ");

            builder.append(percent);

            builder.append(" is out of range [0,100]");

            throw new IllegalArgumentException(builder.toString());

        }

        long lowPosition = Math.round(getNumValues()*percent/100);

        long upperPosition = Math.round(getNumValues()*(100-percent)/100);

        double[] result = new double[2];

        result[0] = getUmpteenth(lowPosition);

        result[1] = getUmpteenth(upperPosition);

        return result;

    }

    @Override

    public double[] getTailTrimValue(int pos) {

        long lowPosition = pos;

        long upperPosition = getNumValues()-pos;

        double[] result = new double[2];

        result[0] = getUmpteenth(lowPosition);

        result[1] = getUmpteenth(upperPosition);

        return result;

    }

}