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 java.util.List;

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 MemoryTileMatrixBuffer {

        //private Logger           log          = LoggerFactory.getLogger(MemoryMatrixBuffer.class);

        private Buffer[]         bufferList   = null;

        private int              nRows        = 0;

        private int              nCols        = 0;

        @SuppressWarnings("unused")

        private Extent           bbox         = null;

        private List<Tile>       tileList     = null;

        private int              dataType     = Buffer.TYPE_UNDEFINED;

        public class Position {

                int col = 0;

                int row = 0;

        }

        /**

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

         * of rows and columns and the complete bounding box

         * @param tileList

         */

        public MemoryTileMatrixBuffer(Tile[] tileList) {

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

                bufferList = 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(bufferList[i] != null)

                                dataType = bufferList[i].getDataType();

                        //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 MemoryTileMatrixBuffer(List<Tile> tileList) {

                this.tileList = tileList;

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

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

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

                        if(bufferList[i] != null)

                                dataType = bufferList[i].getDataType();

                }

                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, int w, int h, int bandCount) {

                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);

                }

                Buffer buf = DefaultRasterManager.getInstance().createBuffer(dataType, w, h, bandCount, true);

                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 requestExtent

         * @param buf

         * @return

         */

        public Buffer getWindow(Extent requestExtent, int w, int h, int bandCount) {

                if(tileList.size() <= 0)

                        return null;

                Buffer sourceWithoutResampling = createBufferWithoutResampling(requestExtent, tileList.get(0).getExtent(), bufferList[0], w, h, bandCount);

                double wcX1 = -1;

                double wcY1 = -1;

                int initXPxBuf = 0;

                int initYPxBuf = 0;

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

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

                        Rectangle2D rTile = getClipPoints(tileList.get(i).getExtent(), bufferList[i], requestExtent);

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

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

                        if(        (rTile.getX() == 0 && rTile.getWidth() == 0) ||

                                        (rTile.getY() == 0 && rTile.getHeight() == 0))

                                continue;

                        //3-Calcular coordenada pixel de inicio del buffer

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

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

                        initXPxBuf = (int)Math.floor((wcX1 * (sourceWithoutResampling.getWidth())) / requestExtent.width());

                        initYPxBuf = (int)Math.floor((wcY1 * (sourceWithoutResampling.getHeight())) / requestExtent.height());

                        //4-Copiar recorte al buffer

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

                }

                /*try {

                        save(sourceWithoutResampling, true, requestExtent, null);

                } catch (NotSupportedExtensionException e) {

                        log.debug("Error saving in MemoryMatrixBuffer", e);

                } catch (RasterDriverException e) {

                        log.debug("Error saving in MemoryMatrixBuffer", e);

                } catch (ProcessInterruptedException e) {

                        log.debug("Error saving in MemoryMatrixBuffer", e);

                } catch (IOException e) {

                        log.debug("Error saving in MemoryMatrixBuffer", e);

                }*/

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

                try {

                        Buffer result = null;

                        result = sourceWithoutResampling.getAdjustedWindow(w, h, Buffer.INTERPOLATION_NearestNeighbour);

                        if(result != sourceWithoutResampling)

                                sourceWithoutResampling.dispose();

                        return result;

                } catch (ProcessInterruptedException e) {

                }

                return null;

        }

        /**

         * Gets the point list to clip the tile

         * @param extTile Bounding box of the tile

         * @param b Buffer of the tile

         * @param extentRequest

         * @return

         */

        private Rectangle2D getClipPoints(Rectangle2D extTile, Buffer b, Extent extentRequest) {

                double widthWCTile = extTile.getWidth();

                double widthPXTile = b.getWidth();

                double heightWCTile = extTile.getHeight();

                double heightPXTile = b.getHeight();

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

                Extent adjustedRequestExtent = getAdjustedExtent(extTile, extentRequest);

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

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

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

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

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

                int initXPxTile = (int)Math.floor((wcX1 * widthPXTile) / widthWCTile);

                int endXPxTile = (int)Math.ceil((wcX2 * widthPXTile) / widthWCTile);

                int initYPxTile = (int)Math.floor((wcY1 * heightPXTile) / heightWCTile);

                int endYPxTile = (int)Math.ceil((wcY2 * heightPXTile) / heightWCTile);

                endXPxTile = endXPxTile >= widthPXTile ? (int)(widthPXTile - 1) : endXPxTile;

                endYPxTile = endYPxTile >= heightPXTile ? (int)(heightPXTile - 1) : endYPxTile;

                return new Rectangle2D.Double(initXPxTile,

                                initYPxTile,

                                Math.abs((endXPxTile - initXPxTile) + 1),

                                Math.abs((endYPxTile - initYPxTile) + 1));

        }

        /**

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

         * @param dstBuf

         * @param tileBuf

         * @param rTile

         * @param initXPxBuf

         * @param initYPxBuf

         */

        private void loadBuffer(Buffer dstBuf, 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 < dstBuf.getHeight()); row++) {

                                                c = initXPxBuf;

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

                                                        dstBuf.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 < dstBuf.getHeight()); row++) {

                                        c = initXPxBuf;

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

                                                dstBuf.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 < dstBuf.getHeight()); row++) {

                                        c = initXPxBuf;

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

                                                dstBuf.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 < dstBuf.getHeight()); row++) {

                                        c = initXPxBuf;

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

                                                dstBuf.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 < dstBuf.getHeight()); row++) {

                                        c = initXPxBuf;

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

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

                                                c++;

                                        }

                                        r++;

                                }

                        }

                }

        }

//        private void save(Buffer bufResult,

//                        boolean alphaBand,

//                        Extent tileExtent,

//                        ColorInterpretation colorInterpretation) throws NotSupportedExtensionException, RasterDriverException, ProcessInterruptedException, IOException {

//                //Escritura en disco del tile

//                RasterManager rManager = RasterLocator.getManager();

//                DataServerWriter dataWriter = RasterLocator.getManager().createDataServerWriter();

//                dataWriter.setBuffer(bufResult, -1);

//                Params params = rManager.createWriter("_.tif").getParams();

//                double pixelSize = (tileExtent.width() / bufResult.getWidth());

//                AffineTransform affineTransform = new AffineTransform(pixelSize, 0, 0, -pixelSize,

//                                tileExtent.getULX(),

//                                tileExtent.getULY());

//                RasterWriter rw = rManager.createWriter(dataWriter, "/tmp/prueba.tif",

//                                bufResult.getBandCount(), affineTransform, bufResult.getWidth(),

//                                bufResult.getHeight(), bufResult.getDataType(), params, null);

//

//                if(colorInterpretation != null) {

//                        String[] values = colorInterpretation.getValues();

//                        if(alphaBand) {

//                                String[] newValues = values;

//                                boolean exists = false;

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

//                                        if(values[i] != null && values[i].compareTo("Alpha") == 0)

//                                                exists = true;

//                                }

//                                if(!exists) {

//                                        newValues = new String[values.length + 1];

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

//                                                newValues[i] = values[i];

//                                        }

//                                        newValues[newValues.length - 1] = "Alpha";

//                                }

//                                rw.setColorBandsInterpretation(newValues);

//                        }

//

//                } else {

//                        if(alphaBand) {

//                                String[] ci = new String[bufResult.getBandCount()];

//                                if(bufResult.getBandCount() == 4) {

//                                        ci[0] = "Red";

//                                        ci[1] = "Green";

//                                        ci[2] = "Blue";

//                                        ci[3] = "Alpha";

//                                } else {

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

//                                                ci[i] = "Gray";

//                                        }

//                                }

//                                rw.setColorBandsInterpretation(ci);

//                        }

//                }

//                rw.dataWrite();

//                rw.writeClose();

//        }

        /**

         * 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 extOrigin,

                        Rectangle2D extTile,

                        Buffer bufTile,

                        int originWidth,

                        int originHeight,

                        int bandCount) {

                double psOrigin = extOrigin.width() / originWidth;

                double psTile = extTile.getWidth() / bufTile.getWidth();

                double rel = psTile / psOrigin;

                int w = (int)Math.floor(originWidth / rel);

                int h = (int)Math.floor(originHeight / rel);

                return DefaultRasterManager.getInstance().createBuffer(dataType, w, h, bandCount, true);

        }

        /**

         * 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);

        }

        /*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;

        }*/

}