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

import java.awt.geom.Point2D;

import org.cresques.cts.ICoordTrans;

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.raster.impl.DefaultRasterManager;

import org.gvsig.timesupport.Time;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.task.TaskStatus;

/**

 * Reprojects a RasterDataStore. 

 *

 * @author Nacho Brodin nachobrodin@gmail.com

 */

public class RasterRenderReprojection {

        private RasterDataStore      store                  = null;

        private ICoordTrans          coordTrans             = null;

        private ICoordTrans          invertedCoordTrans     = null;

        private NoData               noData                 = null;

        private int                  dataType               = Buffer.TYPE_BYTE;

        private TaskStatus           status                 = null;

        private int                  lastAlphaBandNumber    = 0;  

        public RasterRenderReprojection(RasterDataStore store, 

                        ICoordTrans coordTrans, 

                        TaskStatus status) {

                this.store = store;

                this.status = status;

                this.coordTrans = coordTrans;

                this.invertedCoordTrans = coordTrans.getInverted();

                dataType = store.getDataType()[0];

                noData = RasterLocator.getManager().getDataStructFactory().createDefaultNoData(

                                store.getBandCount(), dataType);

        }

        public Buffer warp(Extent bbox, 

                        int w, 

                        int h, 

                        Time time,

                        int[] renderBands,

                        Transparency lastTransparency) throws QueryException, ProcessInterruptedException {

                Point2D ul = new Point2D.Double(bbox.getULX(), bbox.getULY());

                Point2D lr = new Point2D.Double(bbox.getLRX(), bbox.getLRY());

                ul = invertedCoordTrans.convert(ul, ul);

                lr = invertedCoordTrans.convert(lr, lr);

                if(ul.getX() < store.getExtent().getULX())

                        ul.setLocation(store.getExtent().getULX(), ul.getY());

                if(ul.getY() > store.getExtent().getULY())

                        ul.setLocation(ul.getX(), store.getExtent().getULY());

                if(lr.getX() > store.getExtent().getLRX())

                        lr.setLocation(store.getExtent().getLRX(), lr.getY());

                if(lr.getY() < store.getExtent().getLRY())

                        lr.setLocation(lr.getX(), store.getExtent().getLRY());

                Extent newBbox = RasterLocator.getManager().getDataStructFactory().createExtent(ul, lr);

                double[] size = getSize(bbox, newBbox, w, h);

                int newW = (int)size[0];

                int newH = (int)size[1];

                double cellSize = size[2];

                BufferParam bufParam = RasterLocator.getManager().getBufferFactory().createBufferParams(

                                store.getDataType()[0], newW, newH, 3, true);

                Buffer bufReprojected = null;

                try {

                        bufReprojected = RasterLocator.getManager().getBufferFactory().createBuffer(bufParam);

                } catch (LocatorException e) {

                        throw new QueryException("Error creating the buffer", e);

                } catch (BufferCreationException e) {

                        throw new QueryException("Error creating the buffer", e);

                }

                RasterQuery query = DefaultRasterManager.getInstance().createQuery();

                query.setTaskStatus(status);

                query.setTime(time);

                query.setSupersamplingOption(false); // Desactivamos el supersampleo en la carga del buffer.

                query.forceARGBRequest();

                query.setAreaOfInterest(newBbox, newW, newH);

                query.setDrawableBands(renderBands);

                Buffer sourceBuffer = store.query(query);

                query.setSupersamplingOption(true);

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

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

                                Point2D p = transformPoint(newBbox, col, row, cellSize, coordTrans);

                                writePixel(dataType, sourceBuffer, bufReprojected, p, col, row, noData);

                        }

                        //percent = (int)((row * 100) / buf.getHeight());

                }

                bufReprojected.setDataExtent(bbox.toRectangle2D());

                return bufReprojected;

        }

        public int getAlphaBandNumber() {

                return lastAlphaBandNumber;

        }

        /**

         * Transforms the upper left coordinate of a pixel using the transformation 

         * which is passed by parameter

         * @param p

         * @param newBbox

         * @param col

         * @param row

         * @param cellSize

         * @param t

         */

        private Point2D transformPoint(Extent newBbox, int col, int row, double cellSize, ICoordTrans t) {

                Point2D p = new Point2D.Double(

                                newBbox.getULX() + (col * cellSize), 

                                newBbox.getULY() - (row * cellSize));

                p = t.convert(p, p);

                p = store.worldToRaster(p);

                return p;

        }

        /**

         * Writes one pixel in the destination buffer

         * @param type

         * @param sourceBuffer

         * @param buf

         * @param p

         * @param col

         * @param row

         */

        private void writePixel(int type, Buffer sourceBuffer, Buffer buf, Point2D p, int col, int row, NoData nd) {

                if(type == Buffer.TYPE_BYTE) {

                        if(p.getX() > 0 && p.getX() < sourceBuffer.getWidth() && p.getY() > 0 && p.getY() < sourceBuffer.getHeight())

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

                                        buf.setElem(row, col, iBand, sourceBuffer.getElemByte((int)p.getY(), (int)p.getX(), iBand));

                        else

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

                                        buf.setElem(row, col, iBand, nd.getValue().byteValue());

                } else if(type == Buffer.TYPE_DOUBLE) {

                        if(p.getX() > 0 && p.getX() < sourceBuffer.getWidth() && p.getY() > 0 && p.getY() < sourceBuffer.getHeight())

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

                                        buf.setElem(row, col, iBand, sourceBuffer.getElemDouble((int)p.getY(), (int)p.getX(), iBand));

                        else

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

                                        buf.setElem(row, col, iBand, nd.getValue().doubleValue());

                } else if(type == Buffer.TYPE_FLOAT) {

                        if(p.getX() > 0 && p.getX() < sourceBuffer.getWidth() && p.getY() > 0 && p.getY() < sourceBuffer.getHeight())

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

                                        buf.setElem(row, col, iBand, sourceBuffer.getElemFloat((int)p.getY(), (int)p.getX(), iBand));

                        else

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

                                        buf.setElem(row, col, iBand, nd.getValue().floatValue());

                } else if(type == Buffer.TYPE_SHORT) {

                        if(p.getX() > 0 && p.getX() < sourceBuffer.getWidth() && p.getY() > 0 && p.getY() < sourceBuffer.getHeight())

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

                                        buf.setElem(row, col, iBand, sourceBuffer.getElemShort((int)p.getY(), (int)p.getX(), iBand));

                        else

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

                                        buf.setElem(row, col, iBand, nd.getValue().shortValue());

                } else if(type == Buffer.TYPE_INT) {

                        if(p.getX() > 0 && p.getX() < sourceBuffer.getWidth() && p.getY() > 0 && p.getY() < sourceBuffer.getHeight())

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

                                        buf.setElem(row, col, iBand, sourceBuffer.getElemInt((int)p.getY(), (int)p.getX(), iBand));

                        else

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

                                        buf.setElem(row, col, iBand, nd.getValue().intValue());

                } 

        }

        /**

         * Gets the size of the new image

         * @param bbox

         * @param newBbox

         * @return

         */

        private double[] getSize(Extent bbox, Extent newBbox, int p1x, int p1y) {

        //      d1x                 d2x

                //   ---------           ---------

                //   |  p1x  |           |  p2x  |

                //d1y|p1y    |        d2y|p2y    |

                //   |       |           |       |

                //   ---------           ---------

                double sumSideOldBBox = bbox.width() + bbox.height();

                double sumSideNewBBox = newBbox.width() + newBbox.height();

                double d1x = (bbox.width() * 100) / sumSideOldBBox; 

                double d1y = (bbox.height() * 100) / sumSideOldBBox;

                double d2x = (newBbox.width() * 100) / sumSideNewBBox;

                double d2y = (newBbox.height() * 100) / sumSideNewBBox;

                double p2y = (p1y * d2y) / d1y;

                double p2x = (p1x * d2x) / d1x;

                double newCellSize = newBbox.width() / p2x;

                return new double[]{Math.round(p2x), Math.round(p2y), newCellSize};

        }

}