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.mosaic.io.downloader;

import java.io.IOException;

import java.util.ArrayList;

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.coverage.store.parameter.RasterDataParameters;

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

import org.gvsig.fmap.dal.coverage.util.RasterUtils;

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

import org.gvsig.raster.cache.tile.exception.TileGettingException;

import org.gvsig.raster.cache.tile.provider.CacheStruct;

import org.gvsig.raster.impl.DefaultRasterManager;

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

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

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

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

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

import org.gvsig.raster.impl.provider.tile.BaseTileDownloader;

import org.gvsig.raster.mosaic.io.MosaicDataParameters;

/** 

 * Tile getter 

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

 */

public class TileDownloaderForMosaics extends BaseTileDownloader {

        private CacheStruct                      struct                 = null;

        private RasterUtils                      util                   = RasterLocator.getManager().getRasterUtils();

        private String                           extension              = null;

        private ArrayList<RasterProvider>        provList               = null;

        private int                              overlapMethod          = MosaicDataParameters.FIRST;

        private int                              colorCorrectionMethod  = MosaicDataParameters.NONE;

        private TileFusion                       tileFusion             = null;

        public TileDownloaderForMosaics(DefaultRasterProvider prov, 

                        ArrayList<RasterProvider> provList, 

                        CacheStruct struct,

                        int tilesize,

                        String extension,

                        int overlapMethod,

                        int colorCorrectionMethod) {

                super(prov, tilesize, tilesize);

                this.provList = provList;

                this.struct = struct;

                this.extension = extension;

                this.tileFusion = new TileFusion(overlapMethod, colorCorrectionMethod);

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.cache.tile.provider.Downloader#getTile(org.gvsig.raster.cache.tile.Tile)

         */

        public synchronized Tile downloadTile(Tile tile) throws TileGettingException {

                try {

                        Extent tileExtent = new ExtentImpl(tile.getUl(), tile.getLr());

                        double pixelSize = struct.getPixelSizeByLevel(tile.getLevel());

                        Buffer bufResult = null;

                        boolean alphaBand = false;

                        ArrayList<Buffer> listBuffers = new ArrayList<Buffer>();

                        ColorInterpretation ci = null;

                        //Iterates the list of providers clipping the selected extent

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

                                RasterProvider p = provList.get(i);

                                if(!p.getDataParameters().isVisible())

                                        continue;

                                ci = p.getColorInterpretation();

                                Buffer bufPartialResult = clipTileFromProvider((DefaultRasterProvider)p, tile);

                                if(bufPartialResult != null) {

                                        if(p.getDataType()[0] == Buffer.TYPE_BYTE && bufPartialResult.getBandCount() > p.getBandCount()) {

                                                alphaBand = true; //If one result has alpha band then the alpha band flag is on

                                        }

                                        listBuffers.add(bufPartialResult);

                                } 

                        }

                        if(listBuffers.size() == 0)

                                alphaBand = true;

                        //The list of clips is joined in only one tile

                        bufResult = tileFusion.joinTiles(listBuffers, tile.getWidthPx(), tile.getHeightPx(), alphaBand ? 3 : -1);

                        saveTile(bufResult, pixelSize, extension, 

                                        alphaBand, tile.getFile().getAbsolutePath(), tileExtent, ci);

                        //Si borramos el rmf no se puede leer la etiqueta Alpha. En caso de que se modifique jgdal para

                        //poder guardar esta etiqueta deberiamos borrar el rmf para ahorrar ficheros

                        //File rmf = new File(tile.getFile().getAbsolutePath() + ".rmf");

                        //if(rmf.exists())

                                //rmf.delete();

                } catch (ProcessInterruptedException e) {

                } catch (RasterDriverException e) {

                        throw new TileGettingException(e);

                } catch (NotSupportedExtensionException e) {

                        throw new TileGettingException(e);

                } catch (IOException e) {

                        throw new TileGettingException(e);

                }

                readTileFromDisk(tile);

                return tile;

        }

        private Buffer clipTileFromProvider(DefaultRasterProvider p, Tile tile) throws RasterDriverException {

                Extent tileExtent = new ExtentImpl(tile.getUl(), tile.getLr());

                //Escribe todas las bandas a disco

                BandList newBandList = new BandListImpl(p.getURI(), p.getBandCount(), p.getDataType()[0]);

                Buffer bufResult = null;

                double pixelSize = struct.getPixelSizeByLevel(tile.getLevel());

                try {

                        Extent ex = util.intersection(p.getExtent(), tileExtent);

                        if(ex == null)

                                return null;

                        int newBufWidth = (int)Math.ceil((ex.width() * this.tilePxWidth) / tileExtent.width());

                        int newBufHeight = (int)Math.ceil((ex.height() * this.tilePxHeight) / tileExtent.height());

                        int nBandsBuffer = p.getBandCount();

                        //Si no hay parte del tile que cae fuera de la imagen no se usa una nueva banda de transparencia ni valores nodata

                        /*if(newBufHeight == this.tilePxHeight && newBufWidth == this.tilePxWidth) {

                                bufResult = readSupersampledBuffer(tileExtent, newBandList, this.tilePxWidth, this.tilePxHeight, nBandsBuffer);

                                if(bufResult == null) {

                                        bufResult = buildTileBuffer(nBandsBuffer, this.tilePxWidth, this.tilePxHeight);

                                        bufResult = p.getWindow(tileExtent, this.tilePxWidth, this.tilePxHeight, newBandList, bufResult, true);

                                }

                        } else {*/

                                //Hay parte del tile que cae fuera de la imagen

                                if(p.getDataType()[0] == Buffer.TYPE_BYTE) {

                                        //Para imagenes byte se crea una banda de transparencia

                                        nBandsBuffer ++; 

                                } 

                                bufResult = buildTileBuffer(nBandsBuffer, this.tilePxWidth, this.tilePxHeight);

                                Buffer smallBuf = readSupersampledBuffer(ex, newBandList, newBufWidth, newBufHeight, nBandsBuffer);

                                if(smallBuf == null) { //No ha habido resampleo

                                        smallBuf = DefaultRasterManager.getInstance().createMemoryBuffer(p.getDataType()[0], newBufWidth, newBufHeight, nBandsBuffer, true);

                                        smallBuf = p.getWindow(ex, newBufWidth, newBufHeight, newBandList, smallBuf, true);

                                }

                                copyToBuffer(bufResult, tileExtent, smallBuf, ex, pixelSize);

                        //}

                        return bufResult;

                } catch (ProcessInterruptedException e) {

                } 

                return null;

        }

        /**

         * Builds a Bandlist object to load tiles

         * @return

         * @deprecated It is only for multifile providers

         */

        @SuppressWarnings("unused")

        private BandList getBandList() {

                BandListImpl bandList = new BandListImpl();

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

                        try {

                                int dataType = prov.getDataType()[i];

                                DatasetBand band = new DatasetBandImpl(prov.getURIByBand(i), i, dataType, prov.getBandCount());

                                bandList.addBand(band, i);

                        } catch(BandNotFoundInListException ex) {

                                //No a?adimos la banda

                        }

                }

                return bandList;

        }

        /**

         * If the provider doesn't support resampling then this method reamples the result manually

         * @param tileExtent

         * @param newBandList

         * @param bufWidth

         * @param bufHeight

         * @param nBands

         * @return

         * @throws ProcessInterruptedException

         * @throws RasterDriverException

         */

        private Buffer readSupersampledBuffer(Extent tileExtent, BandList newBandList, int bufWidth, int bufHeight, int nBands) throws ProcessInterruptedException, RasterDriverException {

                int widthImgPx = (int)Math.abs(tileExtent.width() / prov.getPixelSizeX());

                int heightImgPx = (int)Math.abs(tileExtent.height() / prov.getPixelSizeY());

                boolean supersampling = ((bufWidth > widthImgPx) || (bufHeight > heightImgPx)) ? true : false;

                if(supersampling && !prov.isSupersamplingSupported()) {

                        //Ecw no supersamplea por lo que habr? que hacerlo a mano

                        Buffer buf = buildTileBuffer(nBands, widthImgPx, heightImgPx);

                        prov.getWindow(tileExtent, widthImgPx, heightImgPx, newBandList, buf, true);

                        return buf.getAdjustedWindow(bufWidth, bufHeight, Buffer.INTERPOLATION_NearestNeighbour);

                }

                return null;

        }

        /**

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

         * @param nbands

         * @return

         */

        private Buffer buildTileBuffer(int nbands, int w, int h) {

                Buffer bufResult = DefaultRasterManager.getInstance().createMemoryBuffer(prov.getDataType()[0], w, h, nbands, true);

                if(prov.getDataType()[0] != Buffer.TYPE_BYTE) {

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

                                clearMaskBuffer(bufResult, i);

                        }

                } else

                        clearMaskBuffer(bufResult, nbands - 1);

                return bufResult;

        }

        /**

         * Copies a piece of image into a tile taking into account the different size and proportion

         * @param bufResult

         * @param tileExtent

         * @param buf

         * @param ex

         * @param pixelSize

         */

        private void copyToBuffer(Buffer bufResult, Extent tileExtent,

                        Buffer buf, Extent ex, double pixelSize) {

                double distx = Math.abs(ex.getULX() - tileExtent.getULX());

                double disty = Math.abs(ex.getULY() - tileExtent.getULY());

                int distpxx = (int)Math.round(distx / pixelSize);

                int distpxy = (int)Math.round(disty / pixelSize);

                //Para BYTE la ?ltima banda es de transparencia por lo que en esa banda en las zonas donde hay imagen

                //hay que ponerle el valor 255 para que aparezcan visibles

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

                        for (int iBand = 0; iBand < bufResult.getBandCount() - 1; iBand++) {

                                if(iBand == 0) {

                                        for (int i = distpxy; (i < bufResult.getHeight() && (i - distpxy) < buf.getHeight()); i++) {

                                                for (int j = distpxx; (j < bufResult.getWidth() && (j - distpxx) < buf.getWidth()); j++) {

                                                        bufResult.setElem(i, j, iBand, buf.getElemByte(i - distpxy, j - distpxx, iBand));

                                                        bufResult.setElem(i, j, bufResult.getBandCount() - 1, (byte)255);

                                                }

                                        }

                                } else {

                                        for (int i = distpxy; (i < bufResult.getHeight() && (i - distpxy) < buf.getHeight()); i++) {

                                                for (int j = distpxx; (j < bufResult.getWidth() && (j - distpxx) < buf.getWidth()); j++) {

                                                        bufResult.setElem(i, j, iBand, buf.getElemByte(i - distpxy, j - distpxx, iBand));

                                                }

                                        }

                                }

                        }

                }

                //En el resto de casos no se usa banda de transparencia sino que las zonas del tile fuera de la imagen

                //se inicializaron previamente a NoData

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

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

                                for (int i = distpxy; (i < bufResult.getHeight() && (i - distpxy) < buf.getHeight()); i++) {

                                        for (int j = distpxx; (j < bufResult.getWidth() && (j - distpxx) < buf.getWidth()); j++) {

                                                bufResult.setElem(i, j, iBand, buf.getElemShort(i - distpxy, j - distpxx, iBand));

                                        }

                                }

                        }

                }

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

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

                                for (int i = distpxy; (i < bufResult.getHeight() && (i - distpxy) < buf.getHeight()); i++) {

                                        for (int j = distpxx; (j < bufResult.getWidth() && (j - distpxx) < buf.getWidth()); j++) {

                                                bufResult.setElem(i, j, iBand, buf.getElemInt(i - distpxy, j - distpxx, iBand));

                                        }

                                }

                        }

                }

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

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

                                for (int i = distpxy; (i < bufResult.getHeight() && (i - distpxy) < buf.getHeight()); i++) {

                                        for (int j = distpxx; (j < bufResult.getWidth() && (j - distpxx) < buf.getWidth()); j++) {

                                                bufResult.setElem(i, j, iBand, buf.getElemFloat(i - distpxy, j - distpxx, iBand));

                                        }

                                }

                        }

                }

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

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

                                for (int i = distpxy; (i < bufResult.getHeight() && (i - distpxy) < buf.getHeight()); i++) {

                                        for (int j = distpxx; (j < bufResult.getWidth() && (j - distpxx) < buf.getWidth()); j++) {

                                                bufResult.setElem(i, j, iBand, buf.getElemDouble(i - distpxy, j - distpxx, iBand));

                                        }

                                }

                        }

                }

        }

}