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.buffer;

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

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

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

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.fmap.dal.coverage.datastruct.BufferHistogram;

/**

 * This class computes the histogram for a <code>Buffer</code>

 * 

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

 */

public class BufferHistogramComputer implements HistogramComputer {

        private BufferHistogram             histogram            = null;

        private Buffer                      buffer               = null;

        protected int                                    progressHistogram    = 0;

        private double[]                    limits               = null;

        private boolean                     refresh              = false;

        @SuppressWarnings("unused")

        private double                      scale                = 1;

        /**

         * Constructor

         * @param dataset

         */

        public BufferHistogramComputer(Buffer buffer) {

                this.buffer = buffer;

        }

        public void setScaleHistogram(double scale) {

                this.scale = scale;

        }

        public BufferHistogram getBufferHistogram()

        throws ProcessInterruptedException, HistogramException {

                if(histogram == null || refresh) {

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

                        progressHistogram = 0;

                        double[][] limits = buffer.getAllBandsLimits();

                        BufferHistogramImpl hist = new BufferHistogramImpl(buffer.getBandCount(), limits[0], limits[1], buffer.getDataType());

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

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

                                        switch(buffer.getDataType()) {

                                        case Buffer.TYPE_BYTE:

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

                                                        hist.incrementPxValue(iBand, (double)(buffer.getElemByte(row, col, iBand)));

                                                break;

                                        case Buffer.TYPE_SHORT:

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

                                                        hist.incrementPxValue(iBand, (double)(buffer.getElemShort(row, col, iBand)));

                                                break;

                                        case Buffer.TYPE_INT:

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

                                                        hist.incrementPxValue(iBand, (double)(buffer.getElemInt(row, col, iBand)));

                                                break;

                                        case Buffer.TYPE_FLOAT:

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

                                                        hist.incrementPxValue(iBand, (double)buffer.getElemFloat(row, col, iBand));

                                                break;

                                        case Buffer.TYPE_DOUBLE:

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

                                                        hist.incrementPxValue(iBand, buffer.getElemDouble(row, col, iBand));

                                                break;

                                        }

                                        if (task.getEvent() != null)

                                                task.manageEvent(task.getEvent());

                                        progressHistogram = ((iBand * buffer.getHeight() + row) * 100) /(buffer.getHeight() * buffer.getBandCount());

                                }

                        }

                        progressHistogram = 100;

                        histogram = hist;

                }

                return histogram;

        }

        public void resetPercent() {

                progressHistogram = 0;

        }

        public int getPercent() {

                return progressHistogram;

        }

        public double getMinimum() {

                if(limits == null)

                        try {

                                limits = buffer.getLimits();

                        } catch (ProcessInterruptedException e) {

                                return 0;

                        }

                return limits[0];

        }

        public double getMaximum() {

                if(limits == null)

                        try {

                                limits = buffer.getLimits();

                        } catch (ProcessInterruptedException e) {

                                return 0;

                        }

                return limits[1];

        }

        public void refreshHistogram() {

                refresh = true;

        }

        public String getLog() {

                return null;

        }

        public boolean isCancelable() {

                return true;

        }

        public boolean isPausable() {

                return false;

        }

        public void setPercent(int value) {

                progressHistogram = value;

        }

}