Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * 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 3

 * 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., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureQuery;

import org.gvsig.fmap.dal.feature.FeatureSet;

import org.gvsig.fmap.dal.feature.FeatureStore;

/**

 * Calcula los intervalos en funci?n del n?mero de intervalos que se pidan.

 *

 * @author Vicente Caballero Navarro

 */

public class QuantileIntervalGenerator {

//        private DataSource sds;

        private FeatureStore featureStore;

        private String msFieldName;

        private int miNumIntervalosSolicitados;

        private double[] mdaValoresRuptura;

        private double[] mdaValInit;

        private int num = 0;

        /**

         * Crea un nuevo QuantileIntervalGenerator.

         *

         * @param layer DOCUMENT ME!

         * @param field DOCUMENT ME!

         * @param numIntervals DOCUMENT ME!

         */

        public QuantileIntervalGenerator(FeatureStore fs, String field,

                int numIntervals) {

                featureStore = fs;

                msFieldName = field;

                miNumIntervalosSolicitados = numIntervals;

        }

        /**

         * Genera los intervalos.

         * @throws DataException TODO

         *

         */

        public void generarIntervalos()

                throws DataException {

                List<Number> ordenadas = new ArrayList<Number>();

                List<Integer> coincidencias = new ArrayList<Integer>();

//                int pos = ((FeatureType)featureStore.getFeatureTypes().get(0)).getIndex(msFieldName);

                mdaValoresRuptura = new double[miNumIntervalosSolicitados - 1];

                mdaValInit = new double[miNumIntervalosSolicitados - 1];

                FeatureQuery featureQuery=featureStore.createFeatureQuery();

                featureQuery.setAttributeNames(new String[]{msFieldName});

                FeatureSet set = null;

                DisposableIterator iterator = null;

                try {

                        set = featureStore.getFeatureSet(featureQuery);

                        iterator = set.fastIterator();

                        long rowCount = 0;

                        while (iterator.hasNext()) {

                                Feature feature = (Feature) iterator.next();

                                insertarEnVector(ordenadas, coincidencias, feature.get(0));// sds.getFieldValue(i,

                                                                                                                                                        // pos));

                                rowCount++;

                        }

                        // int MARGEN = 5;

                        // for (int i = 0; i < sds.getRowCount(); i++) {

                        // insertarEnVector(ordenadas, coincidencias, sds.getFieldValue(i,

                        // pos));

                        // }

                        int index = 0;

                        int posj = 0;

                        for (int i = 1; i < miNumIntervalosSolicitados; i++) {

                                long x = ((i * rowCount) / miNumIntervalosSolicitados);

                                for (int j = posj; j < ordenadas.size(); j++) {

                                        int auxcoin = ((Integer) coincidencias.get(j)).intValue();

                                        index = index + auxcoin;

                                        if (x <= index) {

                                                mdaValoresRuptura[i - 1] = getValue(ordenadas.get(j));

                                                /*

                                                 * index = (int) ((x + (auxcoin /

                                                 * miNumIntervalosSolicitados)) - 1);

                                                 */

                                                posj = j + 1;

                                                if (posj < ordenadas.size()) {

                                                        mdaValInit[i - 1] = getValue(ordenadas.get(posj));

                                                } else {

                                                        mdaValInit[i - 1] = getValue(ordenadas.get(j));

                                                }

                                                num++;

                                                break;

                                        }

                                }

                                // double value=getValue(sds.getFieldValue(x,pos));

                        }

                        // }

                } finally {

                        if (iterator != null) {

                                iterator.dispose();

                        }

                        if (set != null) {

                                set.dispose();

                        }

                }

        }

        /**

         * Esta funci?n busca en el vector de datos la posici?n que le corresponde

         * al valor almacenado en vdValor y devuelve dicha posici?n en

         * vdValorAInsertar. Para hallar la posici?n se realiza una b?squeda

         * binaria. Si se trata de un elemento que ya est? en el vector devolvemos

         * el ?ndice que le corresponde en rlIndiceCorrespondiente y false en

         * rbNuevoElemento. Si se trata de un nuevo elemento que hay que

         * insertar... devolvemos el ?ndice en el que ir?a y True en

         * rbNuevoElemento En caso de que ocurra alg?n error devuelve false

         *

         * @param rVectorDatos ArrayList con los datos.

         * @param coincidencia ?ndice.

         * @param vdValorAInsertar Valor a insertar.

         */

        private void insertarEnVector(List<Number> rVectorDatos,

                        List<Integer> coincidencia, Object vdValorAInsertar) {

                int llIndiceIzq;

                int llIndiceDer;

                int llMedio;

                int indice = -1;

                double ldValorComparacion;

                double valorAInsertar = getValue(vdValorAInsertar);

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

                        rVectorDatos.add((Number) vdValorAInsertar);

                        coincidencia.add(new Integer(1));

                        return;

                }

                llIndiceIzq = 0;

                llIndiceDer = rVectorDatos.size() - 1;

                llMedio = (llIndiceIzq + llIndiceDer) / 2; //'Divisi?n entera!

                while (llIndiceIzq <= llIndiceDer) {

                        //'Coger el valor situado en la mitad de la zona de b?squeda como valor de comparaci?n

                        ldValorComparacion = getValue( rVectorDatos.get(llMedio));

                        //'Si el valor a insertar es mayor que el valor de comparaci?n...

                        if (valorAInsertar > ldValorComparacion) {

                                //      'La zona de b?squeda queda restringida a la parte de la derecha

                                llIndiceIzq = llMedio + 1;

                                llMedio = (llIndiceIzq + llIndiceDer) / 2;

                                //    'Si el valor a insertar es menor que el valor de comparaci?n...

                        } else if (valorAInsertar < ldValorComparacion) {

                                //          'La zona de b?squeda queda restringida a la parte de la derecha

                                llIndiceDer = llMedio - 1;

                                llMedio = (llIndiceIzq + llIndiceDer) / 2;

                                //        'Si el valor de comparaci?n coincide con el valor a insertar

                        } else if (valorAInsertar == ldValorComparacion) {

                                indice = llMedio;

                                int index = rVectorDatos.indexOf(vdValorAInsertar);

                                int coin = ((Integer) coincidencia.get(index)).intValue() + 1;

                                coincidencia.remove(index);

                                coincidencia.add(index, new Integer(coin));

                                return;

                        }

                }

                //  'Nota:

                //  'En este caso (cuando en rbNuevoElemento se devuelve True) lo que hay que hacer al salir de esta funci?n

                //  'es a?adir un nuevo elemento al vector y desplazar todos los valores correspondientes a partir de rlIndiceCorrespondiente

                //  '?D?nde va el nuevo elemento?

                //  'El ?ltimo sitio estudiado viene dado por el valor de llMedio.

                //  'Si el valor a insertar es menor que el valor almacenado en la posici?n llMedio, el nuevo valor deber? ir a su izquierda.

                //  'Si fuera mayor deber?a ir a su derecha.

                ldValorComparacion = getValue( rVectorDatos.get(llMedio));

                if (valorAInsertar > ldValorComparacion) {

                        indice = llMedio + 1;

                } else {

                        indice = llMedio;

                }

                rVectorDatos.add(indice, (Number) vdValorAInsertar);

                coincidencia.add(indice, new Integer(1));

        }

        /**

         * Devuelve el valor en un double del Value que se pasa como par?metro.

         *

         * @param value Value.

         *

         * @return valor.

         */

        private double getValue(Object value) {

                if (value instanceof Number) {

                        return ((Number) value).doubleValue();

                }

                return 0;

        }

        /**

         * Devuelve el valor del punto de ruptura seg?n el ?ndice que se pasa como

         * par?metro.

         *

         * @param index ?ndice del punto de ruptura.

         *

         * @return valor.

         */

        public double getValRuptura(int index) {

                return mdaValoresRuptura[index];

        }

        /**

         * Devuelve el valor inicial de cada intervalo.

         *

         * @param index ?ndice del intervalo.

         *

         * @return valor del intervalo.

         */

        public double getValInit(int index) {

                return mdaValInit[index];

        }

        /**

         * Devuelve el n?mero de intervalos que se han generado.

         *

         * @return N?mero de intervalos generados.

         */

        public int getNumIntervalGen() {

                return num + 1;

        }

}