| gvSIG desktop 1

/*

 * Cresques Mapping Suite. Graphic Library for constructing mapping applications.

 *

 * Copyright (C) 2004-5.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 * cresques@gmail.com

 */

package org.cresques.filter.statistics;

import java.util.ArrayList;

import java.util.Arrays;

import org.cresques.filter.RasterFilter;

import org.cresques.io.datastruct.Statistic;

import org.cresques.util.QuickSort;

import org.gvsig.i18n.Messages;

/**

 * Filtro de recorte de colas. Este filtro toma pixels de la imagen (todos o algunas muestras

 * dependiendo de la variable percentSample) y los ordena. Recorta un porcentaje controlado

 * por tailPercenten ambos extremos del vector ordenado. El nuevo m?ximo y m?nimo coinciden

 * con el valor de la posici?n del vector recortado. Por arriba para el m?ximo y por abajo

 * para el m?nimo.

 * El execute de este filtro no recorre toda la imagen sino que lo

 * hace en funci?n del porcentaje de muestras que quieren tomarse y

 * calculando a partir de este porcentaje un incremento.

 * @author Nacho Brodin (brodin_ign@gva.es)

 */

public abstract class PercentTailTrimFilter extends RasterFilter {

    protected int[]                 min = {

                              Integer.MAX_VALUE, Integer.MAX_VALUE,

                              Integer.MAX_VALUE

                                  };

    protected int[]                 max = {

                              Integer.MIN_VALUE, Integer.MIN_VALUE,

                              Integer.MIN_VALUE

                                  };

    protected int                         count = 0;

    protected double[][]                 sample;

    private int                         tailSize = 0;

    private int                         nSamples = 0;

    private boolean                 removeMaxValue = false;

    protected int                         incX , incY;

    //Par?metros del filtro

    protected double                 tailPercent = 0D;

    public double                         percentSamples = 0D;

    protected ArrayList         fileList = new ArrayList();

    public PercentTailTrimFilter() {

            super.filterName = Messages.getText("tail_trim");

    }

    /**

     * Calcula el incremento de X y de Y para la toma de muestras en el calculo de

     * valores para el recorte

     */

    public void pre() {

        //Obtenemos par?metros comunes

        this.stats = (Statistic) params.get("stats");

        this.tailPercent = ((Double) params.get("tail")).doubleValue();

        this.percentSamples = ((Double) params.get("samples")).doubleValue();

        this.removeMaxValue = ((Boolean) params.get("remove")).booleanValue();

        if (exec) {

            this.stats.tailPercent = this.tailPercent;

            count = 0;

            if (this.percentSamples == 0) { //Se toman todos los pixeles de la imagen 

                nSamples = height * width;

                sample = new double[3][height * width];

                tailSize = (int) Math.round(this.tailPercent * nSamples);

            } else { //Se toma un porcentaje de pixeles de la imagen para el calculo

                incX = (int) Math.round(width / (int) Math.round(this.percentSamples * width));

                incY = (int) Math.round(height / (int) Math.round(this.percentSamples * height));

                nSamples = (int) ((Math.round(width / incX) + 1) * (Math.round(height / incY) +

                           1));

                sample = new double[3][nSamples];

                tailSize = (int) (nSamples * this.tailPercent);

            }

        }

    }

    /**

     * Ordena las muestras , recorta y asigna m?ximo y m?nimo dependiendo del porcentaje

     * de recorte

     */

    public void post() {

        if (exec) {

            QuickSort q = new QuickSort();

            int posInit = 0;

            int posFin = sample[0].length - 1;

            //Ordenamos los vectores

            for (int i = 0; i < 3; i++)

                //q.quicksort(sample[i]);

                    Arrays.sort(sample[i]);

            //Si est? marcada la opci?n removeMaxValue se calcula la posici?n en la que el m?ximo valor

            //y el m?nimo ya no estan, teniendo as? un subconjunto del vector que elimina estos valores

            if (removeMaxValue) {

                for (int i = 0; i < sample[0].length; i++) {

                    if ((sample[0][i] != sample[0][0]) ||

                            (sample[1][i] != sample[1][0]) ||

                            (sample[2][i] != sample[2][0])) {

                        posInit = i;

                        break;

                    }

                }

                for (int i = sample[0].length - 1; i > 0; i--) {

                    if ((sample[0][i] != sample[0][sample[0].length - 1]) ||

                            (sample[1][i] != sample[1][sample[0].length - 1]) ||

                            (sample[2][i] != sample[2][sample[0].length - 1])) {

                        posFin = i;

                        break;

                    }

                }

                //Calculamos de nuevo el n?mero de muestras ya que hemos quitado los valores m?ximo y m?nimo

                nSamples = posFin - posInit;

                //Como ha podido cambiar nSamples recalculamos tailsize

                tailSize = (int) (nSamples * this.tailPercent);

            }

            //Ordenamos los elementos y cogemos el minimo y m?ximo para cada banda

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

                stats.minBandValue[i] = sample[i][posInit + tailSize];

                stats.maxBandValue[i] = sample[i][(posInit + nSamples) -

                                        tailSize - 1];

            }

        }

    }

    /**

     * Obtiene el objeto stats con el m?ximo y m?nimo calculado

     */

    public Object getResult(String name) {

        if (name.equals("stats")) {

            return (Object) this.stats;

        } else {

            return null;

        }

    }

    /**

     * Obtiene el porcentaje de recorte

     * @return porcentaje de recorte

     */

    public double getTailPercent() {

        return tailPercent;

    }

    /**

     * Devuelve true si se eliminan los extremos de la serie antes del calculo del recorte de colas

     * o false si no se eliminan.

     * @return

     */

    public boolean removeMaxValue() {

        return this.removeMaxValue;

    }

}