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.awt.Component;

import java.awt.Dimension;

import java.awt.Image;

import java.awt.geom.Point2D;

import java.awt.image.DataBuffer;

import java.io.FileWriter;

import java.io.IOException;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.util.TreeMap;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.cresques.io.raster.PixelFilter;

import org.cresques.io.raster.SimplePixelFilter;

import org.cresques.px.Extent;

import org.cresques.px.IObjList;

import org.cresques.px.PxContour;

import org.cresques.px.PxObjList;

/**

 * Manejador de ficheros raster georeferenciados.

 * 

 * Esta clase abstracta es el ancestro de todas las clases que proporcionan

 * soporte para ficheros raster georeferenciados.<br>

 * Actua tambien como una 'Fabrica', ocultando al cliente la manera en que

 * se ha implementado ese manejo. Una clase nueva que soportara un nuevo

 * tipo de raster tendr?a que registrar su extensi?n o extensiones usando

 * el m?todo @see registerExtension.<br> 

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

 */

public abstract class GeoRasterFile extends GeoFile {

        /**

         * Flag que representa a la banda del Rojo

         */

        public static final int RED_BAND        = 0x01;

        /**

         * Flag que representa a la banda del Verde

         */

        public static final int GREEN_BAND        = 0x02;

        /**

         * Flag que representa a la banda del Azul

         */

        public static final int BLUE_BAND        = 0x04;

        private static TreeMap supportedExtensions = null;

        protected Component updatable = null;

        protected boolean doTransparency = false;

        /**

         * Filtro para raster.

         * Permite eliminar la franja inutil alrededor de un raster girado o de

         * un mosaico de borde irregular.

         * 

         * Funciona bien solo con raster en tonos de gris, porque se basa que

         * el valor del pixel no supere un determinado valor 'umbral' que se

         * le pasa al constructor.

         * 

         * Desarrollado para 'limpiar' los bordes de los mosaicos del SIG

         * Oleicola. Para ese caso los par?metros del constructo son:

         * PixelFilter(0x10ffff00, 0xff000000, 0xf0f0f0);

         */

        protected PixelFilter tFilter = null;

        /**

         * Asignaci?n de banda del Rojo a una banda de la imagen

         */

        protected int rBandNr = 1;

        /**

         * Asignaci?n de banda del Verde a una banda de la imagen

         */

        protected int gBandNr = 1;

        /**

         * Asignaci?n de banda del Azul a una banda de la imagen

         */

        protected int bBandNr = 1;

        /**

         * N?mero de bandas de la imagen

         */

        protected int bandCount = 1;

        private int dataType = DataBuffer.TYPE_BYTE;

        static {

                supportedExtensions = new TreeMap();

                //if (System.getProperty("os.name").toUpperCase().startsWith("WIN")) {

                        supportedExtensions.put("ecw",  EcwFile.class);

                //}

                supportedExtensions.put("tif",  TifGeoRefFile.class);

                supportedExtensions.put("tiff", TifGeoRefFile.class);

                //supportedExtensions.put("jpg",  TifGeoRefFile.class);

                supportedExtensions.put("jpg",  GdalFile.class);

                //supportedExtensions.put("png",  TifGeoRefFile.class);

                supportedExtensions.put("png",  GdalFile.class);

                supportedExtensions.put("sid",  MrSidFile.class);

        }

        /**

         * Factoria para abrir distintos tipos de raster.

         * 

         * @param proj Proyecci?n en la que est? el raster.

         * @param fName Nombre del fichero.

         * @return GeoRasterFile, o null si hay problemas.

         */

        public static GeoRasterFile openFile(IProjection proj, String fName) {

                String ext = fName.toLowerCase().substring(fName.lastIndexOf('.')+1);

                GeoRasterFile grf = null;

                // TODO NotSupportedExtensionException

                if (!supportedExtensions.containsKey(ext)) return grf;

                /**/

                Class clase = (Class) supportedExtensions.get(ext);

                Class [] args = {IProjection.class, String.class};

                try {

                        Constructor hazNuevo = clase.getConstructor(args);

                        Object [] args2 = {proj, fName};

                        grf = (GeoRasterFile) hazNuevo.newInstance(args2);

                } catch (SecurityException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                } catch (NoSuchMethodException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                } catch (IllegalArgumentException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                } catch (InstantiationException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                } catch (IllegalAccessException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                } catch (InvocationTargetException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

                /* * /

                if (ext.compareTo("ecw") == 0) {

                        grf = new EcwFile(proj, fName);

                } else if (ext.compareTo("tif") == 0 || ext.compareTo("tiff") == 0 || ext.compareTo("jpg") == 0  || ext.compareTo("png") == 0 ) {

                        grf = new TifGeoRefFile(proj, fName);

                }/ * */

                return grf;

        }

        /**

         * Registra una clase que soporta una extensi?n raster.

         * @param ext extensi?n soportada.

         * @param clase clase que la soporta.

         */

        public static void registerExtension(String ext, Class clase) {

                ext = ext.toLowerCase();

                System.out.println("RASTER: extension '"+ext+"' supported.");

                supportedExtensions.put(ext, clase);

        }

        /**

         * Tipo de fichero soportado.

         * Devuelve true si el tipo de fichero (extension) est? soportado, si no

         * devuelve false.

         * 

         * @param fName Fichero raster

         * @return  true si est? soportado, si no false.

          */

        public static boolean fileIsSupported(String fName) {

                String ext = fName.toLowerCase().substring(fName.lastIndexOf('.')+1);

                return supportedExtensions.containsKey(ext);

        }

        /**

         * Constructor

         * @param proj        Proyecci?n

         * @param name        Nombre del fichero de imagen.

         */

        public GeoRasterFile(IProjection proj, String name) {

                super(proj, name);

        }

        /**

         * Carga un fichero raster. Puede usarse para calcular el extent e instanciar 

         * un objeto de este tipo.

         */

        abstract public GeoFile load();

        /**

         * Cierra el fichero y libera los recursos.

         */

        abstract public void close();

        public static PxContour getContour(String fName, String name, IProjection proj) {

                PxContour contour = null;

                return contour;

        }

        /**

         * Obtiene el ancho de la imagen

         * @return Ancho de la imagen

         */

        abstract public int getWidth();

        /**

         * Obtiene el ancho de la imagen

         * @return Ancho de la imagen

         */

        abstract public int getHeight();

        /**

         * Reproyecci?n.

         * @param rp        Coordenadas de la transformaci?n

         */

        abstract public void reProject(ICoordTrans rp);

        /**

         * Asigna un nuevo Extent 

         * @param e        Extent

         */

        abstract public void setView(Extent e);

        /**

         * Obtiene el extent asignado

         * @return        Extent

         */

        abstract public Extent getView();

        public void setTransparency(boolean t) {

                doTransparency = t;

                tFilter = new PixelFilter(255);

        }

        /**

         * Asigna un valor de transparencia

         * @param t        Valor de transparencia

         */

        public void setTransparency(int t ) {

                doTransparency = true;

                tFilter = new SimplePixelFilter(255 - t);

        }

        public boolean getTransparency() { return doTransparency; }

        public void setAlpha(int alpha) {

                if (!doTransparency) setTransparency(255 - alpha);

                else tFilter.setAlpha(alpha);

        }

        public int getAlpha() {

                if (tFilter == null)

                        return 255;

                return tFilter.getAlpha();

        }

        public void setUpdatable(Component c) { updatable = c; }

        /**

         * Actualiza la imagen

         * @param width        ancho

         * @param height        alto

         * @param rp        Reproyecci?n

         * @return        img

         */

        abstract public Image updateImage(int width, int height, ICoordTrans rp);

        /**

         * Obtiene el valor del raster en la coordenada que se le pasa.

         * El valor ser? Double, Int, Byte, etc. dependiendo del tipo de

         * raster.

         * @param x        coordenada X

         * @param y coordenada Y

         * @return

         */

        abstract public Object getData(int x, int y, int band);

        /**

         * Actualiza la/s banda/s especificadas en la imagen.

         * @param width                ancho

         * @param height        alto

         * @param rp                reproyecci?n

         * @param img                imagen

         * @param flags                que bandas [ RED_BAND | GREEN_BAND | BLUE_BAND ]

         * @return                img

         */

        abstract public Image updateImage(int width, int height, ICoordTrans rp, Image img, int origBand, int destBand);

        public int getBandCount() { return bandCount; }

        /**

         * Asocia un colorBand al rojo, verde o azul.

         * @param flag cual (o cuales) de las bandas.

         * @param nBand        que colorBand

         */

        public void setBand(int flag, int bandNr) {

                if ((flag & GeoRasterFile.RED_BAND) == GeoRasterFile.RED_BAND) rBandNr = bandNr;

                if ((flag & GeoRasterFile.GREEN_BAND) == GeoRasterFile.GREEN_BAND) gBandNr = bandNr;

                if ((flag & GeoRasterFile.BLUE_BAND) == GeoRasterFile.BLUE_BAND) bBandNr = bandNr;

        }

        /**

         * Devuelve el colorBand activo en la banda especificada.

         * @param flag banda.

         */

        public int getBand(int flag) {

                if (flag == GeoRasterFile.RED_BAND) return rBandNr;

                if (flag == GeoRasterFile.GREEN_BAND) return gBandNr;

                if (flag == GeoRasterFile.BLUE_BAND) return bBandNr;

                return -1;

        }

        /**

         * @return Returns the dataType.

         */

        public int getDataType() {

                return dataType;

        }

        /**

         * @param dataType The dataType to set.

         */

        public void setDataType(int dataType) {

                this.dataType = dataType;

        }

        public IObjList getObjects() {

                // TODO hay que a?adir el raster a la lista de objetos

                IObjList oList = new PxObjList(proj);

                return oList;

        }

        /**

         * Calcula los par?metros de un worl file a partir de las esquinas del raster.

         *    1. X pixel size A

         *    2. X rotation term D

         *    3. Y rotation term B

         *    4. Y pixel size E

         *    5. X coordinate of upper left corner C

         *    6. Y coordinate of upper left corner F

         * where the real-world coordinates x',y' can be calculated from

         * the image coordinates x,y with the equations

         *  x' = Ax + By + C and y' = Dx + Ey + F.

         *  The signs of the first 4 parameters depend on the orientation

         *  of the image. In the usual case where north is more or less

         *  at the top of the image, the X pixel size will be positive

         *  and the Y pixel size will be negative. For a south-up image,

         *  these signs would be reversed.

         * 

         * You can calculate the World file parameters yourself based

         * on the corner coordinates. The X and Y pixel sizes can be

         *  determined simply by dividing the distance between two

         *  adjacent corners by the number of columns or rows in the image.

         *  The rotation terms are calculated with these equations:

         * 

         *  # B = (A * number_of_columns + C - lower_right_x') / number_of_rows * -1

         *  # D = (E * number_of_rows + F - lower_right_y') / number_of_columns * -1

         * 

         * @param corner (tl, tr, br, bl)

         * @return

         */

        public static double [] cornersToWorldFile(Point2D [] esq, Dimension size) {

                double a=0,b=0,c=0,d=0,e=0,f=0;

                double x1 = esq[0].getX(), y1 = esq[0].getY();

                double x2 = esq[1].getX(), y2 = esq[1].getY();

                double x3 = esq[2].getX(), y3 = esq[2].getY();

                double x4 = esq[3].getX(), y4 = esq[3].getY();

                // A: X-scale

                a = Math.abs( Math.sqrt( (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2))

                      / size.getWidth());

                // E: negative Y-scale

                e =  - Math.abs(Math.sqrt((x1-x4)*(x1-x4)+

                      (y1-y4)*(y1-y4))/size.getHeight());

                // C, F: upper-left coordinates

                c = x1;

                f = y1;

                // B & D: rotation parameters

                b = (a * size.getWidth() + c - x3 ) / size.getHeight() * -1;

                d = (e * size.getHeight() + f - y3 ) / size.getWidth() * -1;

                double [] wf = {a,d,b,e,c,f}; 

                return wf;  

        }

    public static String printWF(String fName, Point2D [] esq, Dimension sz) {

            double [] wf = GeoRasterFile.cornersToWorldFile(esq, sz);

            System.out.println("wf para "+fName);

            System.out.println(esq+"\n"+sz);

            String wfData = "";

            for (int i=0; i<6; i++)

                    wfData += wf[i]+"\n";

                System.out.println(wfData);

                return wfData;

    }

    public static void saveWF(String fName, String data) throws IOException {

            FileWriter fw = new FileWriter(fName);

            fw.write(data);

            fw.flush();

            fw.close();

    }

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

        abstract public int getBlockSize();

}