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.store.properties;

import java.util.ArrayList;

import org.gvsig.fmap.dal.coverage.RasterLibrary;

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

import org.gvsig.fmap.dal.coverage.datastruct.BufferHistogram;

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

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

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

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

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

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

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

import org.gvsig.raster.impl.datastruct.BufferHistogramImpl;

import org.gvsig.raster.impl.process.RasterTask;

import org.gvsig.raster.impl.process.RasterTaskQueue;

import org.gvsig.raster.impl.provider.RasterProvider;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Clase para la gesti?n de histogramas de un raster. Es la encargada del calculo de un histograma

 * total o parcial de un raster a partir de los datos de disco. Adem?s tambi?n es la encargada de gestionar

 * salvar este histograma a .rmf. En caso de que solicite un histograma del raster completo este ir?

 * a buscarlo al fichero rmf asociado antes de calcularlo por si ya existise. Al realizar el calculo

 * del histograma de la imagen completa este ser? salvado en el fichero .rmf asociado al raster.

 * 

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

 */

public class SimpleProviderHistogramComputer implements HistogramComputer {

        private static final Logger     logger    = LoggerFactory.getLogger(SimpleProviderHistogramComputer.class);

        /**

         * Histograma de la imagen completa

         */

        protected BufferHistogramImpl   histogram = null;

        /**

         * Dataset del cual se calcula el histograma

         */

        private RasterProvider          provider  = null;

        private int                     percent   = 0;

        private boolean                 refresh   = false;

        private double                  scale     = 1;

        /**

         * Constructor

         * @param dataset

         */

        public SimpleProviderHistogramComputer(RasterProvider provider) {

                this.provider = provider;

        }

        public void setScaleHistogram(double scale) {

                this.scale = scale;

        }

        /**

         * Obtiene el minimo valor de las estadisticas de un histograma.

         * @return double

         */

        public double getMinimum() {

                return provider.getStatistics().getMinimun();

        }

        /**

         * Obtiene el maximo valor de las estadisticas de un histograma.

         * @return double

         */

        public double getMaximum() {

                return provider.getStatistics().getMaximun();

        }

        /**

         * Obtiene el histograma. Si puede conseguirlo del fichero rmf ir? all? a 

         * buscarlo sino lo calcular?.

         * @return histograma 

         */

        public BufferHistogram getBufferHistogram() throws HistogramException, ProcessInterruptedException {

                RasterTask task = RasterTaskQueue.get(Thread.currentThread().getId() + "");

                if (provider != null) {

                        if(histogram == null || refresh) {

                                try {

                                        provider.getStatistics().calculate(1);

                                } catch (FileNotOpenException e) {

                                        throw new HistogramException("");

                                } catch (RasterDriverException e) {

                                        throw new HistogramException("");

                                }

                                try {

                                        histogram = (BufferHistogramImpl) provider.loadObjectFromRmf(BufferHistogram.class, histogram);

                                        if (histogram != null)

                                                return histogram;

                                } catch (RmfSerializerException e) {

                                        //No carga desde rmf. No afecta a la funcionalidad

                                }

                                if(task.getEvent() != null)

                                        task.manageEvent(task.getEvent());

                                histogram = new BufferHistogramImpl(provider.getBandCount(), 

                                                provider.getStatistics().getMin(), 

                                                provider.getStatistics().getMax(), 

                                                provider.getDataType()[0]);

                                try {

                                        histogram = (BufferHistogramImpl)getHistogramByDataType();

                                } catch (FileNotOpenException e) {

                                        throw new HistogramException("", e);

                                } catch (RasterDriverException e) {

                                        throw new HistogramException("", e);

                                } catch (Exception e) {

                                        logger.info("Error calculando el histograma", e);

                                }

                                try {

                                        provider.saveObjectToRmf(BufferHistogram.class, histogram);

                                } catch (RmfSerializerException e) {

                                        //No salva a rmf. No afecta a la funcionalidad

                                }

                        }

                        return histogram;

                }

                return null;

        }

        /**

         * Gets an array of data from a buffer 

         * @param type

         * @param buf

         * @return

         */

        private void loadHistogramFromBuffer(Buffer buf) {

                switch (buf.getDataType()) {

                case Buffer.TYPE_BYTE:

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

                                for (int col = 0; col < buf.getWidth(); col++)

                                        for (int row = 0; row < buf.getHeight(); row++)

                                                histogram.incrementPxValue(iBand, (double) buf.getElemByte(row, col, iBand));

                        break;

                case Buffer.TYPE_SHORT:

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

                                for (int col = 0; col < buf.getWidth(); col++)

                                        for (int row = 0; row < buf.getHeight(); row++)

                                                histogram.incrementPxValue(iBand, (double) buf.getElemShort(row, col, iBand));

                        break;

                case Buffer.TYPE_FLOAT:

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

                                for (int col = 0; col < buf.getWidth(); col++)

                                        for (int row = 0; row < buf.getHeight(); row++)

                                                histogram.incrementPxValue(iBand, (double) buf.getElemFloat(row, col, iBand));

                        break;

                case Buffer.TYPE_DOUBLE:

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

                                for (int col = 0; col < buf.getWidth(); col++)

                                        for (int row = 0; row < buf.getHeight(); row++)

                                                histogram.incrementPxValue(iBand, (double) buf.getElemDouble(row, col, iBand));

                        break;

                case Buffer.TYPE_INT:

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

                                for (int col = 0; col < buf.getWidth(); col++)

                                        for (int row = 0; row < buf.getHeight(); row++)

                                                histogram.incrementPxValue(iBand, (double) buf.getElemInt(row, col, iBand));

                        break;

                }

        }

        /**

         * Obtiene el histograma teniendo en cuenta la lista de clases

         * @return Histograma correspondiente a la lista de clases

         */

        private BufferHistogram getHistogramByDataType() 

                throws InvalidSetViewException, FileNotOpenException, RasterDriverException, ProcessInterruptedException {

                RasterTask task = RasterTaskQueue.get(Thread.currentThread().getId() + "");

                percent = 0;

                int type = provider.getDataType()[0];

                int h = RasterLibrary.blockHeight;

                if(provider.getNoDataValue().isDefined())

                        histogram.setNoDataValue(provider.getNoDataValue());

                for (int block = 0; block < provider.getHeight(); block += h) {

                        Object buf = null;

                        try {

                                buf = provider.readBlock(block, h, scale);

                        } catch (InvalidSetViewException e) {

                                // La vista se asigna autom?ticamente

                        }

                        int hB = h;

                        if ((block + hB) > provider.getHeight())

                                hB = Math.abs(((int)provider.getHeight()) - block);

                        hB *= scale;

                        if(buf instanceof Buffer) {

                                loadHistogramFromBuffer((Buffer)buf);

                        } else {

                                switch (type) {

                                case Buffer.TYPE_BYTE:

                                        byte[][][] bBlock = (byte[][][]) buf;

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

                                                for (int col = 0; col < bBlock[iBand][0].length; col++)

                                                        for (int row = 0; row < hB; row++)

                                                                histogram.incrementPxValue(iBand, (double) bBlock[iBand][row][col]);

                                        break;

                                case Buffer.TYPE_SHORT:

                                        short[][][] sBlock = (short[][][]) buf;

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

                                                for (int col = 0; col < sBlock[iBand][0].length; col++)

                                                        for (int row = 0; row < hB; row++)

                                                                histogram.incrementPxValue(iBand, (double) sBlock[iBand][row][col]);

                                        break;

                                case Buffer.TYPE_INT:

                                        int[][][] iBlock = (int[][][]) buf;

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

                                                for (int col = 0; col < iBlock[iBand][0].length; col++)

                                                        for (int row = 0; row < hB; row++)

                                                                histogram.incrementPxValue(iBand, (double) iBlock[iBand][row][col]);

                                        break;

                                case Buffer.TYPE_FLOAT:

                                        float[][][] fBlock = (float[][][]) buf;

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

                                                for (int col = 0; col < fBlock[iBand][0].length; col++)

                                                        for (int row = 0; row < hB; row++)

                                                                histogram.incrementPxValue(iBand, (double) (fBlock[iBand][row][col]));

                                        break;

                                case Buffer.TYPE_DOUBLE:

                                        double[][][] dBlock = (double[][][]) buf;

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

                                                for (int col = 0; col < dBlock[iBand][0].length; col++)

                                                        for (int row = 0; row < hB; row++)

                                                                histogram.incrementPxValue(iBand, (double) (dBlock[iBand][row][col]));

                                        break;

                                }

                        }

                        if (task.getEvent() != null)

                                task.manageEvent(task.getEvent());

                        percent += ((h * 100) / provider.getHeight());

                }

                percent = 100;

                return histogram;

        }

        /**

         * Pone a cero el porcentaje de progreso del proceso de calculo de histograma

         */

        public void resetPercent() {

                percent = 0;

        }

        /**

         * Obtiene el porcentaje de progreso del proceso de calculo de histograma

         * @return porcentaje de progreso

         */

        public int getPercent() {

                return percent;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.store.props.HistogramComputer#refreshHistogram()

         */

        public void refreshHistogram() {

                refresh = true;

        }

        protected void setBufferHistogram(BufferHistogram bh) {

                if(bh instanceof BufferHistogramImpl)

                        this.histogram = (BufferHistogramImpl)bh;

        }

        /**

         * Joins the this histogram object with the parameter and

         * returns a new Histogram object.

         * @param stats

         * @return

         * @throws InterruptedException 

         * @throws HistogramException 

         */

        public static HistogramComputer union(RasterProvider prov, ArrayList<RasterProvider> list) throws HistogramException, InterruptedException {

                SimpleProviderHistogramComputer newHistogramComputer = new SimpleProviderHistogramComputer(prov);

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

                        HistogramComputer hc = list.get(0).getHistogramComputer();

                        try {

                                BufferHistogram bh = hc.getBufferHistogram();

                                if(newHistogramComputer.histogram == null) {

                                        newHistogramComputer.setBufferHistogram(bh);

                                } else {

                                        newHistogramComputer.histogram.union(bh);

                                }

                        } catch (ProcessInterruptedException e) {

                                throw new InterruptedException();

                        }

                }

                return newHistogramComputer;

        }

        public String getLog() {

                return null;

        }

        public boolean isCancelable() {

                return true;

        }

        public boolean isPausable() {

                return false;

        }

        public void setPercent(int value) {

        }

}