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

import java.awt.Graphics;

import java.awt.geom.AffineTransform;

import java.awt.image.BufferedImage;

import java.io.IOException;

import javax.swing.ImageIcon;

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

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

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

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

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.datastruct.NoData;

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.exception.InitializeException;

import org.gvsig.fmap.dal.exception.ProviderNotRegisteredException;

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

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

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

import org.gvsig.raster.impl.RasterDefaultImplLibrary;

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

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

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

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

import org.gvsig.raster.impl.store.DefaultRasterStore;

import org.gvsig.raster.util.DefaultProviderServices;

import org.gvsig.tools.locator.LocatorException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Base class for downloaders

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

 */

public abstract class BaseTileDownloader implements Downloader {

        private Logger                          log               = LoggerFactory.getLogger(BaseTileDownloader.class);

        protected int                           tilePxWidth       = 0;

        protected int                           tilePxHeight      = 0;

        protected RasterDataStore               store             = 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 BaseTileDownloader(RasterDataStore store, int tilePxWidth, int tilePxHeight) {

                this.store = store;

                this.tilePxWidth = tilePxWidth;

                this.tilePxHeight = tilePxHeight;

                if(store.getNoDataValue() != null && store.getNoDataValue().isDefined())

                        setNoDataValue(store.getNoDataValue());

        }

        /**

         * Gets the image that represent a tile while is downloading.

         * @return

         */

        public Object[] getDownloadingImage(int w, int h) {

                if(RasterDefaultImplLibrary.downloadingImg == null)

                        return null;

                String key = w + "X" + h + "_Downloading";

                return new Object[]{getBufferFromImageIcon(w, h, key, RasterDefaultImplLibrary.downloadingImg)};

        }

        /**

         * Gets the image that represent a crash tile

         * @return

         */

        public Object[] getCrashImage(int w, int h) {

                if(RasterDefaultImplLibrary.crashImg == null)

                        return null;

                String key = w + "X" + h + "_Crash";

                return new Object[]{getBufferFromImageIcon(w, h, key, RasterDefaultImplLibrary.crashImg)};

        }

        private Buffer getBufferFromImageIcon(int w, int h, String key, ImageIcon icon) {

                Buffer buf = RasterDefaultImplLibrary.defaultImages.get(key);

                if(buf == null) {

                        try {

                                BufferParam par = RasterLocator.getManager().getBufferFactory().createBufferParams(w, h, 4, Buffer.TYPE_BYTE, true);

                                buf = RasterLocator.getManager().getBufferFactory().createBuffer(par);

                        } catch (LocatorException e) {

                                log.debug("Error creating buffers ", e);

                        } catch (BufferCreationException e) {

                                log.debug("Error creating buffers ", e);

                        }

                        byte[] background = new byte[]{-1, -1, -1, (byte)50};

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

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

                                        buf.setElemByte(j, i, background);

                        BufferedImage img = new BufferedImage(icon.getIconWidth(), icon.getIconHeight(), BufferedImage.TYPE_INT_ARGB);

                        Graphics g = img.createGraphics();

                    g.drawImage(icon.getImage(), 0, 0, null);

                        int initX = (w / 2) - (img.getWidth() / 2);

                        int initY = (h / 2) - (img.getHeight() / 2);

                        for (int i = initY; i < (img.getHeight() + initY); i++) {

                                for (int j = initX; j < (img.getWidth() + initX); j++) {

                                        int value = img.getRGB(j - initX, i - initY);

                                        buf.setElem(i, j, 0, (byte)((value & 0x00ff0000) >> 16));

                                        buf.setElem(i, j, 1, (byte)((value & 0x0000ff00) >> 8));

                                        buf.setElem(i, j, 2, (byte)(value & 0x000000ff));

                                        buf.setElem(i, j, 3, (byte)((value & 0xff000000) >> 24));

                                }

                        }

                        RasterDefaultImplLibrary.defaultImages.put(key, buf);

                }

                return buf;

        }

        /**

         * Gets the size of a tile in pixels

         * @return Array of two integers. The first integer is the width and the second the height in pixels

         */

        public int[] getTileSize() {

                return new int[]{tilePxWidth, tilePxHeight};

        }

        /**

         * Sets the nodata value

         * @param noData

         */

        public void setNoDataValue(NoData noData) {

                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;

                }

        }

        public Tile readTileFromDisk(Tile tile) throws TileGettingException {

                if(!tile.getFile().exists()) {

                        tile.setCorrupt(true);

                        return null;

                }

                BandList bandList = (BandList)tile.getDownloaderParams("BandList");

                try {

                        DefaultRasterStore tileStore = new DefaultRasterStore();

                        AbstractRasterProvider tileProvider = DefaultProviderServices.loadProvider(tile.getFile());

                        tileStore.setProvider(tileProvider);

                        this.tilePxWidth = tile.getWidthPx();

                        this.tilePxHeight = tile.getHeightPx();

                        RasterQuery q = RasterLocator.getManager().createQuery();

                        int[] renderBands = bandList.getDrawableBands();

                        if(renderBands.length == 4 && renderBands[3] < tileProvider.getBandCount())

                                q.forceARGBRequest();

                        else

                                q.forceRGBRequest();

                        q.setDrawableBands(bandList.getDrawableBands());

                        Buffer buf = tileStore.query(q);

                        tile.setData(new Object[]{buf, null, tileStore.getColorTable()});

                        buf.setDataExtent(tileStore.getExtent().toRectangle2D());

                        tileStore.close();

                        return tile;

                } catch (ProcessInterruptedException e) {

                        throw new TileGettingException(e);

                } catch (ProviderNotRegisteredException e) {

                        throw new TileGettingException(e);

                } catch (InitializeException e) {

                        throw new TileGettingException(e);

                } catch (QueryException e) {

                        throw new TileGettingException(e);

                }

        }

        /**

         * Builds a BandList structure using all bands of a raster provider

         * @param prov

         * @return

         */

        @SuppressWarnings("unused")

        private BandList createBandListFromProvider(RasterProvider prov) {

                BandList bandList = new BandListImpl();

                bandList.clear();

                int nBands = prov.getDataType()[0] == Buffer.TYPE_BYTE ? prov.getBandCount() - 1 : prov.getBandCount();

                int[] drawableBands = new int[nBands];

                for(int i = 0; i < nBands; i++) {

                        try {

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

                                DatasetBand band = new DatasetBandImpl(prov.getURIByBand(i).getPath(),

                                                                                                        prov.getBandPositionByProvider(i),

                                                                                                        dataType,

                                                                                                        nBands);

                                bandList.addBand(band);

                                drawableBands[i] = i;

                        } catch(BandNotFoundInListException ex) {

                                //No a?adimos la banda

                        }

                }

                bandList.setDrawableBands(drawableBands);

                return bandList;

        }

        /**

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

                }

        }

        /**

         * Saves a buffer to disk

         * @param bufResult Buffer to save

         * @param pixelSize Pixel size

         * @param extension output file format

         * @param alphaBand true if it has alpha band

         * @param path Path to the new file

         * @param tileExtent Bounding box of the tile

         * @throws NotSupportedExtensionException

         * @throws RasterDriverException

         * @throws ProcessInterruptedException

         * @throws IOException

         */

        protected void saveTile(Buffer bufResult,

                        double pixelSize,

                        String extension,

                        boolean alphaBand,

                        Tile tile,

                        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("_." + extension).getParams();

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

                                tileExtent.getULX(),

                                tileExtent.getULY());

                RasterWriter rw = rManager.createWriter(dataWriter, tile.getFile().getAbsolutePath(),

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

                tile.setCorrupt(false);

        }

}