| gvSIG desktop 1

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2006 IVER T.I. and Generalitat Valenciana.

 *

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

 */

package org.gvsig.raster.dataset.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.gvsig.raster.dataaccess.buffer.RasterBuffer;

import org.gvsig.raster.dataset.GeoRasterWriter;

import org.gvsig.raster.dataset.IDataWriter;

import org.gvsig.raster.dataset.NotSupportedExtensionException;

import org.gvsig.raster.dataset.WriterSupportOptions;

import org.gvsig.raster.shared.Extent;

import org.gvsig.raster.util.RasterUtilities;

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;

/**

 * 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 (nachobrodin@gmail.com)

 */

public class GdalWriter extends GeoRasterWriter {

        //Datos de registro de drivers

    static {

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

        //GeoRasterWriter.registerWriterExtension("tiff", GdalWriter.class);

        typeList.put("tif", "GTiff");

        //typeList.put("tiff", "GTiff");

    }

    public final int                                 windowSizeX = 386;

    public final int                                 windowSizeY = 195;

    public final int                                 panelSizeX = 358;

    public final int                                 panelSizeY = 105;

    public final String                         panelLayout = "BorderLayout";

    private GdalDriver                                 drv;

    private Gdal                                         dset_destino = null;

    private GdalRasterBand                         rband = null;

    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[]                        bufBands = 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;

    private        boolean                                        write = true; //Cuando est? a true se puede escribir en la imagen de salida. Si est? a false el proceso es interrumpido

    private int                                         dataType = RasterBuffer.TYPE_UNDEFINED;

    /**

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

     * @param drvType        Tipo de driver

     */

    public GdalWriter(String fileName) {

            ident = fileName.toLowerCase().substring(fileName.lastIndexOf(".") + 1);

            driver = (String)typeList.get(ident);

        support = new GdalSupportOptions(driver);

        support.setBlockSize(blockSizeDefault);

        support.setPhotometric("RGB");

        support.setInterleave("BAND");

        support.setCompress("NONE");

        support.setWriteGeoref(true);

        support.setTfw(false);

        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) throws GdalException, IOException {

            ident = outFileName.toLowerCase().substring(outFileName.lastIndexOf(".") + 1);

            driver = (String)typeList.get(ident);

        support = new GdalSupportOptions(driver);

        this.outFileName = outFileName;

        this.inFileName = inFileName;

        currentRaster = raster;

        sizeWindowX = raster.getFWidth();

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

            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(64currentRaster.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 outFilename              Fichero de salida

     * @param blockSize                Tama?o de bloque

     * @param Extent                   extent

     * @param compresion                   Compresi?n si la tiene

     * @param outSizeX                          Tama?o de salida en X

     * @param outSizeY                        Tama?o de salida en Y

     * @param dataType                        Tipo de dato

     * @throws GdalException

     * @throws IOException

     */

    public GdalWriter(        IDataWriter dataWriter,

                                             String outFileName,

                                             Integer blockSize,

                                             Integer nBands,

                                             Extent ex,

                                             Integer compresion,

                                             Integer outSizeX,

                                             Integer outSizeY,

                                             Integer dataType)throws GdalException, IOException {

            ident = outFileName.toLowerCase().substring(outFileName.lastIndexOf(".") + 1);

            driver = (String)typeList.get(ident);

        support = new GdalSupportOptions(driver);

        this.dataType = dataType.intValue();

        this.dataWriter = dataWriter;

        this.outFileName = outFileName;

        this.sizeWindowX = outSizeX.intValue();

        this.sizeWindowY = outSizeY.intValue();

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

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

        }

        this.nBands = nBands.intValue();

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

        if (support.getGeoref()) {

            double maxX = ex.maxX();

            double minX = ex.minX();

            double maxY = ex.maxY();

            double minY = ex.minY();

            this.support.setBlockSize(blockSize.intValue());

            geot = new GeoTransform();

            geot.adfgeotransform[0] = minX;

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

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

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

        }

        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.driver = drvType;

    }

    /**

     * Creaci?n del dataset de destino.

     * @throws EcwException

     */

    private void init() throws GdalException {

        //Controlamos que el tipo de driver sea correcto

        if (driver == null) {

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

        }

        boolean okdrvtype = false;

        String[] types = GeoRasterWriter.getDriversType();

        for (int i = 0; i < GeoRasterWriter.getNTypes(); i++)

            if (driver.equals(types[i])) {

                okdrvtype = true;

            }

        if (okdrvtype == false) {

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

        }

        //Obtenemos el driver y creamos el dataset del destino

        drv = Gdal.getDriverByName(driver);

        if (dset_destino != null) {

            dset_destino.close();

            dset_destino = null;

        }

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

                                  nBands, RasterUtilities.getGdalTypeFromRasterBufType(dataType), params);

        if (this.support.getGeoref()) {

            dset_destino.setGeoTransform(geot);

        }

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

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

    }

    public void anotherFile(String fileName)throws GdalException{

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

                nBands, RasterUtilities.getGdalTypeFromRasterBufType(dataType), params);

    }

    /**

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

        }

    }

    /**

     * Escritura de datos tipo Byte.

     * @param sizeY Alto del bloque que se escribe.

     * @param posicionY Posici?ny a partir desde donde se comienza.

     */

    public void writeByteBand(int sizeY, int posicionY){

            byte[][] buftmp = dataWriter.readByteData(sizeWindowX, sizeY);

            for(int iBand = 0; iBand < nBands; iBand ++)

                bufBands[iBand].buffByte = new byte[buftmp[iBand].length];

            //Escribimos el bloque destino

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

                    for (int i = 0; i < buftmp[iBand].length; i++)

                            bufBands[iBand].buffByte[i] = buftmp[iBand][i];

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

                try {

                                rband = dset_destino.getRasterBand(iBand + 1);

                                rband.writeRaster(0, posicionY, sizeWindowX, sizeY, bufBands[iBand], Gdal.GDT_Byte);

                } catch (GdalException e) {

                                //No se est? escribiendo ...

                        }

        }

    }

    /**

     * Escritura de datos tipo Short.

     * @param sizeY Alto del bloque que se escribe.

     * @param posicionY Posici?ny a partir desde donde se comienza.

     */

    public void writeShortBand(int sizeY, int posicionY){

            short[][] buftmp = dataWriter.readShortData(sizeWindowX, sizeY);

            for(int iBand = 0; iBand < nBands; iBand ++)

                bufBands[iBand].buffShort = new short[buftmp[iBand].length];

            //Escribimos el bloque destino

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

                    for (int i = 0; i < buftmp[iBand].length; i++)

                            bufBands[iBand].buffShort[i] = buftmp[iBand][i];

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

                try {

                                rband = dset_destino.getRasterBand(iBand + 1);

                                rband.writeRaster(0, posicionY, sizeWindowX, sizeY, bufBands[iBand], Gdal.GDT_Int16);

                } catch (GdalException e) {

                                //No se est? escribiendo ...

                        }

        }

    }

    /**

     * Escritura de datos tipo Int.

     * @param sizeY Alto del bloque que se escribe.

     * @param posicionY Posici?ny a partir desde donde se comienza.

     */

    public void writeIntBand(int sizeY, int posicionY){

            int[][] buftmp = dataWriter.readIntData(sizeWindowX, sizeY);

            for(int iBand = 0; iBand < nBands; iBand ++)

                bufBands[iBand].buffInt = new int[buftmp[iBand].length];

            //Escribimos el bloque destino

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

                    for (int i = 0; i < buftmp[iBand].length; i++)

                            bufBands[iBand].buffInt[i] = buftmp[iBand][i];

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

                try {

                                rband = dset_destino.getRasterBand(iBand + 1);

                                rband.writeRaster(0, posicionY, sizeWindowX, sizeY, bufBands[iBand], Gdal.GDT_Int32);

                } catch (GdalException e) {

                                //No se est? escribiendo ...

                        }

        }

    }

    /**

     * Escritura de datos tipo Float.

     * @param sizeY Alto del bloque que se escribe.

     * @param posicionY Posici?ny a partir desde donde se comienza.

     */

    public void writeFloatBand(int sizeY, int posicionY){

            float[][] buftmp = dataWriter.readFloatData(sizeWindowX, sizeY);

            for(int iBand = 0; iBand < nBands; iBand ++)

                bufBands[iBand].buffFloat = new float[buftmp[iBand].length];

            //Escribimos el bloque destino

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

                    for (int i = 0; i < buftmp[iBand].length; i++)

                            bufBands[iBand].buffFloat[i] = buftmp[iBand][i];

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

                try {

                                rband = dset_destino.getRasterBand(iBand + 1);

                                rband.writeRaster(0, posicionY, sizeWindowX, sizeY, bufBands[iBand], Gdal.GDT_Float32);

                } catch (GdalException e) {

                                //No se est? escribiendo ...

                        }

        }

    }

    /**

     * Escritura de datos tipo Double.

     * @param sizeY Alto del bloque que se escribe.

     * @param posicionY Posici?ny a partir desde donde se comienza.

     */

    public void writeDoubleBand(int sizeY, int posicionY){

            double[][] buftmp = dataWriter.readDoubleData(sizeWindowX, sizeY);

            for(int iBand = 0; iBand < nBands; iBand ++)

                bufBands[iBand].buffDouble = new double[buftmp[iBand].length];

            //Escribimos el bloque destino

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

                    for (int i = 0; i < buftmp[iBand].length; i++)

                            bufBands[iBand].buffDouble[i] = buftmp[iBand][i];

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

                try {

                                rband = dset_destino.getRasterBand(iBand + 1);

                                rband.writeRaster(0, posicionY, sizeWindowX, sizeY, bufBands[iBand], Gdal.GDT_Float64);

                } catch (GdalException e) {

                                //No se est? escribiendo ...

                        }

        }

    }

    /**

     * Escritura para tipo de dato ARGB.

     * @param sizeY Alto del bloque que se escribe.

     * @param posicionY Posici?ny a partir desde donde se comienza.

     */

    public void writeARGBBand(int sizeY, int posicionY){

            int[] buftmp = dataWriter.readARGBData(sizeWindowX, sizeY, 0);

             for(int iBand = 0; iBand < nBands; iBand ++)

                 bufBands[iBand].buffByte = new byte[buftmp.length];

         //Escribimos el bloque destino

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

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

                                    0xff);

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

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

         }

         try {

             rband = dset_destino.getRasterBand(1);

             rband.writeRaster(0, posicionY, sizeWindowX, sizeY, bufBands[0],

                               Gdal.GDT_Byte);

             rband = dset_destino.getRasterBand(2);

             rband.writeRaster(0, posicionY, sizeWindowX, sizeY, bufBands[1],

                               Gdal.GDT_Byte);

             rband = dset_destino.getRasterBand(3);

             rband.writeRaster(0, posicionY, sizeWindowX, sizeY, bufBands[2],

                               Gdal.GDT_Byte);

         } 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 sizeY, int posicionY) {

        //leemos el bloque origen

        switch(dataType){

        case RasterBuffer.TYPE_IMAGE:

                writeARGBBand(sizeY, posicionY);

                break;

        case RasterBuffer.TYPE_BYTE:

                writeByteBand(sizeY, posicionY);

                break;

        case RasterBuffer.TYPE_SHORT:

                writeShortBand(sizeY, posicionY);

                break;

        case RasterBuffer.TYPE_INT:

                writeIntBand(sizeY, posicionY);

                break;

        case RasterBuffer.TYPE_FLOAT:

                writeFloatBand(sizeY, posicionY);

                break;

        case RasterBuffer.TYPE_DOUBLE:

                writeDoubleBand(sizeY, posicionY);

                break;

        }

    }

    /**

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

        bufBands = new GdalBuffer[nBands];

        for(int iBand = 0; iBand < nBands; iBand ++)

                bufBands[iBand] = 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++) {

                            if(write){

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

                                    //this.writeClose();

                    }

                }*/

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

                    if(write)

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

                    /*else

                            this.writeClose();*/

                }

            }

            if (anchoResto != 0) {

                if (mode == Mode.fileWrite) {

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

                        rband = dset_destino.getRasterBand(iBand + 1);

                        if(write){

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

                                //this.writeClose();

                    }*/

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

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

                    if(write)

                            writeBands(anchoResto, posicionY);

                    /*else

                            this.writeClose();*/

                }

            }

        /*} 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.");

        }

        org.gvsig.raster.dataset.io.GdalDriver gdalFile;

                try {

                        gdalFile = new org.gvsig.raster.dataset.io.GdalDriver(proj, src);

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

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

                        GdalWriter.createWorldFile(dst, gdalFile);

                gdalFile.close();

                } catch (NotSupportedExtensionException e) {

                        e.printStackTrace();

                }

    }

    /**

         * Crea un fichero de georeferenciaci?n

         * @param img

         * @param name

         * @return

         * @throws IOException

         */

        private static void createWorldFile(String name, org.gvsig.raster.dataset.io.GdalDriver 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);

    }

    /**

     * Cancela el salvado de datos.

     * @throws GdalException

     */

    public void writeClose() {

        try {

                if(dset_destino != null)

                        dset_destino.close();

           //oSRS = null;

        } catch (GdalException e) {

            e.printStackTrace();

        }

    }

    /**

     * Cancela el salvado de datos.

     */

    public void writeCancel() {

       write = false;

    }

    /**

     * 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 Size:</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>Compresi?n:</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>Generar Tfw:</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();

    }

    /**

     * Obtiene el valor a la variable write que estar? a true cuando se est? escribiendo

     *  o puede escribirse la imagen de salida. El cancelar la operaci?n de escritura

     * pondr? esta variable a false deteniendose la escritura y cerrandose el dataset

     * de salida.

     * @return True si puede escribirse y false si no puede

     */

    public boolean isWrite() {

                return write;

        }

    /**

     * Asigna el valor a la variable write que estar? a true cuando se est? escribiendo

     *  o puede escribirse la imagen de salida. El cancelar la operaci?n de escritura

     * pondr? esta variable a false deteniendose la escritura y cerrandose el dataset

     * de salida.

     * @param write Variable booleana. True si puede escribirse y false si no puede

     */

        public void setWrite(boolean write) {

                this.write = write;

        }

        /**

         * Obtiene las opciones de salvado.

         * @return GdalSupportOptions

         */

        public GdalSupportOptions getSupport(){

            return this.support;

    }

    /**

     *

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

     *

     * Opciones que soporta el driver de escritura de Gdal.

     */

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

        public 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) {