Application: gvSIG desktop » gvSIG raster

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

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

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.raster.impl.grid;

import org.gvsig.fmap.dal.coverage.dataset.Buffer;

import org.gvsig.fmap.dal.coverage.exception.BandAccessException;

import org.gvsig.fmap.dal.coverage.exception.FileNotOpenException;

import org.gvsig.fmap.dal.coverage.exception.GridException;

import org.gvsig.fmap.dal.coverage.exception.RasterBufferInvalidAccessException;

import org.gvsig.fmap.dal.coverage.exception.RasterDriverException;

import org.gvsig.fmap.dal.coverage.store.props.BasicStats;

/**

 * Estadisticas de un grid

 * @author Victor Olaya (volaya@ya.com)

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class GridStatistic implements BasicStats {

        private double[]                         max = null;

        private double[]                         min = null;

        private double[]                         mean = null;

        private double[]                         variance = null;

        private boolean                         statisticsCalculated = false;

        private GridImpl                        grid = null;

        protected int                                bandToOperate = 0;

        public GridStatistic(GridImpl grid){

                this.grid = grid;

        }

        private void calculateStatistics() throws GridException {

                int x, y;

                double z;

                int[] iValues = new int[grid.getBandCount()];

                mean = new double[grid.getBandCount()];

                min = new double[grid.getBandCount()];

                max = new double[grid.getBandCount()];

                variance = new double[grid.getBandCount()];

                for (int iBand = 0; iBand < grid.getBandCount(); iBand++) {

                        mean[iBand]        = 0.0;

                        variance[iBand]        = 0.0;

                        iValues[iBand]        = 0;

                }

                int oldBandToOperate = bandToOperate;

                statisticsCalculated = true;

                for (int iBand = 0; iBand < grid.getBandCount(); iBand++) {

                        grid.setBandToOperate(iBand);

                        for (y = 0; y < grid.getNY(); y++){

                                for (x = 0; x < grid.getNX(); x++){

                                        z = getValue(x, y);

                                        if( !grid.isNoDataValue(z))        {

                                                if( iValues[iBand] == 0 )

                                                        min[iBand] = max[iBand] = z;

                                                else if( min[iBand] > z )

                                                        min[iBand]        = z;

                                                else if( max[iBand] < z )

                                                        max[iBand]        = z;

                                                mean[iBand]        += z;

                                                variance[iBand] += z * z;

                                                iValues[iBand]++;

                                        }

                                }

                        }

                        if( iValues[iBand] > 0 ){

                                mean[iBand]        /= (double) iValues[iBand];

                                variance[iBand] = variance[iBand] / (double) iValues[iBand] - mean[iBand] * mean[iBand];

                        }

                }

                bandToOperate = oldBandToOperate;

                statisticsCalculated = true;

        }

        /**

         * Obtiene un valor de una celda del grid independientemente del tipo de dato.

         * @param x Posici?n en X

         * @param y Posici?n en Y

         * @return Valor de la celda en formato double

         * @throws RasterBufferInvalidAccessException

         */

        private double getValue(int x, int y) throws GridException {

                switch(grid.getDataType()) {

                case Buffer.TYPE_BYTE:return (double)(grid.getCellValueAsByte(x, y)  & 0xff);

                case Buffer.TYPE_SHORT:return (double)(grid.getCellValueAsShort(x, y)  & 0xffff);

                case Buffer.TYPE_INT:return (double)(grid.getCellValueAsInt(x, y)  & 0xffffffff);

                case Buffer.TYPE_FLOAT:return (double)grid.getCellValueAsFloat(x, y);

                case Buffer.TYPE_DOUBLE:return (double)grid.getCellValueAsDouble(x, y);

                }

                return 0;

        }

        /**

         * Asigna el flag que informa si las estadisticas est?n calculadas para un grid concreto

         * @param calc true si est?n calculadas y false si no lo est?n

         */

        public void setStatisticsCalculated(boolean calc){

                this.statisticsCalculated = calc;

        }

        /**

         * Asigna la banda sobre la que se realizan las operaciones. Por defecto es la banda 0

         * con lo que para el uso de MDTs no habr? que modificar este valor.

         * @param band Banda sobre la que se realizan las operaciones.

         */

        public void setBandToOperate(int band){

                this.bandToOperate = band;

        }

        public void calcFullStatistics() throws FileNotOpenException,

                        RasterDriverException, InterruptedException {

                try {

                        calculateStatistics();

                } catch (GridException e) {

                        throw new RasterDriverException("");

                }

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.dataset.BasicStats#getMaxValue()

         */

        public double getMaxValue() throws BandAccessException {

                return max[bandToOperate];

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.dataset.BasicStats#getMeanValue()

         */

        public double getMeanValue() throws BandAccessException {

                return mean[bandToOperate];

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.dataset.BasicStats#getMinValue()

         */

        public double getMinValue() throws BandAccessException {

                return min[bandToOperate];

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.dataset.BasicStats#getVarianceValue()

         */

        public double getVarianceValue() throws BandAccessException {

                return variance[bandToOperate];

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.dataset.BasicStats#isCalculated()

         */

        public boolean isCalculated() {

                return statisticsCalculated;

        }

        public void dispose() {

                try {

                        finalize();

                } catch (Throwable e) {

                }

        }

        /*

         * (non-Javadoc)

         * @see java.lang.Object#finalize()

         */

        protected void finalize() throws Throwable {

                max = null;

                min = null;

                mean = null;

                variance = null;

                grid = null;

                super.finalize();

        }

}