Application: gvSIG desktop » gvSIG raster

package org.gvsig.raster.impl.store;

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

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

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

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

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

import org.gvsig.fmap.dal.coverage.store.RasterDataStore;

import org.gvsig.raster.impl.DefaultRasterManager;

import org.gvsig.raster.impl.buffer.DefaultRasterQuery;

import org.gvsig.raster.impl.buffer.SpiRasterQuery;

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

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

/**

 * The requests to a <code>RasterDataStore</code> adjust the bounding box and the size in pixels 

 * to the source limits. The user can need a buffer that exceeds the raster dimension. 

 * In this case, the area that is out of the raster limits should be set to nodata values or 

 * transparent in RGB cases. 

 * 

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

 * @deprecated Is being used the method getAdjustedWindow of <code>Buffer</code> 

 */

public class Supersampling {

        private DefaultRasterQuery           query                   = null;

        private DefaultRasterQuery           originalQuery           = null;

        private RasterDataStore              store                   = null; 

        private FramedBufferResampling       framedBufferResampling  = null;

        protected byte                       byteNoData              = (byte)0x00;

        protected short                      shortNoData             = Short.MIN_VALUE;

        protected int                        intNoData               = Integer.MIN_VALUE;

        protected float                      floatNoData             = -99999;

        protected double                     doubleNoData            = -99999;

        public Supersampling(DefaultRasterQuery q, RasterDataStore store) {

                this.query = q;

                this.store = store;

                setNoDataValue(store.getNoDataValue());

                this.originalQuery = (DefaultRasterQuery)query.clone();

        }

        public Buffer query(RasterProvider provider) throws QueryException, ProcessInterruptedException {

                query.calculateParameters(store);

                Buffer bufResult = null;

                Buffer buf = null;

                try {

                        if(query.requestHasShift()) {

                                framedBufferResampling = new FramedBufferResampling(originalQuery, store);

                                buf = framedBufferResampling.query(provider);

                        } else 

                                buf = ((AbstractRasterProvider)provider).getDataSet((SpiRasterQuery)query);

                        bufResult = supersampleBuffer(buf);

                        buf.dispose();

                } catch (RasterDriverException e) {

                        throw new QueryException("Error getting data", e);

                }

                return bufResult;

        }

        private Buffer supersampleBuffer(Buffer buf) {

                int width = query.getBufWidth();

                int height = query.getBufHeight();

                double[] step = query.getStep();

                Buffer result = buildBuffer(buf.getBandCount(), width, height, buf.getDataType());

                int[] r = new int[height];

                int[] c = new int[width];

                calcSupersamplingStepsArrays(r, c, step);

                if(buf.getDataType() == Buffer.TYPE_BYTE) {

                        byte[] data = new byte[buf.getBandCount()];

                        for (int row = 0; row < height; row++) {

                                for (int col = 0; col < width; col++) {

                                        buf.getElemByte(r[row], c[col], data);

                                        result.setElemByte(row, col, data);

                                }

                        }

                }

                if(buf.getDataType() == Buffer.TYPE_SHORT) {

                        short[] data = new short[buf.getBandCount()];

                        for (int row = 0; row < height; row++) {

                                for (int col = 0; col < width; col++) {

                                        buf.getElemShort(r[row], c[col], data);

                                        result.setElemShort(row, col, data);

                                }

                        }

                }

                if(buf.getDataType() == Buffer.TYPE_INT) {

                        int[] data = new int[buf.getBandCount()];

                        for (int row = 0; row < height; row++) {

                                for (int col = 0; col < width; col++) {

                                        buf.getElemInt(r[row], c[col], data);

                                        result.setElemInt(row, col, data);

                                }

                        }

                }

                if(buf.getDataType() == Buffer.TYPE_FLOAT) {

                        float[] data = new float[buf.getBandCount()];

                        for (int row = 0; row < height; row++) {

                                for (int col = 0; col < width; col++) {

                                        buf.getElemFloat(r[row], c[col], data);

                                        result.setElemFloat(row, col, data);

                                }

                        }

                }

                if(buf.getDataType() == Buffer.TYPE_DOUBLE) {

                        double[] data = new double[buf.getBandCount()];

                        for (int row = 0; row < height; row++) {

                                for (int col = 0; col < width; col++) {

                                        buf.getElemDouble(r[row], c[col], data);

                                        result.setElemDouble(row, col, data);

                                }

                        }

                }

                return result;

        }

        /**

         * Calcula los vectores de desplazamiento en pixels en X e Y cuando se supersamplea.

         * @param r Array de desplazamientos para las filas. Debe tener espacio reservado

         * @param c Array de desplazamientos para las columnas. Debe tener espacio reservado

         * cargados.

         */

        private void calcSupersamplingStepsArrays(int[] r, int[] c, double[] step) {

                double pos = step[1];

                for(int row = 0; row < r.length; row ++) {

                        r[row] = (int)(pos / step[3]);

                        pos ++;

                }

                pos = step[0];

                for(int col = 0; col < c.length; col ++) {

                        c[col] = (int)(pos / step[2]);

                        pos ++;

                }

        }

        /**

         * Sets the nodata value

         * @param noData

         */

        private void setNoDataValue(NoData noData) {

                if(noData == null)

                        return;

                switch (store.getDataType()[0]) {

                case Buffer.TYPE_BYTE:

                        byteNoData = noData.getValue().byteValue();

                        break;

                case Buffer.TYPE_SHORT:

                        shortNoData = noData.getValue().shortValue();

                        break;

                case Buffer.TYPE_INT:

                        intNoData = noData.getValue().intValue();

                        break;

                case Buffer.TYPE_FLOAT:

                        floatNoData = noData.getValue().floatValue();

                        break;

                case Buffer.TYPE_DOUBLE:

                        doubleNoData = ((NoData)noData).getValue().doubleValue();

                        break;

                }

        }

        /**

         * Builds a buffer using the specified number of bands and initialize it

         * @param nbands

         * @return

         */

        private Buffer buildBuffer(int nbands, int w, int h, int datatype) {

                Buffer bufResult = DefaultRasterManager.getInstance().createBuffer(datatype, w, h, nbands, true);

                for (int i = 0; i < bufResult.getBandCount(); i++) {

                        clearMaskBuffer(bufResult, i);

                }

                return bufResult;

        }

        /**

         * Sets a band to NODATA value 

         * @param bufResult

         * @param tileExtent

         * @param buf

         * @param ex

         * @param pixelSize

         */

        protected void clearMaskBuffer(Buffer buf, int nBand) {

                if(buf.getDataType() == Buffer.TYPE_BYTE) {

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

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

                                        buf.setElem(i, j, nBand, byteNoData);

                                }

                        }

                        return;

                }

                if(buf.getDataType() == Buffer.TYPE_SHORT) {

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

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

                                        buf.setElem(i, j, nBand, shortNoData);

                                }

                        }

                        return;

                }

                if(buf.getDataType() == Buffer.TYPE_INT) {

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

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

                                        buf.setElem(i, j, nBand, intNoData);

                                }

                        }

                        return;

                }

                if(buf.getDataType() == Buffer.TYPE_FLOAT) {

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

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

                                        buf.setElem(i, j, nBand, floatNoData);

                                }

                        }

                        return;

                }

                if(buf.getDataType() == Buffer.TYPE_DOUBLE) {

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

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

                                        buf.setElem(i, j, nBand, doubleNoData);

                                }

                        }

                        return;

                }

        }

}