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

import java.io.IOException;

import org.cresques.cts.IProjection;

import org.cresques.geo.ViewPortData;

import org.cresques.io.GdalWriter.GdalSupportOptions;

import org.cresques.px.PxRaster;

import es.gva.cit.jgdal.Gdal;

import es.gva.cit.jgdal.GdalDriver;

import es.gva.cit.jgdal.GdalException;

/**

 * Driver para la escritura de Jpeg.

 * Este driver utiliza GdalWriter para salvar Jpeg. 

 * La escritura de un jpeg no es posible utilizando un servidor de datos 

 * como el que usan los drivers comunes por lo que ser? necesario salvar antes

 * a Tif con el driver de Gdal para posteriormente convertir la imagen completa

 * a jpg.

 *  

 @author Nacho Brodin (brodin_ign@gva.es)

 */

public class JpegWriter extends GeoRasterWriter {

        public final int                                 windowSizeX = 386;

    public final int                                 windowSizeY = 220;

    public final int                                 panelSizeX = 358;

    public final int                                 panelSizeY = 125;

        //Datos de registro de drivers

    static {

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

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

        typeList.put("jpg", "Jpeg");

        typeList.put("jpeg", "Jpeg");

    }

    private GdalWriter                                gdalWriter = null;

    private JpegSupportOptions                support = null;

    private String                                        outTif = null;

    private String                                        outJpg = null;

    private String[]                                props = null;

    private ViewPortData                        viewPort =  null;

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

    /**

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

     * @param drvType        Tipo de driver

     */

    public JpegWriter(String fileName) {

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

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

            support = new JpegSupportOptions(driver);

            gdalWriter = new GdalWriter(fileName);

            gdalWriter.getSupport().setTfw(true);

            setParams();

    }

    /**

     * 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 JpegWriter(PxRaster raster, String outFileName, String inFileName) throws GdalException, IOException {

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

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

            support = new JpegSupportOptions(driver);

            gdalWriter = new GdalWriter(raster, outFileName, inFileName);

            gdalWriter.getSupport().setTfw(true);

            setParams();

    }

    /**

     * 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 JpegWriter(        IDataWriter dataWriter, 

                                             String outFileName, 

                                             Integer blockSize, 

                                             Integer nBands,

                                             ViewPortData vp,

                                             Integer compresion,

                                             Integer outSizeX,

                                             Integer outSizeY)throws GdalException, IOException {

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

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

            support = new JpegSupportOptions(driver);

            outJpg = outFileName;

            outTif = outFileName.substring(0, outFileName.lastIndexOf(".") + 1);

            outTif = outTif + "tif";

            this.viewPort = vp;

            gdalWriter = new GdalWriter(dataWriter, outTif, blockSize, nBands, 

                                                                    vp, compresion, outSizeX, outSizeY);

            gdalWriter.getSupport().setTfw(true);

            setParams();

    }

    /**

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

     * @param drvType        Tipo de driver

     */

    public void setDriverType(String drvType) {

        gdalWriter.setDriverType(drvType);

    }

    /**

     * 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("COMPRESSION"))

                        support.setCompressionDefault(Integer.parseInt(value));

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

                    boolean prog = true;

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

                        prog = true;

                    } else {

                        prog = false;

                    }

                    support.setProgressive(prog);

                }

            }

        }

    }

    /**

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

            this.props = props;

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

            readProperty(props[iProps]);

            setParams();

    }

    /**

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

     * @throws IOException

     */

    public void fileWrite() throws IOException {

            gdalWriter.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 {

            GdalWriter.createCopy(driverDst, dst, src, bstrict, params, proj);

    }

    /**

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

     */

    private void setParams() {

        params = new String[3];

        params[0] = new String("WORLDFILE=ON");

        params[1] = new String("QUALITY=" + support.getCompressionRealValue());

        String prog = null;

        if (support.isProgressive()) {

                prog = new String("ON");

        } else {

                prog = new String("NO");

        }

        params[2] = new String("PROGRESSIVE=" + prog); 

    }

    /**

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

     * @throws IOException

     */

    public void dataWrite() throws IOException {

        gdalWriter.dataWrite();

        if(gdalWriter.isWrite()){

                gdalWriter.writeClose();

                if(outTif != null){

                        GdalDriver driver = null;

                        try{

                                    driver = Gdal.getDriverByName("JPEG");

                                    GdalWriter.createCopy(driver, outJpg, outTif, false, 

                                                                                        params, viewPort.getProjection());

                        }catch(GdalException exc){

                                System.err.println("No se ha podido obtener el driver.");

                            }

                        File file = new File(outTif);

                        file.delete();        

                }

        }

    }

    /**

     * Cierra el compresor ecw.

     * @throws GdalException

     */

    public void writeClose() {

            //El close del tif se hizo en dataWrite

    }

    /**

     * Cancela el salvado de datos.

     */

    public void writeCancel() {

            gdalWriter.setWrite(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=\"" + windowSizeX + "\" sizey=\"" +

                        windowSizeY + "\">");

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

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

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

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

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

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

                        gdalWriter.getSupport().getBlockSize() + "\">");

        for (int i = 0; i < gdalWriter.getSupport().getBlockSizeList().length; i++)

            options.append("<elem>" + gdalWriter.getSupport().getBlockSizeList()[i] +

                           "</elem>");

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

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

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

        options.append("<slider ident=\"COMPRESSION\" name=\"Compression\" sizex=\"370\" sizey=\"20\">");

        options.append("<min>" + support.getCompressionList()[0] +

                       "</min>");

        options.append("<max>" + support.getCompressionList()[1] +

                       "</max>");

        options.append("<value>" + support.getCompressionDefault() + "</value>");

        options.append("<minorspacing>" + support.getCompressionList()[3] +

                       "</minorspacing>");

        options.append("<majorspacing>" + support.getCompressionList()[4] +

                       "</majorspacing>");

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

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

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

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

        String sel = null;

        if (support.isProgressive()) {

            sel = new String("yes");

        } else {

            sel = new String("no");

        }

        options.append("<check ident=\"PROGRESSIVE\" 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 Jpeg.

    */

   public class JpegSupportOptions extends WriterSupportOptions {

       private boolean                 progressive = true; 

       private String[]         compresionListValues = { "10", "100", "16", "5", "30" }; //min, max, valor defecto, intervalo peque?o, intervalo grande;

       private int                         compresionDefaultValue = 16;

       public JpegSupportOptions(String ext) {

           super(ext);

       }

       /**

        * Obtiene la compresion seleccionada

        * @return Compresi?n seleccionada

        */

       public int getCompressionDefault() {

           return compresionDefaultValue;

       }

       /**

        * Obtiene la compresion seleccionada en el valor real que necesita gdal. Por defecto gdal

        * tiene un valor de 75 en un rango de 10-100 donde 10 es la m?xima compresi?n. 

        * Como el slider est? en un rango de 0-100 donde el 100 es la m?xima compresi?n y 0 

        * la m?nima hay que hacer una conversi?n.

        * @return Compresi?n seleccionada

        */

       public int getCompressionRealValue() {

           return 110 - compresionDefaultValue;

       }

       /**

        * Obtiene la lista de los valores para la generaci?n de la barra de

        * compresi?n. Son cinco valores m?nimo, m?ximo, seleccionado,

        * intervalo peque?o, intervalo grande.

        * @return lista de valores de compresi?n

        */

       public String[] getCompressionList() {

           return compresionListValues;

       }

       /**

        * Asigna el nivel de compresi?npor defecto

        * @param compress        Nivel de compresi?n

        */

       public void setCompressionDefault(int compress) {

           this.compresionDefaultValue = compress;

       }

       /**

        * Asigna la lista de valores de compresi?n

        * @param compresion        lista de valores

        */

       public void setCompressionList(String[] compresion) {

           this.compresionListValues = compresion;

       }

           public boolean isProgressive() {

                        return progressive;

           }

           public void setProgressive(boolean progressive) {

                        this.progressive = progressive;

           }

   }

}