Application: gvSIG desktop

/*

 * Cresques Mapping Suite. Graphic Library for constructing mapping applications.

 *

 * Copyright (C) 2004-5.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 * cresques@gmail.com

 */

package org.cresques.io;

import java.io.BufferedOutputStream;

import java.io.DataOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import org.cresques.cts.IProjection;

import org.cresques.px.PxRaster;

import es.gva.cit.jecwcompress.EcwException;

import es.gva.cit.jgdal.Gdal;

import es.gva.cit.jgdal.GdalBuffer;

import es.gva.cit.jgdal.GdalDriver;

import es.gva.cit.jgdal.GdalException;

import es.gva.cit.jgdal.GdalRasterBand;

import es.gva.cit.jgdal.GeoTransform;

import es.gva.cit.jogr.OGRSpatialReference;

/**

 * Driver para la escritura a trav?s de Gdal.

 * Puede exportar un fichero de un formato a otro desde un GeoRasterFile

 * en cualquier formato soportado por la lectura a un formato que este incluido

 * en la lista supportedDrv.

 *

 * Puede salvar a disco en un formato que este incluido en la lista supportedDrv

 * obteniendo los datos que van siendo servidos desde el cliente. Este cliente

 * debe implementar un IDataWriter o tener un objeto que lo implemente. Inicialmente

 * le pasar? los par?metros de la imagen de salida y cuando el driver comience a

 * escribir le ir? solicitando m?s a trav?s del m?todo readData de IDataWriter.

 * El cliente ser? el que lleve el control de lo que va sirviendo y lo que le queda

 * por servir.

 * @author Nacho Brodin (brodin_ign@gva.es)

 */

public class GdalWriter extends GeoRasterWriter {

    static {

        GeoRasterWriter.registerWriterExtension("tif", GdalWriter.class);

        GeoRasterWriter.registerWriterExtension("jpg", GdalWriter.class);

        GeoRasterWriter.registerWriterExtension("jpeg", GdalWriter.class);

    }

    public final int windowSizeX = 386;

    public final int windowSizeY = 195;

    public final int panelSizeX = 350;

    public final int panelSizeY = 105;

    public final String panelLayout = "BorderLayout";

    private GdalDriver drv;

    private Gdal dset_destino = null;

    private GdalRasterBand rband = null;

    private String drvType = null; //Tipo de driver

    private String[] supportedDrv = { "GTiff", "JPEG" }; //Lista de drivers de escritura que soporta

    private GeoTransform geot = null; //Datos de georeferenciaci?n

    private OGRSpatialReference oSRS; //Datos de proyecci?n                                                

    private GdalBuffer buf = null; //Buffer de origen de gdal

    private GdalBuffer bufBandR = null;

    private GdalBuffer bufBandG = null;

    private GdalBuffer bufBandB = null;

    private int nBlocks = 0; //N?mero de bloques en Y en el que se divide la imagen para escribir

    private int anchoResto = 0; //Tama?o del ?ltimo bloque de la imagen.

    private String[] params = null; //Par?metros de creaci?n del dataset.

    private GdalSupportOptions support = null;

    private boolean consulta = false;

    /**

     * Constructor para la obtenci?n de par?metros del driver

     * @param drvType        Tipo de driver

     */

    public GdalWriter(String drvType) {

        this.support = new GdalSupportOptions(drvType);

        this.ident = this.drvType = drvType;

        if(drvType.equals("GTiff"))

                this.driver = "tif";

        else if(drvType.equals("JPEG"))

                this.driver = "jpg";

        this.support.setBlockSize(64);

        this.support.setPhotometric("RGB");

        this.support.setInterleave("BAND");

        this.support.setCompress("NONE");

        this.support.setWriteGeoref(true);

        this.support.setTfw(false);

        this.consulta = true;

    }

    /**

     * Constructor para salvar una sola imagen completa

     * @param raster        PxRaster de la imagen de  origen

     * @param outfilename        Nombre del fichero de salida

     * @param infilename        Nombre del fichero de entrada

     * @param drvType        Tipo de driver

     */

    public GdalWriter(PxRaster raster, String outfilename, String infilename,

                      String drvType) throws GdalException, IOException {

        this.support = new GdalSupportOptions(drvType);

        this.ident = this.drvType = drvType;

        if(drvType.equals("GTiff"))

                this.driver = "tif";

        else if(drvType.equals("JPEG"))

                this.driver = "jpg";

        this.outfilename = outfilename;

        this.infilename = infilename;

        this.currentRaster = raster;

        this.sizeWindowX = raster.getFWidth();

        this.sizeWindowY = raster.getFHeight();

        //Obtenemos la georeferenciaci?n

        if (support.getGeoref()) {

            double maxX = currentRaster.getExtent().maxX();

            double minX = currentRaster.getExtent().minX();

            double maxY = currentRaster.getExtent().maxY();

            double minY = currentRaster.getExtent().minY();

            //                    System.out.println("Extent->"+maxX+" "+minX+" "+maxY+" "+minY);

            geot = new GeoTransform();

            geot.adfgeotransform[0] = minX;

            geot.adfgeotransform[3] = maxY;

            geot.adfgeotransform[1] = (maxX - minX) / currentRaster.getFWidth();

            geot.adfgeotransform[5] = (minY - maxY) / currentRaster.getFHeight();

        }

        nBands = currentRaster.getBandCount();

        this.support.setBlockSize(64/*currentRaster.getBlockSize()*/);

        if ((sizeWindowX < 0) || (sizeWindowY < 0)) {

            throw new IOException("Tama?o del fichero de salida erroneo.");

        }

        if (nBands == 3) {

            this.support.setPhotometric("PHOTOMETRIC=RGB");

        } else if (nBands == 1) {

            this.support.setPhotometric("PHOTOMETRIC=MINISBLACK");

        } else {

            this.support.setPhotometric("");

        }

        params = new String[2];

        params[0] = new String("TILED=YES");

        params[1] = new String(this.support.getPhotometric());

        init();

        /*oSRS = new OGRSpatialReference();

        try{

                oSRS.setUTM(currentRaster.geoFile.getUTM(), currentRaster.geoFile.getZone());

                  oSRS.setWellKnownGeogCS(currentRaster.geoFile.getGeogCS());

                  //System.out.println(currentRaster.geoFile.getGeogCS()+"Nueva Proyecci?n ==> "+oSRS.exportToWkt());

                  dset_destino.setProjection(oSRS.exportToWkt());

        }catch(Exception e){

                e.printStackTrace();

        }*/

    }

    /**

     * Constructor para salvar datos servidos por el cliente

     * @param dataWriter        Objeto servidor de datos para el driver de escritura

     * @param outSizeX        N?mero de pixels en X de la imagen de salida

     * @param outSizeY        N?mero de pixels en Y de la imagen de salida

     * @param outFilename        Fichero de salida

     * @param extentMaxX        Posici?n en X m?xima del extent

     * @param extentMinX        Posici?n en X m?nima del extent

     * @param extentMaxY        Posici?n en Y m?xima del extent

     * @param extentMinY        Posici?n en Y m?nima del extent

     * @param nBands        N?mero de bandas

     * @param drvType        Tipo de driver

     * @throws GdalException

     * @throws IOException

     */

    public GdalWriter(IDataWriter dataWriter, int outSizeX, int outSizeY,

                      String outFilename, double extentMaxX, double extentMinX,

                      double extentMaxY, double extentMinY, int nBands,

                      int sizeBlock, String drvType)

               throws GdalException, IOException {

        this.support = new GdalSupportOptions(drvType);

        this.ident = this.drvType = drvType;

        if(drvType.equals("GTiff"))

                this.driver = "tif";

        else if(drvType.equals("JPEG"))

                this.driver = "jpg";

        this.dataWriter = dataWriter;

        this.outfilename = outFilename;

        this.sizeWindowX = outSizeX;

        this.sizeWindowY = outSizeY;

        if ((sizeWindowX < 0) || (sizeWindowY < 0)) {

            throw new IOException("Tama?o del fichero de salida erroneo.");

        }

        this.nBands = nBands;

        //Calculamos la georeferenciaci?n a partir del extend pasado por el cliente.

        if (support.getGeoref()) {

            double maxX = extentMaxX;

            double minX = extentMinX;

            double maxY = extentMaxY;

            double minY = extentMinY;

            this.support.setBlockSize(sizeBlock);

            /*System.out.println("----Extent->"+maxX+" "+minX+" "+maxY+" "+minY);

            double pixelSizeX = (double)((maxX-minX)/outSizeX);

            int indexPoint = String.valueOf(pixelSizeX).indexOf('.');

            pixelSizeX = Double.parseDouble(String.valueOf(pixelSizeX).substring(0,indexPoint+3));

            double pixelSizeY = (double)((minY-maxY)/outSizeY);

            indexPoint = String.valueOf(pixelSizeY).indexOf('.');

            pixelSizeY = Double.parseDouble(String.valueOf(pixelSizeY).substring(0,indexPoint+3));

            System.out.println("----PixelSize->"+pixelSizeX+" "+pixelSizeY);*/

            geot = new GeoTransform();

            geot.adfgeotransform[0] = minX;

            geot.adfgeotransform[3] = maxY; //-((pixelSizeY * outSizeY)-minY);

            geot.adfgeotransform[1] = (double) ((maxX - minX) / outSizeX); //pixelSizeX;

            geot.adfgeotransform[5] = (double) ((minY - maxY) / outSizeY); //pixelSizeY;

            //System.out.println("----adfGeo->"+geot.adfgeotransform[0]+" "+geot.adfgeotransform[3]+" "+geot.adfgeotransform[1]+" "+geot.adfgeotransform[5]);

        }

        setParams();

        init();

    }

    /**

     *Asigna par?metros de creaci?n del dataset de Gdal

     */

    private void setParams() {

        params = new String[5];

        params[0] = new String("TILED=YES");

        params[1] = new String("PHOTOMETRIC=" + this.support.getPhotometric());

        params[2] = new String("INTERLEAVE=" + this.support.getInterleave());

        params[3] = new String("COMPRESS=" + this.support.getCompress());

        String tfw = null;

        if (this.support.getTfw()) {

            tfw = new String("YES");

        } else {

            tfw = new String("NO");

        }

        params[4] = new String("TFW=" + tfw);

    }

    /**

     * Asigna el tipo de driver con el que se salvar? la imagen

     * @param drvType        Tipo de driver

     */

    public void setDriverType(String drvType) {

        this.drvType = drvType;

    }

    /**

     * Creaci?n del dataset de destino.

     * @throws EcwException

     */

    private void init() throws GdalException {

        //Controlamos que el tipo de driver sea correcto

        if (drvType == null) {

            throw new GdalException("Tipo de driver sin especificar.");

        }

        boolean okdrvtype = false;

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

            if (drvType.equals(supportedDrv[i])) {

                okdrvtype = true;

            }

        if (okdrvtype == false) {

            throw new GdalException("El tipo de driver "+drvType+" no est? soportado por GdalWriter.");

        }

        //Obtenemos el driver y creamos el dataset del destino

        drv = Gdal.getDriverByName(drvType);

        /*try{

                drv = Gdal.getDriverByName("JPEG");

                Gdal src = new Gdal();

                src.open("/home/nacho/imagenes/q101866.tif", 0);

                drv.createCopy( "/home/nacho/outgvGIG.jpg", src, false );

        }catch(IOException e){}

        return;*/

        //System.out.println("++++++>"+params.length);

        //for(int i=0;i<params.length;i++)System.out.println("=====>"+params[i]);

        if (dset_destino != null) {

            dset_destino.close();

            dset_destino = null;

        }

        dset_destino = drv.create(outfilename, sizeWindowX, sizeWindowY,

                                  nBands, Gdal.GDT_Byte, params);

        if (this.support.getGeoref()) {

            dset_destino.setGeoTransform(geot);

        }

        nBlocks = (int) (sizeWindowY / this.support.getBlockSize());

        anchoResto = sizeWindowY - (nBlocks * this.support.getBlockSize());

        //System.out.println("---"+nBlocks+" "+sizeBlock+" "+anchoResto);

    }

    /**

     * A partir de un elemento que contiene una propiedad y un valor

     * lo parsea y asigna el valor a su variable.

     * @param propValue        elemento con la forma propiedad=valor

     */

    private void readProperty(String propValue) {

        String prop = propValue.substring(0, propValue.indexOf("="));

        if (propValue.startsWith(prop)) {

            String value = propValue.substring(propValue.indexOf("=") + 1,

                                               propValue.length());

            if ((value != null) && !value.equals("")) {

                if (prop.equals("BLOCKSIZE")) {

                    this.support.setBlockSize(Integer.parseInt(value));

                }

                if (prop.equals("GEOREF")) {

                    boolean georef = true;

                    if (value.equals("yes")) {

                        georef = true;

                    } else {

                        georef = false;

                    }

                    this.support.setWriteGeoref(georef);

                }

                if (prop.equals("INTERLEAVE")) {

                    this.support.setInterleave(value);

                }

                if (prop.equals("PHOTOMETRIC")) {

                    this.support.setPhotometric(value);

                }

                if (prop.equals("COMPRESS")) {

                    this.support.setCompress(value);

                }

                if (prop.equals("TFW")) {

                    boolean tfw = true;

                    if (value.equals("yes")) {

                        tfw = true;

                    } else {

                        tfw = false;

                    }

                    this.support.setTfw(tfw);

                }

            }

        }

    }

    /**

     * Asigna propiedades al driver a partir de un vector de

     * strings donde cada elemento tiene la estructura de

     * propiedad=valor.

     * @param props        Propiedades

     */

    public void setProps(String[] props) {

        for (int iProps = 0; iProps < props.length; iProps++)

            readProperty(props[iProps]);

        setParams();

        try {

            if (!consulta) {

                init();

            }

        } catch (GdalException e) {

            e.printStackTrace();

        }

    }

    /**

     * Escribe tres bandas en el GDALRasterBand desde el IDataWriter con una

     * altura definida por sizeY.

     * @param buftmp        Buffer

     * @param sizeY        Altura en pixels del bloque leido

     * @param posicionY        Posici?n y a partir de la cual se escribe en el GDALRasterBand destino

     */

    private void writeBands(int[] buftmp, int sizeY, int posicionY) {

        //leemos el bloque origen

        buftmp = dataWriter.readData(sizeWindowX, sizeY, 0);

        bufBandR.buffByte = new byte[buftmp.length];

        bufBandG.buffByte = new byte[buftmp.length];

        bufBandB.buffByte = new byte[buftmp.length];

        //Escribimos el bloque destino

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

            bufBandR.buffByte[i] = (byte) (((buftmp[i] & 0xff0000) >> 16) &

                                   0xff);

            bufBandG.buffByte[i] = (byte) (((buftmp[i] & 0xff00) >> 8) & 0xff);

            bufBandB.buffByte[i] = (byte) ((buftmp[i] & 0xff) & 0xff);

            //if(i==0 || i==1 || i==2)System.out.println("<**>"+buftmp[i]+" + "+bufBandR.buffByte[i]+" - "+bufBandG.buffByte[i]+" - "+bufBandB.buffByte[i]);

        }

        try {

            rband = dset_destino.getRasterBand(1);

            rband.writeRaster(0, posicionY, sizeWindowX, sizeY, bufBandR,

                              Gdal.GDT_Byte);

            rband = dset_destino.getRasterBand(2);

            rband.writeRaster(0, posicionY, sizeWindowX, sizeY, bufBandG,

                              Gdal.GDT_Byte);

            rband = dset_destino.getRasterBand(3);

            rband.writeRaster(0, posicionY, sizeWindowX, sizeY, bufBandB,

                              Gdal.GDT_Byte);

        } catch (GdalException e) {

            e.printStackTrace();

        }

    }

    /**

     * Funci?n que gestiona la lectura desde el origen y la escritura

     * de Gdal sobre el fichero destino.

     * @param mode        Modo de escritura

     * @throws IOException

     */

    private void write(int mode) throws IOException {

        buf = new GdalBuffer();

        bufBandR = new GdalBuffer();

        bufBandG = new GdalBuffer();

        bufBandB = new GdalBuffer();

        int[] buftmp = null;

        //long t1 = System.currentTimeMillis();

        try {

            if (mode == Mode.fileWrite) {

                for (int iBand = 0; iBand < this.nBands; iBand++) {

                    rband = dset_destino.getRasterBand(iBand + 1);

                    for (int iBlock = 0; iBlock < nBlocks; iBlock++) {

                        //leemos el bloque origen

                        buf.buffByte = currentRaster.getGeoFile().getWindow(0,

                                                                            iBlock * this.support.getBlockSize(),

                                                                            sizeWindowX,

                                                                            this.support.getBlockSize(),

                                                                            iBand +

                                                                            1);

                        //Escribimos el bloque destino

                        rband.writeRaster(0,

                                          iBlock * this.support.getBlockSize(),

                                          sizeWindowX,

                                          this.support.getBlockSize(), buf,

                                          Gdal.GDT_Byte);

                    }

                }

            } else if (mode == Mode.dataWrite) {

                //for(int iBlock=1;iBlock<=nBlocks;iBlock++){

                for (int iBlock = 0; iBlock < nBlocks; iBlock++) {

                    int posicionY = iBlock * this.support.getBlockSize();

                    writeBands(buftmp, this.support.getBlockSize(), posicionY);

                }

            }

            if (anchoResto != 0) {

                if (mode == Mode.fileWrite) {

                    for (int iBand = 0; iBand < this.nBands; iBand++) {

                        rband = dset_destino.getRasterBand(iBand + 1);

                        //leemos el bloque origen

                        buf.buffByte = currentRaster.getGeoFile().getWindow(0,

                                                                            nBlocks * this.support.getBlockSize(),

                                                                            sizeWindowX,

                                                                            anchoResto,

                                                                            iBand +

                                                                            1);

                        //Escribimos el bloque destino

                        rband.writeRaster(0,

                                          nBlocks * this.support.getBlockSize(),

                                          sizeWindowX, anchoResto, buf,

                                          Gdal.GDT_Byte);

                    }

                } else if (mode == Mode.dataWrite) {

                    int posicionY = nBlocks * this.support.getBlockSize();

                    writeBands(buftmp, anchoResto, posicionY);

                }

            }

        } catch (GdalException e) {

            e.printStackTrace();

        }

    }

    /**

     * Realiza la funci?n de compresi?n a partir de un GeoRasterFile.

     * @throws IOException

     */

    public void fileWrite() throws IOException {

        if (currentRaster == null) {

            throw new IOException("No se ha asignado un fichero de entrada.");

        }

        this.write(Mode.fileWrite);

    }

    /**

     * Realiza una copia en el formato especificado.

     * @throws IOException

     */

    public static void createCopy(GdalDriver driverDst, String dst, String src, 

                    boolean bstrict, String[] params, IProjection proj) throws IOException, GdalException {

        if (dst == null || src == null) {

            throw new IOException("No se ha asignado un fichero de entrada.");

        }

        GdalFile gdalFile = new GdalFile(proj, src);

        driverDst.createCopy(dst, gdalFile.file, bstrict, params);

        if(dst.endsWith(".jpg") || dst.endsWith(".jpeg"))

                GdalWriter.createWorldFile(dst, gdalFile);

        gdalFile.close();

    }

    /**

         * Crea un fichero de georeferenciaci?n

         * @param img

         * @param name

         * @return

         * @throws IOException

         */

        private static void createWorldFile(String name, GdalFile gdalFile) throws IOException{

            File tfw = null;

            String extWorldFile = ".wld";

            if(name.endsWith("tif"))

                    extWorldFile = ".tfw";

            if(name.endsWith("jpg") || name.endsWith("jpeg"))

                    extWorldFile = ".jpgw";

            tfw = new File(name.substring(0, name.lastIndexOf(".")) + extWorldFile);

            //Generamos un world file para gdal

            DataOutputStream dos = new DataOutputStream( new BufferedOutputStream(new FileOutputStream(tfw)) );

            dos.writeBytes((gdalFile.getExtent().getMax().getX() - gdalFile.getExtent().getMin().getX())/gdalFile.getWidth()+"\n");

            dos.writeBytes("0.0\n");

            dos.writeBytes("0.0\n");

            dos.writeBytes((gdalFile.getExtent().getMax().getY() - gdalFile.getExtent().getMin().getY())/gdalFile.getHeight()+"\n");

            dos.writeBytes(""+gdalFile.getExtent().getMin().getX()+"\n");

            dos.writeBytes(""+gdalFile.getExtent().getMin().getY()+"\n");

            dos.close();    

        }

    /**

     * Realiza la escritura de datos con los datos que le pasa el cliente.

     * @throws IOException

     */

    public void dataWrite() throws IOException {

        if (dataWriter == null) {

            throw new IOException("No se ha obtenido un objeto de entrada para la escritura valido.");

        }

        this.write(Mode.dataWrite);

    }

    /**

     * Cierra el compresor ecw.

     * @throws GdalException

     */

    public void writeClose() {

        try {

            dset_destino.close();

            oSRS = null;

        } catch (GdalException e) {

            e.printStackTrace();

        }

    }

    /**

     * Devuelve la configuraci?n de la ventana de dialogo

     * para las propiedades del driver de escritura de Gdal.

     * @return XML de configuraci?n del dialogo.

     */

    public String getXMLPropertiesDialog() {

        StringBuffer options = null;

        options = new StringBuffer();

        options.append("<window sizex=\"" + this.windowSizeX + "\" sizey=\"" +

                       this.windowSizeY + "\">");

        options.append("<panel sizex=\"" + this.panelSizeX + "\" sizey=\"" +

                       this.panelSizeY + "\" layout=\"" + this.panelLayout +

                       "\" border=\"yes\">");

        options.append("<panel layout=\"FlowLayout\" position=\"North\" align=\"left\">");

        options.append("<label>Block:</label>");

        options.append("<combo ident=\"BLOCKSIZE\" selected=\"" +

                       this.support.getBlockSize() + "\">");

        for (int i = 0; i < this.support.getBlockSizeList().length; i++)

            options.append("<elem>" + this.support.getBlockSizeList()[i] +

                           "</elem>");

        options.append("</combo>");

        //options.append("<label>Georef Si/No:</label>");

        String sel = null;

        if (this.support.getGeoref()) {

            sel = new String("yes");

        } else {

            sel = new String("no");

        }

        /*options.append("<check ident=\"GEOREF\" selected=\"" + sel +

                       "\" text=\"\">");

        options.append("</check>");*/

        options.append("</panel>");

        options.append("<panel layout=\"FlowLayout\" position=\"Center\" align=\"left\">");

        options.append("<label>Photometric:</label>");

        options.append("<combo ident=\"PHOTOMETRIC\" selected=\"" +

                       this.support.getPhotometric() + "\">");

        for (int i = 0; i < this.support.getPhotometricList().length; i++)

            options.append("<elem>" + this.support.getPhotometricList()[i] +

                           "</elem>");

        options.append("</combo>");

        options.append("<label>Interleave:</label>");

        options.append("<combo ident=\"INTERLEAVE\" selected=\"" +

                       this.support.getInterleave() + "\">");

        for (int i = 0; i < this.support.getInterleaveList().length; i++)

            options.append("<elem>" + this.support.getInterleaveList()[i] +

                           "</elem>");

        options.append("</combo>");

        options.append("</panel>");

        options.append("<panel layout=\"FlowLayout\" position=\"South\" align=\"left\">");

        options.append("<label>Compress:</label>");

        options.append("<combo ident=\"COMPRESS\" selected=\"" +

                       this.support.getCompress() + "\">");

        for (int i = 0; i < this.support.getCompressList().length; i++)

            options.append("<elem>" + this.support.getCompressList()[i] +

                           "</elem>");

        options.append("</combo>");

        options.append("<label>World file:</label>");

        sel = null;

        if (this.support.getTfw()) {

            sel = new String("yes");

        } else {

            sel = new String("no");

        }

        options.append("<check ident=\"TFW\" selected=\"" + sel +

                       "\" text=\"\">");

        options.append("</check>");

        options.append("</panel>");

        options.append("</panel>");

        options.append("</window>");

        return options.toString();

    }

    /**

     *

     * @author Nacho Brodin (brodin_ign@gva.es)

     *

     * Opciones que soporta el driver de escritura de Gdal.

     */

    class GdalSupportOptions extends WriterSupportOptions {

        private String[] photometric = {

                                           "YCBR", "MINISBLACK", "MINISWHITE",

                                           "RGB", "CMYK", "CIELAB", "ICCLAB",

                                           "ITULAB", "CBCR"

                                       };

        private String[] interleave = { "BAND", "PIXEL" };

        private String[] compress = { "LZW", "PACKBITS", "DEFLATE", "NONE" };

        private String photometricDefault = "RGB";

        private String interleaveDefault = "BAND";

        private String compressDefault = "NONE";

        private boolean tfw = false;

        GdalSupportOptions(String ext) {

            super(ext);

        }

        /**

         * @param defaultPhot        Tipo de imagen

         */

        public void setPhotometric(String defaultPhot) {

            this.photometricDefault = defaultPhot;

        }

        /**

         * @param defaultInt

         */

        public void setInterleave(String defaultInt) {

            this.interleaveDefault = defaultInt;

        }

        /**

         * @param defaultComp

         */

        public void setCompress(String defaultComp) {

            this.compressDefault = defaultComp;

        }

        /**

         * Asigna true o false si se desea generar un fichero tfw con la

         * georeferenciaci?n o no;

         * @param tfw true se genera el fichero tfw y false no se genera

         */

        public void setTfw(boolean tfw) {

            this.tfw = tfw;

        }

        /**

         * @return

         */

        public String[] getPhotometricList() {

            return photometric;

        }

        /**

         * @return

         */

        public String[] getInterleaveList() {

            return interleave;

        }

        /**

         * @return

         */

        public String[] getCompressList() {

            return compress;

        }

        /**

         * @return

         */

        public String getPhotometric() {

            return photometricDefault;

        }

        /**

         * @return

         */

        public String getInterleave() {

            return interleaveDefault;

        }

        /**

         * Obtiene el par?metro de compresi?n

         * @return

         */

        public String getCompress() {

            return compressDefault;

        }

        /**

         * Devuelve true o false si se genera un fichero tfw con la

         * georeferenciaci?n o no;

         * @param tfw true se genera el fichero tfw y false no se genera

         */

        public boolean getTfw() {

            return tfw;

        }

    }

    private class Mode {

        public final static int fileWrite = 0;

        public final static int dataWrite = 1;

    }

}