| gvSIG desktop 1

 * Copyright (C) 2004-5.

 *

 *

import java.io.IOException;

 * Driver para la compresi?n en formato Ecw.

 *

 * Puede exportar un fichero desde un GeoRasterFile en cualquier formato soportado

 *

 * Puede salvar a disco en formato Ecw 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

public class EcwWriter extends GeoRasterWriter {

    static {

        GeoRasterWriter.registerWriterExtension("ecw", EcwWriter.class);

    }

    public final int windowSizeX = 386;

    public final int windowSizeY = 215;

    public final int panelSizeX = 350;

    public final int panelSizeY = 125;

    public final String panelLayout = "BorderLayout";

    private NCSEcwCompressClient compressclient = null;

    private Reader readerObj;

    private double pixelSizeX;

    private double pixelSizeY;

    private double geoCoordOrigenX;

    private double geoCoordOrigenY;

    private EcwSupportOptions support = null;

    private boolean consulta = false;

    /**

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

     *

     */

    public EcwWriter() {

        this.support = new EcwSupportOptions();

        this.driver = "ecw";

        this.support.setBlockSize(64);

        this.support.setCompressionDefault(10);

        this.support.setFormatDefault(4);

        this.support.setWriteGeoref(true);

        this.ident = "Ecw";

        this.consulta = true;

    }

    /**

     * Constructor para salvar una sola imagen completa

     * @param raster        PxRaster de la imagen origen

     * @param outfilename        Fichero de salida

     * @param infilename        Fichero de entrada

     * @param compresion        Compresi?n

     */

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

                     int compresion) throws EcwException, IOException {

        this.support = new EcwSupportOptions();

        this.ident = "Ecw";

        this.outfilename = outfilename;

        this.infilename = infilename;

        this.currentRaster = raster;

        this.support.setCompressionDefault(compresion);

        this.sizeWindowX = raster.getFWidth();

        this.sizeWindowY = raster.getFHeight();

        this.support.setBlockSize(currentRaster.getBlockSize());

        nBands = currentRaster.getBandCount();

        //Calculamos la georeferenciaci?n

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

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

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

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

        double w = currentRaster.getFWidth();

        double h = currentRaster.getFHeight();

        pixelSizeX = (maxX - geoCoordOrigenX) / w;

        pixelSizeY = (minY - geoCoordOrigenY) / h;

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

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

        }

        if (nBands == 1) {

            this.support.setFormatDefault(CompressFormat.COMPRESS_UINT8);

        } else if (nBands == 3) {

            this.support.setFormatDefault(CompressFormat.COMPRESS_RGB);

        } else {

            this.support.setFormatDefault(CompressFormat.COMPRESS_MULTI);

        }

        init();

    }

    /**

     * Constructor para la lectura de datos desde el objeto cliente a partir

     * de un viewport dado.

     * @param dataWriter        Objeto que sirve datos para el escritor

     * @param vp        viewport de origen

     * @param outFileName        Fichero de salida

     * @param blockSize        Tama?o de bloque

     * @param nBands        N?mero de bandas

     * @param compresion        Compresi?n

     * @throws EcwException

     * @throws IOException

     */

    public EcwWriter(IDataWriter dataWriter, ViewPortData vp,

                     String outFileName, int blockSize, int nBands,

                     int compresion) throws EcwException, IOException {

        this.support = new EcwSupportOptions();

        this.ident = "Ecw";

        if (compresion <= 0) {

            throw new EcwException("Tasa de compresi?n no valida.");

        }

        if (nBands <= 0) {

            throw new EcwException("N?mero de bandas erroneo.");

        }

        if ((vp.getWidth() <= 0) || (vp.getHeight() <= 0)) {

            throw new EcwException("Tama?o de la imagen de salida erroneo.");

        }

        this.outfilename = outFileName;

        this.dataWriter = dataWriter;

        this.support.setCompressionDefault(compresion);

        this.nBands = nBands;

        this.sizeWindowX = (int) vp.getWidth();

        this.sizeWindowY = (int) vp.getHeight();

        this.support.setBlockSize(blockSize);

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

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

        geoCoordOrigenX = vp.getExtent().minX();

        geoCoordOrigenY = vp.getExtent().maxY();

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

        pixelSizeX = (maxX - geoCoordOrigenX) / vp.getWidth();

        pixelSizeY = (minY - geoCoordOrigenY) / vp.getHeight();

        if (pixelSizeX == 0) {

            pixelSizeX = 1.0;

        }

        if (pixelSizeY == 0) {

            pixelSizeY = 1.0;

        }

        init();

    }

    /**

     * Inicializaci?n de los par?metros del compresor que ser?n obtenidos

     * de PxRaster.

     * @throws EcwException

     */

    private void init() throws EcwException {

        if (this.support.getCompression() == 0) {

            this.support.setCompressionDefault(1);

        }

        if (compressclient == null) {

            compressclient = new NCSEcwCompressClient();

        }

        compressclient.setOutputFilename(outfilename);

        compressclient.setInputFilename(infilename);

        compressclient.setTargetCompress(this.support.getCompression());

        compressclient.setInOutSizeX(sizeWindowX);

        compressclient.setInOutSizeY(sizeWindowY);

        compressclient.setInputBands(nBands);

        compressclient.setCompressFormat(this.support.getFormat());

        //System.out.println("Origen=>"+minX + "  "+maxY );

        //System.out.println("Pixel Size=>"+psX+"  "+psY);

        //compressclient.setDatum("UTM Zona 31N");

        //client.setProjection("WGS84");

        if (this.support.getGeoref()) {

            compressclient.setCellIncrementX(pixelSizeX);

            compressclient.setCellIncrementY(pixelSizeY);

            compressclient.setOriginX(geoCoordOrigenX);

            compressclient.setOriginY(geoCoordOrigenY);

        }

        compressclient.setCellSizeUnits(1);

        //System.out.println(outfilename+" "+infilename+" "+compresion+" "+sizeWindowX+" "+sizeWindowY+" "+currentRaster.getBandCount());

        //System.out.println(psX+" "+psY+" "+minX+" "+maxX);

        if (currentRaster != null) {

            readerObj = new Reader(currentRaster.getGeoFile(), compressclient,

                                   ulX, ulY, sizeWindowX, sizeWindowY,

                                   this.support.getBlockSize());

        } else if (dataWriter != null) {

            readerObj = new Reader(dataWriter, compressclient, sizeWindowX,

                                   sizeWindowY, this.support.getBlockSize(),

                                   this.nBands);

        }

    }

    /**

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

                    int select = 0;

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

                        select = 1;

                    }

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

                        select = 2;

                    }

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

                        select = 3;

                    }

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

                        select = 4;

                    }

                    this.support.setFormatDefault(select);

                }

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

                    boolean georef = true;

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

                        georef = true;

                    } else {

                        georef = false;

                    }

                    this.support.setWriteGeoref(georef);

                }

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

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

                }

            }

        }

    }

    /**

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

        try {

            if (!consulta) {

                init();

            }

        } catch (EcwException 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.");

        }

        try {

            compressclient.NCSEcwCompressOpen(false);

            compressclient.NCSEcwCompress(readerObj);

        } catch (EcwException e) {

            e.printStackTrace();

        }

    }

    /**

     * Realiza la funci?n de compresi?n a partir de los datos pasados por el cliente.

     * @throws IOException

     */

    public void dataWrite() throws IOException {

        if (dataWriter == null) {

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

        }

        try {

            compressclient.NCSEcwCompressOpen(false);

            compressclient.NCSEcwCompress(readerObj);

        } catch (EcwException e) {

            e.printStackTrace();

        }

    }

    /**

     * Cierra el compresor ecw.

     */

    public void writeClose() {

        try {

            compressclient.NCSEcwCompressClose();

        } catch (EcwException e) {

            e.printStackTrace();

        }

    }

    /**

     * Devuelve la configuraci?n de la ventana de dialogo

     * para las propiedades del driver de escritura de Ecw.

     * @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>Tama?o bloque:</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>Formato:</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=\"Georef Si/No\">");

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

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

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

        options.append("<slider ident=\"COMPRESSION\" name=\"Nivel de Compresi?n\" sizex=\"350\" sizey=\"20\">");

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

                       "</min>");

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

                       "</max>");

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

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

                       "</minorspacing>");

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

                       "</majorspacing>");

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

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

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

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

        return options.toString();

    }

    /**

     * @author Nacho Brodin <brodin_ign@gva.es>

     *

     * Opciones de escritura para el Ecw. Estas opciones son utilizadas para el

     * dialogo de propiedades de Salvar a Raster en Ecw.

     */

    class EcwSupportOptions extends WriterSupportOptions {

        private String[] compresionListValues = { "0", "20", "10", "1", "5" }; //min, max, valor defecto, intervalo peque?o, intervalo grande;

        private String[] formatList = { "NONE", "UINT8", "YUV", "MULTI", "RGB" };

        private int formatDefault = 4;

        private int compresionDefault = 10;

        EcwSupportOptions() {

            super("Ecw");

        }

        /**

         * Asigna la lista de valores de compresi?n

         * @param compresion        lista de valores

         */

        public void setCompressionList(String[] compresion) {

            this.compresionListValues = compresion;

        }

        /**

         * Valor de formato seleccionado en el driver.

         * 0-NONE, 1-UINT8, 2-YUV, 3-MULTI, 4-RGB

         * @param i        valor de formato

         */

        public void setFormatDefault(int i) {

            this.formatDefault = i;

        }

        /**

         * Asigna el nivel de compresi?npor defecto

         * @param compress        Nivel de compresi?n

         */

        public void setCompressionDefault(int compress) {

            this.compresionDefault = compress;

        }

        /**

         * Obtiene el tipo de imagen en un formato comprensible por el driver.

         * @return        Tipo de imagen

         */

        public String getStringFormat() {

            return "COMPRESS_" + formatList[formatDefault];

        }

        /**

         * Obtiene la lista de los tipos de formato disponible

         * @return Lista de tipos de formato

         */

        public String[] getFormatList() {

            return formatList;

        }

        /**

         * Obtiene el tipo de formato seleccionado en el driver

         * @return Tipo de formato seleccionado

         */

        public int getFormat() {

            return formatDefault;

        }

        /**

         * Obtiene la compresion seleccionada

         * @return Compresi?n seleccionada

         */

        public int getCompression() {

            return compresionDefault;

        }

        /**

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

        }

    }

 * para obligar escribir el m?todo loadBuffer encargado de servir los datos cuando el

    private NCSEcwCompressClient compressclient = null;

    private int width;

    private int height;

    private int ulX;

    private int ulY;

    private GeoRasterFile grf = null;

    private IDataWriter dataWriter = null;

    private GdalRasterBand rband = null;

    private int blockSizeRead = 1; //Alto del bloque leido de la imagen origen 

    private int countLine = 1; //Contador de l?neas procesadas en cada lectura de bloque

    byte[][] buf = null;

    byte[] bufband1 = null;

    byte[] bufband2 = null;

    byte[] bufband3 = null;

    byte[] bufband4 = null;

    byte[] bufband5 = null;

    byte[] bufband6 = null;

    int[] dataBuffer = null;

    private int lineasBloqueFinal = 0; //N?mero de l?neas leidas del bloque final

    private int nBlocks = 0; //N?mero de bloques completos

    private int countBlock = 1; //Contador de bloques completos procesados

    private int nBands = 0;

    /**

     * Constructor para la escritura de un fichero desde un GeoRasterFile

     * @param grf        GeorasterFile del fichero de origen

     * @param compressclient        Objeto que representa al compresor ecw

     * @param ulx        Coordenada X de la esquina superior izquierda

     * @param uly        Coordenada Y de la esquina superior izquierda

     * @param width        Ancho de la imagen

     * @param height        Alto de la imagen

     * @param blockSizeRead        Altura del bloque en la lectura

     */

    public Reader(GeoRasterFile grf, NCSEcwCompressClient compressclient,

                  int ulx, int uly, int width, int height, int blockSizeRead) {

        this.compressclient = compressclient;

        this.width = width;

        this.height = height;

        this.ulX = ulx;

        this.ulY = uly;

        this.grf = grf;

        this.nBands = grf.bandCount;

        if (blockSizeRead != 0) {

            this.blockSizeRead = blockSizeRead;

        }

        nBlocks = (int) (height / this.blockSizeRead);

        lineasBloqueFinal = height - (nBlocks * this.blockSizeRead);

        if (blockSizeRead > 64) {

            this.blockSizeRead = 64;

        }

    }

    /**

     * Constructor para que los datos sean servidos desde el cliente a trav?s de un

     * IDataWriter.

     * @param dataWriter        Objeto servidor de datos del driver

     * @param compressclient        Objeto que representa al compresor ecw

     * @param width        Ancho de la imagen

     * @param height        Alto de la imagen

     * @param blockSizeRead        Altura del bloque en la lectura

     * @param nBands        N?mero de bandas

     */

    public Reader(IDataWriter dataWriter, NCSEcwCompressClient compressclient,

                  int width, int height, int blockSizeRead, int nBands) {

        this.compressclient = compressclient;

        this.width = width;

        this.height = height;

        this.dataWriter = dataWriter;

        this.nBands = nBands;

        if (blockSizeRead != 0) {

            this.blockSizeRead = blockSizeRead;

        }

        nBlocks = (int) (height / this.blockSizeRead);

        lineasBloqueFinal = height - (nBlocks * this.blockSizeRead);

        //System.out.println("NBLOQUES="+nBlocks+" lineas ultimo="+lineasBloqueFinal);

        if (blockSizeRead > 64) {

            this.blockSizeRead = 64;

        }

    }

    /**

     * Lectura de bandas desde un GeoRasterFile

     * @param ulX        Coordenada X de la esquina superior izquierda

     * @param ulY        Coordenada Y de la esquina superior izquierda

     * @param width        Ancho de la imagen

     * @param lineasLeidas        N?mero de l?neas a leer del origen

     */

    private void readBandsGRFile(int ulX, int ulY, int width, int lineasLeidas) {

        if (nBands >= 1) {

            bufband1 = grf.getWindow(ulX, ulY, width, lineasLeidas, 1);

        }

        if (nBands >= 2) {

            bufband2 = grf.getWindow(ulX, ulY, width, lineasLeidas, 2);

        }

        if (nBands >= 3) {

            bufband3 = grf.getWindow(ulX, ulY, width, lineasLeidas, 3);

        }

        if (nBands >= 4) {

            bufband4 = grf.getWindow(ulX, ulY, width, lineasLeidas, 4);

        }

        if (nBands >= 5) {

            bufband5 = grf.getWindow(ulX, ulY, width, lineasLeidas, 5);

        }

        if (nBands >= 6) {

            bufband6 = grf.getWindow(ulX, ulY, width, lineasLeidas, 6);

        }

    }

    /**

     * Lectura de bandas llamando al objeto cliente para que nos cargue el buffer

     * @param width        Ancho de la imagen

     * @param height        Alto de la imagen

     */

    private void readBands(int width, int height) {

        dataBuffer = dataWriter.readData(width, height, 0);

    }

    /**

     * M?todo obligado por el interfaz y que es llamado desde C cuando el

     * compresor necesita que le sirvan m?s datos.

     */

    public void loadBuffer() {

        int lineasLeidas = 0;

        //si se leen bloques completos lineasLeidas es == al tama?o de bloque sino

        //es que es el ?ltimo con lo que ser? del tama?o del bloque final

        if (countBlock <= nBlocks) {

            lineasLeidas = blockSizeRead;

        } else {

            lineasLeidas = lineasBloqueFinal;

        }

        //Leemos un bloque nuevo cuando se han procesado todas las l?neas del anterior

        if ((nNextLine % blockSizeRead) == 0) {

            if (grf != null) {

                readBandsGRFile(ulX, ulY + nNextLine, width, lineasLeidas);

            } else if (dataWriter != null) {

                readBands(width, lineasLeidas);

            }

            countLine = 0;

            countBlock++;

        }

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

            for (int pos = 0; pos < width; pos++) {

                if (grf != null) {

                    if (iBand == 0) {

                        compressclient.buffer[pos + (width * iBand)] = bufband1[pos +

                                                                       (width * countLine)];

                    }

                    if (iBand == 1) {

                        compressclient.buffer[pos + (width * iBand)] = bufband2[pos +

                                                                       (width * countLine)];

                    }

                    if (iBand == 2) {

                        compressclient.buffer[pos + (width * iBand)] = bufband3[pos +

                                                                       (width * countLine)];

                    }

                    if (iBand == 3) {

                        compressclient.buffer[pos + (width * iBand)] = bufband4[pos +

                                                                       (width * countLine)];

                    }

                    if (iBand == 4) {

                        compressclient.buffer[pos + (width * iBand)] = bufband5[pos +

                                                                       (width * countLine)];

                    }

                    if (iBand == 5) {

                        compressclient.buffer[pos + (width * iBand)] = bufband6[pos +

                                                                       (width * countLine)];

                    }

                } else {

                    if (iBand == 0) {

                        compressclient.buffer[pos + (width * iBand)] = (byte) ((dataBuffer[pos +

                                                                       (width * countLine)] &

                                                                       0xff0000) >> 16);

                    }

                    if (iBand == 1) {

                        compressclient.buffer[pos + (width * iBand)] = (byte) ((dataBuffer[pos +

                                                                       (width * countLine)] &

                                                                       0xff00) >> 8);

                    }

                    if (iBand == 2) {

                        compressclient.buffer[pos + (width * iBand)] = (byte) (dataBuffer[pos +

                                                                       (width * countLine)] &

                                                                       0xff);

                    }

                }

                if ((pos == (width - 1)) && (iBand == (this.nBands - 1))) {

                    countLine++;

                }

            }

        }

    }

    /**

     * M?todo obligado por el interfaz y que es llamado desde C cuando el

     * compresor actualiza el porcentaje de compresi?n

     */

    public void updatePercent() {

        System.out.println(compressclient.getPercent() + "%");

    }

}