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

import java.awt.geom.Rectangle2D;

import java.util.ArrayList;

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

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

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

import org.gvsig.raster.cache.tile.Tile;

import org.gvsig.raster.impl.DefaultRasterManager;

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

/** 

 * Buffer composed by a list of tiles and its extents. 

 * It will expose a method getWindow to read a window of data from the tile list.

 * The list of tiles have to make a square.

 * 

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

 */

public class MemoryMatrixBuffer {

        private Buffer[]         bufferList  = null;

        private Buffer[]         transpList  = null;

        private int              nRows       = 0;

        private int              nCols       = 0;        

        private Extent           bbox        = null;

        private ArrayList<Tile>  tileList    = null;

        /**

         * Constructor using an array of tiles. It will compute the number

         * of rows and columns and the complete bounding box

         * @param tileList

         */

        public MemoryMatrixBuffer(Tile[] tileList) {

                this.tileList = new ArrayList<Tile>();

                bufferList = new Buffer[tileList.length];

                if(tileList[0].getData().length > 1 && tileList[0].getData()[1] instanceof Buffer)

                        transpList = new Buffer[tileList.length];

                for (int i = 0; i < tileList.length; i++) {

                        this.tileList.add(tileList[i]);

                        bufferList[i] = (Buffer)tileList[i].getData()[0];

                        if(tileList[i].getData().length > 1 && tileList[i].getData()[1] instanceof Buffer)

                                transpList[i] = (Buffer)tileList[i].getData()[1];

                        //extentList[i] = tileList[i].getExtent();

                        //pxLayerList[i] = tileList[i].getCoordsPx();

                }

                int minRow = Integer.MAX_VALUE;

                int maxRow = Integer.MIN_VALUE;

                int minCol = Integer.MAX_VALUE;

                int maxCol = Integer.MIN_VALUE;

                for (int i = 0; i < tileList.length; i++) {

                        if(tileList[i].getRow() > maxRow)

                                maxRow = tileList[i].getRow();

                        if(tileList[i].getCol() > maxCol)

                                maxCol = tileList[i].getCol();

                        if(tileList[i].getRow() < minRow)

                                minRow = tileList[i].getRow();

                        if(tileList[i].getCol() < minCol)

                                minCol = tileList[i].getCol();

                }

                nRows = maxRow - minRow + 1;

                nCols = maxCol - minCol + 1;

                bbox = calculateBBox();

        }

        /**

         * Constructor using an ArrayList of tiles. It will compute the number

         * of rows and columns and the complete bounding box

         * @param tileList

         */

        public MemoryMatrixBuffer(ArrayList<Tile> tileList) {

                this.tileList = tileList;

                bufferList = new Buffer[tileList.size()];

                if(tileList.get(0).getData().length > 1 && tileList.get(0).getData()[1] instanceof Buffer)

                        transpList = new Buffer[tileList.size()];

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

                        bufferList[i] = (Buffer)tileList.get(i).getData()[0];

                        if(tileList.get(i).getData().length > 1 && tileList.get(i).getData()[1] instanceof Buffer)

                                transpList[i] = (Buffer)tileList.get(i).getData()[1];

                }

                int minRow = Integer.MAX_VALUE;

                int maxRow = Integer.MIN_VALUE;

                int minCol = Integer.MAX_VALUE;

                int maxCol = Integer.MIN_VALUE;

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

                        if(tileList.get(i).getRow() > maxRow)

                                maxRow = tileList.get(i).getRow();

                        if(tileList.get(i).getCol() > maxCol)

                                maxCol = tileList.get(i).getCol();

                        if(tileList.get(i).getRow() < minRow)

                                minRow = tileList.get(i).getRow();

                        if(tileList.get(i).getCol() < minCol)

                                minCol = tileList.get(i).getCol();

                }

                nRows = maxRow - minRow + 1;

                nCols = maxCol - minCol + 1;

                bbox = calculateBBox();

        }

        /**

         * Builds the complete bounding box of the tile list

         * @return

         */

        private Extent calculateBBox() { 

                double minX = Double.MAX_VALUE;

                double minY = Double.MAX_VALUE;

                double maxX = 0;

                double maxY = 0;

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

                        Rectangle2D e = tileList.get(i).getExtent();

                        if(e.getX() < minX)

                                minX = e.getX();

                        if((e.getY() - e.getHeight()) < minY)

                                minY = (e.getY() - e.getHeight());

                        if((e.getX() + e.getWidth()) > maxX)

                                maxX = (e.getX() + e.getWidth());

                        if(e.getY() > maxY)

                                maxY = e.getY();

                }

                return new ExtentImpl(minX, minY, maxX, maxY);

        }

        /**

         * Gets a window from tiles

         * @param ext

         * @param buf

         * @return

         */

        public Buffer getWindow(Rectangle2D r, Buffer buf) {

                int shiftRow = 0;

                int shiftCol = 0;

                int posRow = 0;

                int posCol = 0;

                Rectangle2D[] rTileShiftList = new Rectangle2D[bufferList.length];

                Rectangle2D[] rBufferShiftList = new Rectangle2D[bufferList.length];

                int[] colsWidth = new int[nCols];

                int[] rowsHeight = new int[nRows];

                for (int i = 0; i < bufferList.length; i++) {

                        Rectangle2D pxLayer = tileList.get(i).getCoordsPx();

                        int initPxTileX = (int)Math.max(pxLayer.getMinX(), r.getMinX()) - (tileList.get(i).getCol() * tileList.get(i).getWidthPx()); 

                        int initPxTileY = (int)Math.max(pxLayer.getMinY(), r.getMinY()) - (tileList.get(i).getRow() * tileList.get(i).getHeightPx());

                        int widthPxTile = (int)Math.min(pxLayer.getMaxX(), r.getMaxX()) - (tileList.get(i).getCol() * tileList.get(i).getWidthPx()) - initPxTileX;

                        int heightPxTile = (int)Math.min(pxLayer.getMaxY(), r.getMaxY()) - (tileList.get(i).getRow() * tileList.get(i).getHeightPx()) - initPxTileY;

                        rTileShiftList[i] = new Rectangle2D.Double(initPxTileX, initPxTileY, widthPxTile, heightPxTile);

                        if(i == 0) {

                                shiftCol = tileList.get(i).getCol();

                                shiftRow = tileList.get(i).getRow();

                        }

                        posCol = tileList.get(i).getCol() - shiftCol;

                        posRow = tileList.get(i).getRow() - shiftRow;

                        if(posCol == 0)

                                colsWidth[posCol] = widthPxTile;

                        else

                                colsWidth[posCol] = widthPxTile + colsWidth[posCol - 1];

                        if(posRow == 0)

                                rowsHeight[posRow] = heightPxTile;

                        else

                                rowsHeight[posRow] = heightPxTile + rowsHeight[posRow - 1];

                        //shiftX = initPxTileX < shiftX ? initPxTileX : shiftX;

                        //shiftY = initPxTileY < shiftY ? initPxTileY : shiftY;

                }

                int initPxBufferX = 0; 

                int initPxBufferY = 0;

                int widthPxBuffer = 0;

                int heightPxBuffer = 0;

                for (int i = 0; i < bufferList.length; i++) {

                        posCol = tileList.get(i).getCol() - shiftCol;

                        posRow = tileList.get(i).getRow() - shiftRow;

                        if(posCol == 0) {

                                initPxBufferX = 0;

                                widthPxBuffer = colsWidth[0];

                        } else {

                                initPxBufferX = colsWidth[posCol - 1];

                                widthPxBuffer = colsWidth[posCol] - initPxBufferX;

                        }

                        if(posRow == 0) {

                                initPxBufferY = 0;

                                heightPxBuffer = rowsHeight[0];

                        } else {

                                initPxBufferY = rowsHeight[posRow - 1];

                                heightPxBuffer = rowsHeight[posRow] - initPxBufferY;

                        }

                        rBufferShiftList[i] = new Rectangle2D.Double(initPxBufferX, initPxBufferY, widthPxBuffer, heightPxBuffer);

                }                        

                for (int i = 0; i < bufferList.length; i++) {

                        loadBuffer(buf, 

                                        bufferList[i],

                                        rTileShiftList[i], 

                                        (int)rBufferShiftList[i].getX(), 

                                        (int)rBufferShiftList[i].getY(), 

                                        false);

                }

                return buf;

        }

        /**

         * Gets a window from tiles

         * @param ext

         * @param buf

         * @return

         */

        public Buffer getWindow(Extent ext, Buffer buf) {

                return getWindow(ext, buf, false);

        }

        /**

         * Gets a window from tiles

         * @param ext

         * @param buf

         * @return

         */

        public Buffer getWindow(Extent ext, Buffer buf, boolean alpha) {

                //Crea un buffer a escala de la lista de tiles pero q ser? el buffer final

                /*int bands = buf.getBandCount();

                if(transpList != null && !alpha)

                        bands ++;*/

                Buffer sourceWithoutResampling = createBufferWithoutResampling(ext, buf.getDataType(), buf.getBandCount());

                for (int i = 0; i < bufferList.length; i++) {

                        //1-Calcular las coordenadas pixel del tile de entrada

                        int[] points = getClipPoints(tileList.get(i).getExtent(), bufferList[i], ext);

                        //2-Ajustar peti?n al extent del tile

                        Extent adjustedRequestExtent = getAdjustedExtent(tileList.get(i).getExtent(), ext);

                        if((points[0] == 0 && points[1] == 0) || (points[2] == 0 && points[3] == 0))

                                continue;

                        //3-Calcular coordenada pixel de inicio del buffer

                        double wcX1 = Math.abs(adjustedRequestExtent.getMin().getX() - ext.getMin().getX());

                        double wcY1 = Math.abs(ext.getMax().getY() - adjustedRequestExtent.getMax().getY());

                        int initXPxBuf = (int)Math.ceil((wcX1 * (sourceWithoutResampling.getWidth())) / ext.width());

                        int initYPxBuf = (int)Math.ceil((wcY1 * (sourceWithoutResampling.getHeight())) / ext.height());

                        //4-Copiar recorte al buffer

                        Rectangle2D rTile = new Rectangle2D.Double(points[0], points[2], (points[1] - points[0]) + 1, (points[3] - points[2]) + 1);

                        if(alpha)

                                loadBuffer(sourceWithoutResampling, transpList[i], rTile, initXPxBuf, initYPxBuf, true);

                        else

                                loadBuffer(sourceWithoutResampling, bufferList[i], rTile, initXPxBuf, initYPxBuf, false);

                }

                //Devuelve el buffer pero reescalandolo antes al tama?o en pixeles de la petici?n

                try {

                        return sourceWithoutResampling.getAdjustedWindow(buf.getWidth(), buf.getHeight(), Buffer.INTERPOLATION_NearestNeighbour);

                } catch (ProcessInterruptedException e) {

                }

                return buf;

        }

        /**

         * Builds a buffer in the same resolution as the list of tiles. When the operation

         * ends this buffer should be resampled.

         * @return

         */

        private Buffer createBufferWithoutResampling(Extent ext, int dataType, int bands) {

                int w = 0;

                int h = 0;

                for (int i = 0; i < bufferList.length; i++) {

                        int[] points = getClipPoints(tileList.get(i).getExtent(), bufferList[i], ext);

                        w += (points[1] - points[0]) + 1;

                        h += (points[3] - points[2]) + 1;

                }

                //Si todos los tiles de la lista no cubren completamente el buffer pedido habr? que calcular cuantos 

                //pixeles quedan fuera para a?adirlos al nuevo buffer que estamos construyendo

                double mtsPx = tileList.get(0).getExtent().getWidth() / bufferList[0].getWidth();

                double distanceUp = (ext.getMax().getY() - bbox.getMax().getY()) <= 0 ? 0 : (ext.getMax().getY() - bbox.getMax().getY());

                double distanceDown = (bbox.getMin().getY() - ext.getMin().getY()) <= 0 ? 0 : (bbox.getMin().getY() - ext.getMin().getY());

                double distanceLeft = (bbox.getMin().getX() - ext.getMin().getX()) <= 0 ? 0 : (bbox.getMin().getX() - ext.getMin().getX());

                double distanceRight = (ext.getMax().getX() - bbox.getMax().getX()) <= 0 ? 0 : (ext.getMax().getX() - bbox.getMax().getX());

                int distanceUpPx = (int)(distanceUp / mtsPx);

                int distanceDownPx = (int)(distanceDown / mtsPx);

                int distanceLeftPx = (int)(distanceLeft / mtsPx);

                int distanceRightPx = (int)(distanceRight / mtsPx);

                return DefaultRasterManager.getInstance().createBuffer(dataType, 

                                (int)((w / nCols) + distanceLeftPx + distanceRightPx), 

                                (int)((h / nRows) + distanceUpPx + distanceDownPx), 

                                bands, 

                                true);

        }

        /**

         * Gets the point list to clip the tile

         * @param r Bounding box of the tile

         * @param b Buffer of the tile

         * @param extentRequest 

         * @return

         */

        private int[] getClipPoints(Rectangle2D r, Buffer b, Extent extentRequest) {

                double widthWCTile = r.getWidth();

                double widthPXTile = b.getWidth();

                double heightWCTile = r.getHeight();

                double heightPXTile = b.getHeight();

                //1-Ajustar peti?n al extent del tile

                Extent adjustedRequestExtent = getAdjustedExtent(r, extentRequest);

                //2-Obtener el punto inicial y final del recorte del tile en pixeles

                double wcX1 = adjustedRequestExtent.getMin().getX() - r.getX();

                double wcX2 = adjustedRequestExtent.getMax().getX() - r.getX();

                double wcY1 = r.getY() - adjustedRequestExtent.getMax().getY();

                double wcY2 = r.getY() - adjustedRequestExtent.getMin().getY();

                int initXPxTile = (int)((wcX1 * widthPXTile) / widthWCTile);

                int endXPxTile = (int)((wcX2 * widthPXTile) / widthWCTile) - 1;

                int initYPxTile = (int)((wcY1 * heightPXTile) / heightWCTile);

                int endYPxTile = (int)((wcY2 * heightPXTile) / heightWCTile) - 1;

                return new int[]{initXPxTile, 

                                endXPxTile >= widthPXTile ? endXPxTile - 1 : endXPxTile, 

                                initYPxTile, 

                                endYPxTile >= heightPXTile ? endYPxTile - 1 : endYPxTile};

        }

        /**

         * Adjust the request to the tile bounding box

         * @param tileExtent

         * @param extentRequest

         * @return

         */

        private Extent getAdjustedExtent(Rectangle2D tileExtent, Extent extentRequest) {

                double x1 = Math.max(extentRequest.getMin().getX(), tileExtent.getX());

                double y1 = Math.min(extentRequest.getMax().getY(), tileExtent.getY());

                double x2 = Math.min(extentRequest.getMax().getX(), (tileExtent.getX() + tileExtent.getWidth()));

                double y2 = Math.max(extentRequest.getMin().getY(), (tileExtent.getY() - tileExtent.getHeight()));

                return new ExtentImpl(x1, y1, x2, y2); 

        }

        /**

         * Write data in the source buffer taking into account the view shift

         * @param sourceBuf

         * @param tileBuf

         * @param rTile

         * @param initXPxBuf

         * @param initYPxBuf

         */

        private void loadBuffer(Buffer sourceBuf, Buffer tileBuf, Rectangle2D rTile, int initXPxBuf, int initYPxBuf, boolean alpha) {

                int r = initXPxBuf;

                int c = initYPxBuf;

                //if(!alpha) {

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

                                for (int band = 0; band < tileBuf.getBandCount(); band++) {

                                        r = initYPxBuf;

                                        for (int row = (int)rTile.getMinY(); (row < (int)rTile.getMaxY() && r < sourceBuf.getHeight()); row++) {

                                                c = initXPxBuf;

                                                for (int col = (int)rTile.getMinX(); (col < (int)rTile.getMaxX() && c < sourceBuf.getWidth()); col++) {

                                                        sourceBuf.setElem(r, c, band, tileBuf.getElemByte(row, col, band));

                                                        c++;

                                                }

                                                r++;

                                        }

                                }

                        }

                /*} else {

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

                                r = initYPxBuf;

                                for (int row = (int)rTile.getMinY(); row < (int)rTile.getMaxY(); row++) {

                                        c = initXPxBuf;

                                        for (int col = (int)rTile.getMinX(); col < (int)rTile.getMaxX(); col++) {

                                                sourceBuf.setElem(r, c, 0, tileBuf.getElemByte(row, col, 0));

                                                c++;

                                        }

                                        r++;

                                }

                        }

                }*/

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

                        for (int band = 0; band < tileBuf.getBandCount(); band++) {

                                r = initYPxBuf;

                                for (int row = (int)rTile.getMinY(); (row < (int)rTile.getMaxY() && r < sourceBuf.getHeight()); row++) {

                                        c = initXPxBuf;

                                        for (int col = (int)rTile.getMinX(); (col < (int)rTile.getMaxX() && c < sourceBuf.getWidth()); col++) {

                                                sourceBuf.setElem(r, c, band, tileBuf.getElemShort(row, col, band));

                                                c++;

                                        }

                                        r++;

                                }

                        }

                }

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

                        for (int band = 0; band < tileBuf.getBandCount(); band++) {

                                r = initYPxBuf;

                                for (int row = (int)rTile.getMinY(); (row < (int)rTile.getMaxY() && r < sourceBuf.getHeight()); row++) {

                                        c = initXPxBuf;

                                        for (int col = (int)rTile.getMinX(); (col < (int)rTile.getMaxX() && c < sourceBuf.getWidth()); col++) {

                                                sourceBuf.setElem(r, c, band, tileBuf.getElemInt(row, col, band));

                                                c++;

                                        }

                                        r++;

                                }

                        }

                }

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

                        for (int band = 0; band < tileBuf.getBandCount(); band++) {

                                r = initYPxBuf;

                                for (int row = (int)rTile.getMinY(); (row < (int)rTile.getMaxY() && r < sourceBuf.getHeight()); row++) {

                                        c = initXPxBuf;

                                        for (int col = (int)rTile.getMinX(); (col < (int)rTile.getMaxX() && c < sourceBuf.getWidth()); col++) {

                                                sourceBuf.setElem(r, c, band, tileBuf.getElemFloat(row, col, band));

                                                c++;

                                        }

                                        r++;

                                }

                        }

                }

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

                        for (int band = 0; band < tileBuf.getBandCount(); band++) {

                                r = initYPxBuf;

                                for (int row = (int)rTile.getMinY(); (row < (int)rTile.getMaxY() && r < sourceBuf.getHeight()); row++) {

                                        c = initXPxBuf;

                                        for (int col = (int)rTile.getMinX(); (col < (int)rTile.getMaxX() && c < sourceBuf.getWidth()); col++) {

                                                sourceBuf.setElem(r, c, band, tileBuf.getElemDouble(row, col, band));

                                                c++;

                                        }

                                        r++;

                                }

                        }

                }

        }

        /*private double clip(double value) {

                return math.clipDecimals(value, 5);

        }

        private double round(double value) {

                double a = (value - (int)value);

                return (a > 0.95 || a < 0.05) ? Math.round(value) : value;

        }*/

}