Application: gvSIG desktop

/*

 * EcwFile.java

 */

package org.cresques.io;

import java.awt.Dimension;

import java.awt.Image;

import java.awt.Point;

import java.awt.image.BufferedImage;

import com.ermapper.ecw.JNCSFile;

import com.ermapper.ecw.JNCSFileNotOpenException;

import com.ermapper.ecw.JNCSProgressiveUpdate;

import com.ermapper.util.JNCSDatasetPoint;

import com.ermapper.util.JNCSWorldPoint;

import com.ermapper.ecw.JNCSException;

import es.gva.cit.jmrsid.LTIMetadataRecord;

import es.gva.cit.jmrsid.MrSIDException;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.cresques.px.*;

/**

 * Soporte para los ficheros .ecw de ErMapper.

 * <br>

 * NOTA: El SDK que ermapper ha puesto a disposici?n del p?blico en java

 * es una versi?n 2.45, de 19/11/2001. Est? implementada usando JNI que

 * se apoya en tres librer?as din?micas (dll), y presenta deficiencias

 * muy graves a la hora de acceder a la informaci?n. Hasta el momento

 * hemos detectado 3 de ellas:<BR>

 *     1?.- No soporta ampliaciones superiores a 1:1. si se intenta acceder

 * a un ecw con un zoom mayor da una excepci?n del tipo

 * com.ermapper.ecw.JNCSInvalidSetViewException, que de no ser tenida encuenta

 * acaba tirando abajo la m?quina virtual de java.<BR>

 *     2?.- La longitud m?xima de l?nea que adminte el m?todo readLineRGBA es

 * de unos 2500 pixeles, lo que hace el uso para la impresi?n en formatos

 * superiorea a A4 a 300 ppp o m?s inviable.<BR>

 *     3?.- La actualizaci?n progresiva usando el interface JNCSProgressiveUpdate

 * con el JNCSFile hace que el equipo genere un error severo y se apague. Este

 * error imposibilita esta t?cnica de acceso a ECW.<BR>

 * <br>

 * Para saltarnos la limitaci?n del bug#1 pedimos la ventana correspondiente al zoom 1:1 para

 * el view que nos han puesto, y la resizeamos al tama?o que nos pide el usuario.<br>

 * Como consecuencia del bug#2, para tama?os de ventana muy grandes (los necesarios

 * para imprimir a m?s de A4 a 300DPI), hay que hacer varias llamadas al fichero con

 * varios marcos contiguos, y los devolvemos 'pegados' en una sola imagen (esto se

 * realiza de manera transparente para el usuario dentro de la llamada a updateImage.<br>

 *

 * @author "Luis W. Sevilla" <sevilla_lui@gva.es>

 */

public class EcwFile extends GeoRasterFile  implements JNCSProgressiveUpdate {

        private JNCSFile file = null;

        private boolean bErrorOnOpen = false;

        private String errorMessage = null;

        private Extent v = null;

        // Ultimo porcentaje de refresco. Se carga en el update y se

        // actualiza en el refreshUpdate

        private int lastRefreshPercent = 0;

        public EcwFile(IProjection proj, String fName) {

                super(proj, null);

                fName = DataSource.normalize(fName);

                super.setName(fName);

                extent = new Extent();

                try {

                        System.err.println("Abriendo "+fName);

                        file = new JNCSFile(fName, false);

                        //file = new JNCSFile(fName, true);

                    //file.addProgressiveUpdateListener(this);

                        load();

                        bandCount = file.numBands;

                        if ( bandCount > 2) {

                                setBand(RED_BAND,   0);

                                setBand(GREEN_BAND, 1);

                                setBand(BLUE_BAND,  2);

                        } else

                                setBand(RED_BAND|GREEN_BAND|BLUE_BAND, 0);

                } catch(Exception e) {

                  bErrorOnOpen = true;

                  errorMessage = e.getMessage();

//                  g.drawString(errorMessage, 0, 50);

                  System.err.println(errorMessage);

                  e.printStackTrace();

                }

        }

        public void setView(Extent e) { v = new Extent(e); }

        public Extent getView() { return v; }

        /**

         * Carga un ECW.

         *

         * @param fname

         */

        public GeoFile load() {

                double minX, minY, maxX, maxY;

                System.out.println("ECW size = ("+file.width+","+file.height+")\n"+

                        " inc=("+file.cellIncrementX+","+file.cellIncrementY+")\n"+

                        " datum='"+file.datum+"', proyeccion='"+file.projection+"'");

                minX = file.originX;

                maxY = file.originY;

                maxX = file.originX + (double)(file.width-1)*file.cellIncrementX;

                minY = file.originY + (double)(file.height-1)*file.cellIncrementY;

                extent = new Extent(minX, minY, maxX, maxY);

                        System.out.println(extent);

                return this;

        }

        public void close() {

                file.close(true);

                file = null;

        }

        public int getWidth() { return file.width; }

        public int getHeight() { return file.height; }

        /**

         * Trozo de imagen (Chunk) en que se divide la consulta a la librer?a,

         * para esquivar el bug#2.

         *

         * @author luisw

         */

        static class ChunkFrame {

                // Ancho m?ximo (~2500 px)

                final static int MAX_WIDTH = 1536;

                // Alto m?ximo (no hay l?mite)

                final static int MAX_HEIGHT = 1536;

                Point pos;

                Extent v;

                int width, height;

                boolean mustResize = false;

                public ChunkFrame(Extent vista, int w, int h) {

                        v = vista;

                        width = w;

                        height = h;

                }

                /**

                 * Calcula el array de chunks (trozos).

                 * @param file        Fichero ecw que hay que trocear.

                 * @param v Extent total de la vista.

                 * @param sz        Tama?o total de la vista.

                 * @return array de ChunkFrames.

                 * @throws JNCSFileNotOpenException

                 */

                public static ChunkFrame [] computeFrames(JNCSFile file, Extent v, Dimension sz) throws JNCSFileNotOpenException {

                        ChunkFrame [] frames = null;

                        ChunkFrame f = null;

                        // Calcula el n? de chunks (filas y columnas)

                        int numCol = (sz.width / MAX_WIDTH), numRow = (sz.height / MAX_HEIGHT);

                        if (sz.width -(numCol*MAX_WIDTH) > 0) numCol++;

                        if (sz.height - (numRow*MAX_HEIGHT) > 0) numRow++;

                        frames = new ChunkFrame[numCol*numRow];

                        // Coprobaci?n previa para resolver el bug#1

                        JNCSDatasetPoint ptMin = file.convertWorldToDataset(v.minX(), v.minY());

                        JNCSDatasetPoint ptMax = file.convertWorldToDataset(v.maxX(), v.maxY());

                        System.out.println("Dataset coords Width = "+(ptMax.x-ptMin.x)+", px width = "+sz.width+

                                        " px heigh = "+sz.height);

                        // BEGIN Cambiando para soportar e < 1:1

                        // TODO Mejorarlo para que los PAN con un zoom muy grande sean correctos

                        System.out.println("MAXX MINX-"+ptMax.x+","+ptMin.x);

                        if ((ptMax.x-ptMin.x)<sz.width) {

                                numCol = numRow = 1;

                                frames = new ChunkFrame[numCol*numRow];

                                f = frames[0] = new ChunkFrame(v, ptMax.x-ptMin.x, ptMin.y-ptMax.y);

                                System.out.println("Size=("+f.width+","+f.height+")");

                                f.pos = new Point(0,0);

                                f.mustResize = true;

                                f.v = new Extent(v);

                        } else {

                                // Calcula cada chunk

                                double stepx = ((double) ptMax.x-ptMin.x)/sz.getWidth();

                                double stepy = ((double) ptMax.y-ptMin.y)/sz.getHeight();

                                int h = sz.height;

                                for (int r=0; r<numRow; r++) {

                                        int w = sz.width;

                                        for (int c = 0; c<numCol; c++) {

                                                f = new ChunkFrame(null, -1, -1);

                                                // Posici?n del chunk

                                                f.pos = new Point(c*MAX_WIDTH, r*MAX_HEIGHT);

                                                // Tama?o del chunk

                                                f.width = Math.min(MAX_WIDTH, w);

                                                f.height = Math.min(MAX_HEIGHT, h);

                                                // Extent del chunk

                                                int x1 = ptMin.x+(int) (f.pos.x*stepx);

                                                int x2 = x1+(int)(f.width*stepx);

                                                int y1 = ptMax.y-(int) (f.pos.y*stepy); //ptMax.y;

                                                int y2 = y1-(int)(f.height*stepy);//ptMin.y;

                                                JNCSWorldPoint pt1 = file.convertDatasetToWorld(x1, y1);

                                                JNCSWorldPoint pt2 = file.convertDatasetToWorld(x2, y2);

                                                f.v = new Extent(pt1.x, pt1.y, pt2.x, pt2.y); // Hay que calcularlo

                                                System.out.println(" View DataSet = ("+x1+","+y1+","+x2+","+y2+")");

                                                System.out.println(" View Extent  = "+ v);

                                                System.out.println("Frame Extent  = "+ f.v);

                                                frames[r*numCol+c] = f;

                                                w -= MAX_WIDTH;

                                        }

                                        h -= MAX_HEIGHT;

                                }

                        }

                        System.out.println("Hay "+numRow+" filas y "+numCol+" columnas.");

                        return frames;

                }

        }

        /**

         * Obtiene un trozo de imagen (determinado por la vista y los par?metros.

         *

         * @param width

         * @param height

         */

        public synchronized Image updateImage(int width, int height, ICoordTrans rp) {

                // TODO reproyectar para devolver el trozo de imagen pedida sobre ...

                // la proyecci?n de destino.

                int line = 0;

                boolean mustResize = false;

                Dimension fullSize = null;

                Image ecwImage = null;

                if (file == null) return ecwImage;

                try {

                        double dFileAspect, dWindowAspect;

                        //double dWorldTLX, dWorldTLY, dWorldBRX, dWorldBRY;

                        int bandlist[];

                        int pRGBArray[] = null;

                        // Work out the correct aspect for the setView call.

                        dFileAspect = (double)v.width()/(double)v.height();

                        dWindowAspect = (double)width /(double)height;

                        if (dFileAspect > dWindowAspect) {

                          height =(int)((double)width/dFileAspect);

                        } else {

                          width = (int)((double)height*dFileAspect);

                        }

                        fullSize = new Dimension(width, height);

                        System.out.println("fullSize = ("+width+","+height+")");

                        // Peta en los peque?os ... arreglar antes de meter del todo

                        ChunkFrame frames[] = ChunkFrame.computeFrames(file, v, fullSize);

                        for (int nChunk=0; nChunk<frames.length; nChunk++) {

                                System.out.println("chunck "+nChunk+"->"+frames[nChunk]);

                        }

                        if (frames.length == 1) {

                                width = frames[0].width;

                                height = frames[0].height;

                                if(width<=0)width=1;

                                if(height<=0)height=1;

                                System.out.println("frameSize = ("+width+","+height+")");

                                //System.out.println("Cambio el ancho total a ("+width+","+height+")");

                        }

/*                        JNCSDatasetPoint ptMin = file.convertWorldToDataset(v.minX(), v.minY());

                        JNCSDatasetPoint ptMax = file.convertWorldToDataset(v.maxX(), v.maxY());

                        System.out.println("Dataset coords Width = "+(ptMax.x-ptMin.x)+", px width ="+width);

                        // BEGIN Cambiando para soportar e < 1:1

                        // TODO Mejorarlo para que los PAN con un zoom muy grande sean correctos

                        if ((ptMax.x-ptMin.x)<width) {

                                width = ptMax.x-ptMin.x;

                                height = ptMin.y-ptMax.y;

                                System.out.println("Size=("+width+","+height+")");

                                mustResize = true;

                        }*/

                        // Create an image of the ecw file.

                        if (doTransparency)

                                ecwImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);

                        else

                                ecwImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

                        pRGBArray = new int[width];

                        // Setup the view parameters for the ecw file.

                        if ( bandCount > 2) {

                                bandlist = new int[bandCount];

                                bandlist[0] = getBand(RED_BAND);

                                bandlist[1] = getBand(GREEN_BAND);

                                bandlist[2] = getBand(BLUE_BAND);

                                if (bandCount > 3)

                                        for (int i=3; i< bandCount; i++) {

                                                 bandlist[i] = 0;

                                        }

                        } else {

                                bandlist = new int[bandCount];

                                for (int i=0; i< bandCount; i++) {

                                  bandlist[i] = i;

                                }

                        }

                        for (int nChunk=0; nChunk<frames.length; nChunk++) {

                                ChunkFrame f = frames[nChunk];

                                // Set the view

                                file.setView(file.numBands, bandlist, f.v.minX(), f.v.maxY(), f.v.maxX(), f.v.minY(), f.width, f.height);

                                System.out.println("f.Size = ("+f.width+","+f.height+")+CHUNK="+nChunk);

                                // Read the scan lines

                                for (line=0; line < f.height; line++) {

                                        file.readLineRGBA(pRGBArray);

                                        // Prueba de sustituci?n de color transparente

                                        if (doTransparency) {

                                                if (line == 0) tFilter.debug = true;

                                                  tFilter.filterLine(pRGBArray);

                                                tFilter.debug = false;

                                        }

                                        //System.out.println("setRGB("+f.pos.x+","+f.pos.y+line+","+f.width+","+1+","+pRGBArray+","+0+","+f.width+")");

                                        ((BufferedImage)ecwImage).setRGB(f.pos.x, f.pos.y+line, f.width, 1, pRGBArray, 0, f.width);

                                }

                        }

                        if (frames[0].mustResize) {

                                //System.out.println("resize "+fullSize);

                                return resizeImage(fullSize, ecwImage);

                        }

                /*

                 * La excepci?n atrapada es la de 'zoom > 1:1 no valido'

                } catch (com.ermapper.ecw.JNCSInvalidSetViewException e) {

                        System.err.println(errorMessage);

                        e.printStackTrace(); */

                } catch(com.ermapper.ecw.JNCSException e) { //java.lang.ArrayIndexOutOfBoundsException:

                        bErrorOnOpen = true;

                        System.err.println("EcwFile JNCS Error en la l?nea "+line+"/"+height);

                        System.err.println(e.getMessage());

                        e.printStackTrace();

                } catch(java.lang.ArrayIndexOutOfBoundsException e) { //:

                        bErrorOnOpen = true;

                        System.err.println("EcwFile ArrayIndex Error en la l?nea "+line+"/"+height);

                        System.err.println(e.getMessage());

                        e.printStackTrace();

                } catch(Exception e) {

                        bErrorOnOpen = true;

                        errorMessage = e.getMessage();

//                        g.drawString(errorMessage, 0, 50);

                        System.err.println(errorMessage);

                        e.printStackTrace();

                }

                lastRefreshPercent = file.getPercentComplete();

                System.out.println("Leido al "+lastRefreshPercent+" %.");

                return ecwImage;

        }

        private Image resizeImage(Dimension sz, Image image) {

                return image.getScaledInstance((int) sz.getWidth(),

                        (int) sz.getHeight(), Image.SCALE_SMOOTH);

        }

        /**

         * Reproyecta el raster.

         */

        public void reProject(ICoordTrans rp) {

                // TODO metodo reProject pendiente de implementar

        }

        /**

         * Soporte para actualizaci?n de la imagen

         * @see com.ermapper.ecw.JNCSProgressiveUpdate#refreshUpdate(int, int, double, double, double, double)

         */

        public void refreshUpdate(int nWidth, int nHeight, double dWorldTLX, double dWorldTLY, double dWorldBRX, double dWorldBRY) {

                int completado = file.getPercentComplete();

                System.out.println("EcwFile: se actualiza 1: "+completado+" % completado");

                if ((updatable != null) && (lastRefreshPercent < 100)) {

                        if ((completado-lastRefreshPercent > 25) || completado == 100) {

                                lastRefreshPercent = file.getPercentComplete();

                                updatable.repaint();

                        }

                }

        }

        public void refreshUpdate(int nWidth, int nHeight, int dDatasetTLX, int dDatasetTLY, int dDatasetBRX, int dDatasetBRY) {

                System.out.println("EcwFile: se actualiza 2");

        }

        /* (non-Javadoc)

         * @see org.cresques.io.GeoRasterFile#updateImage(int, int, org.cresques.cts.ICoordTrans, java.awt.Image, int)

         */

        public Image updateImage(int width, int height, ICoordTrans rp, Image img, int flags) {

                // TODO Auto-generated method stub

                return null;

        }

        /* (non-Javadoc)

         * @see org.cresques.io.GeoRasterFile#getData(int, int)

         */

        public Object getData(int x, int y, int band) {

                //file.readLineRGBA();

                return null;

        }

        /**

         * Devuelve los datos de una ventana solicitada

         * @param ulX        coordenada X superior izda.

         * @param ulY        coordenada Y superior derecha.

         * @param sizeX        tama?o en X de la ventana.

         * @param sizeY tama?o en Y de la ventana.

         * @param band        Banda solicitada.

         */

        public byte[] getWindow(int ulX, int ulY, int sizeX, int sizeY, int band){

                //TODO Nacho: Implementar getWindow de EcwFile

                        return null;

        }

        /**

         * Obtiene la zona (Norte / Sur)

         * @return true si la zona es norte y false si es sur

         */

        public boolean getZone(){

                //TODO Nacho: Implementar getZone de EcwFile

                return false;

        }

        /**

         *Devuelve el n?mero de zona UTM

         *@return N?mero de zona

         */

        public int getUTM(){

//                TODO Nacho: Implementar getUTM de EcwFile

                return 0;

        }

        /**

         * Obtiene el sistema de coordenadas geograficas

         * @return Sistema de coordenadas geogr?ficas

         */

        public String getGeogCS(){

                //TODO Nacho: Implementar getGeogCS de EcwFile

                return new String("");

        }

        /**

         * Devuelve el tama?o de bloque

         * @return Tama?o de bloque

         */

        public int getBlockSize(){

     //TODO Nacho: Implementar getBlockSize de EcwFile

          return 1;

        }

}