| gvSIG desktop 1

        ExtensionPoints extensionPoints = ExtensionPointsSingleton.getInstance();

        WriteFileFormatFeatures features = null;

    	String os = System.getProperties().getProperty("os.version");

        if (os.startsWith("2.4")){

        	extensionPoints.add("RasterWriter", "ecw", ErmapperWriter.class);

        	features = new WriteFileFormatFeatures("Ecw", "ecw", -1, null, ErmapperWriter.class);

    		fileFeature.put("ecw", features);

        }

        extensionPoints.add("RasterWriter", "jp2", ErmapperWriter.class);

        features = new WriteFileFormatFeatures("Jpeg2000", "jp2", -1, null, ErmapperWriter.class);

    }

    public final int 				windowSizeX = 386;

    public final int 				windowSizeY = 220;

    public final int 				panelSizeX = 358;

    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 boolean 				consulta = false;

    /**

     * Carga los par?metros de este driver.

     */

    public void loadParams() {

    	WriteFileFormatFeatures wfff = new WriteFileFormatFeatures();

    	wfff.loadParams();

    	driverParams = wfff.getParams();

    	driverParams.setParam(	"compression", 

								"10", 

								Params.SLIDER, 

    	driverParams.setParam(	"format", 

								"RGB", 

								Params.CHOICE, 

    }

    /**

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

     */

    public ErmapperWriter(String fileName) {

    	ident = RasterUtilities.getExtensionFromFileName(fileName);    	

    	driver = ((WriteFileFormatFeatures)fileFeature.get(ident)).getDriverName();

    	loadParams();

        consulta = true;

    }

    /**

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

                     		String outFileName,  

                     		Integer nBands,

                     		Extent ex,

                     		Integer outSizeX,

                     		Integer outSizeY,

                     		Integer dataType,

         					Params params) throws EcwException, IOException {

    	ident = RasterUtilities.getExtensionFromFileName(outFileName); 

    	driver = ((WriteFileFormatFeatures)fileFeature.get(ident)).getDriverName();

        this.dataType = dataType.intValue();

        if (nBands.intValue() <= 0) 

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

        if ((ex.width() <= 0) || (ex.height() <= 0)) {

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

        }

        this.outFileName = outFileName;

        this.dataWriter = dataWriter;

        this.nBands = nBands.intValue();

        this.sizeWindowX = outSizeX.intValue();

        this.sizeWindowY = outSizeY.intValue();

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

        double maxX = ex.maxX();

        geoCoordOrigenX = ex.minX();

        geoCoordOrigenY = ex.maxY();

        double minY = ex.minY();

        pixelSizeX = (maxX - geoCoordOrigenX) / outSizeX.intValue();

        pixelSizeY = (minY - geoCoordOrigenY) / outSizeY.intValue();

        if (pixelSizeX == 0) 

            pixelSizeX = 1.0;

        if (pixelSizeY == 0) 

            pixelSizeY = 1.0;

        if(params == null)

        	loadParams();

        else 

        	driverParams = params;

        init();

    }

    /**

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

     * de PxRaster.

     * @throws EcwException

     */

    private void init() throws EcwException {

    	percent = 0;

    	int comp = new Integer(((Param)driverParams.getParamById("compression")).defaultValue).intValue();

    	String format = ((Param)driverParams.getParamById("format")).defaultValue;

        if ( comp == 0 ) 

        	driverParams.changeParamValue("compression", "1");

        if (compressclient == null) 

            compressclient = new NCSEcwCompressClient();

        compressclient.setOutputFilename(outFileName);

        compressclient.setInputFilename(inFileName);

        compressclient.setTargetCompress(comp);

        compressclient.setInOutSizeX(sizeWindowX);

        compressclient.setInOutSizeY(sizeWindowY);

        compressclient.setInputBands(nBands);

        compressclient.setCompressFormat(convertFormatToInt(format));

       /* boolean georef = new Boolean(((Param)driverParams.getParamById("georef")).defaultValue).booleanValue();

        if (georef) {*/

        compressclient.setCellIncrementX(pixelSizeX);

        compressclient.setCellIncrementY(pixelSizeY);

        compressclient.setOriginX(geoCoordOrigenX);

        compressclient.setOriginY(geoCoordOrigenY);

        //}

        compressclient.setCellSizeUnits(1);

        int blocksize = new Integer(((Param)driverParams.getParamById("blocksize")).defaultValue).intValue();

        if (dataWriter != null) {

            readerObj = new Reader(dataWriter, compressclient, sizeWindowX,

                                   sizeWindowY, blocksize, nBands, this, dataType);

        }

    }

    /**

     * Convierte la cadena que representa el formato en un valor n?merico

     * que entiende el driver.

     * @param format Cadena que representa el formato

     * @return Entero que representa a la cadena

     */

    private int convertFormatToInt(String format) {

    	if(format.compareTo("NONE") == 0)

    		return 0;

    	if(format.compareTo("UINT8") == 0)

    		return 1;

        if(format.compareTo("YUV") == 0)

        	return 2;

        if(format.compareTo("MULTI") == 0)

        	return 3;

        if(format.compareTo("RGB") == 0)

        	return 4;

    	return -1;

    }

    /**

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

                    driverParams.changeParamValue("blocksize", value);

                if (prop.equals("FORMAT")) 

                	driverParams.changeParamValue("format", value);

                if (prop.equals("COMPRESSION"))

                	driverParams.changeParamValue("compression", 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]);

        loadParams();

        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 {

       /* try {

            compressclient.NCSEcwCompressOpen(false);

            compressclient.NCSEcwCompress(readerObj);

        } catch (EcwException e) {

            e.printStackTrace();

        }*/

    	//TODO: FUNCIONALIDAD: Compresi?n a partir de un dataset. De momento no es necesario y es posible que nunca lo sea.

    }

    /**

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

        }

    }

    /**

     * Cancela el compresor ecw.

     */

    public void writeCancel() {

        try {

        	if(readerObj != null)

        		readerObj.setWrite(false);

            compressclient.NCSEcwCompressCancel();

        } catch (EcwException e) {

            e.printStackTrace();

        }

    }

    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 GeoRasterWriter			writer = 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;

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

    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 = IBuffer.TYPE_BYTE;

    /**

     * 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, int dataType) {

        this.compressclient = compressclient;

        this.width = width;

        this.height = height;

        this.ulX = ulx;

        this.ulY = uly;

        this.grf = grf;

        this.nBands = grf.getBandCount();

        this.dataType = dataType;

        if (blockSizeRead != 0) {

            this.blockSizeRead = blockSizeRead;

        }

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

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

    }

    /**

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

                  GeoRasterWriter writer, int dataType) {

        this.compressclient = compressclient;

        this.width = width;

        this.height = height;

        this.dataWriter = dataWriter;

        this.nBands = nBands;

        this.writer = writer;

        this.dataType = dataType;

        if (blockSizeRead != 0) {

            this.blockSizeRead = blockSizeRead;

        }

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

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

    }

    /**

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

    	if(dataType == IBuffer.TYPE_IMAGE)

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

    	if(dataType == IBuffer.TYPE_BYTE) {

    		byte[][] b = dataWriter.readByteData(width, height);

    	}

    }

    /**

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

            	if(dataType == IBuffer.TYPE_IMAGE)

            		dataBuffer = dataWriter.readARGBData(width, lineasLeidas, 0);

            	if(dataType == IBuffer.TYPE_BYTE) 

            		byteBuffer = dataWriter.readByteData(width, lineasLeidas);

            }

            countLine = 0;

            countBlock++;

        }

        if(dataType == IBuffer.TYPE_IMAGE)

    		loadBufferFromImageDataType(dataBuffer);

    	if(dataType == IBuffer.TYPE_BYTE) 

    		loadBufferFromByteDataType(byteBuffer);

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

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

                if (grf != null && write) {

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

                }

            }

        }*/

    }

    /**

     * Carga el buffer de datos desde elementos de tipo entero con contenido ARGB 

     * @param data Array de datos enteros

     */

    private void loadBufferFromImageDataType(int[] data) {

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

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

            	switch(iBand) {

            	case 0:  

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

            			(byte) ((data[pos + (width * countLine)] & 0xff0000) >> 16);

            		break;

            	case 1: 

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

            			(byte) ((data[pos + (width * countLine)] & 0xff00) >> 8);

            		break;

            	case 2: 

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

            			(byte) (data[pos + (width * countLine)] & 0xff);

            		break;

            	}

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

            		countLine++;

            }

        }

    }

    /**

     * Carga el buffer de datos a comprimir desde un buffer byte[][] donde la primera dimensi?n 

     * es el n?mero de bandas y la segunda los elementos en lista (Ancho X Alto)

     * @param b Buffer de datos de tipo byte[][]

     */

    private void loadBufferFromByteDataType(byte[][] b) {

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

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

            	compressclient.buffer[pos + (width * iBand)] = b[iBand][pos + (width * countLine)];

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

    	writer.setPercent(compressclient.getPercent()); 

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

    }

    /**

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

    /**

     * 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

     */