Application: gvSIG desktop

/*

 * PxRaster.java

 */

package org.cresques.px;

import java.awt.Color;

import java.awt.Component;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.geom.GeneralPath;

import java.awt.geom.Point2D;

import java.awt.image.DataBuffer;

import java.awt.image.ImageObserver;

import java.lang.reflect.InvocationTargetException;

import java.util.Date;

import java.util.Vector;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.cresques.geo.Projected;

import org.cresques.geo.ViewPortData;

import org.cresques.io.GdalFile;

import org.cresques.io.GeoRasterFile;

import org.cresques.io.raster.ComputeMinMaxFilter;

import org.cresques.io.raster.ComputeMinMaxImageFilter;

import org.cresques.io.raster.RasterFilterStack;

import org.cresques.io.raster.LinearEnhancementFilter;

import org.cresques.io.raster.LinearEnhancementImageFilter;

import org.cresques.io.raster.PercentTailTrimFilter;

import org.cresques.io.raster.PercentTailTrimImageFilter;

import org.cresques.io.raster.RasterBuf;

import org.cresques.io.raster.RasterStats;

import org.cresques.io.raster.RasterToImageFilter;

import org.cresques.io.raster.TransparencyFilter;

import org.cresques.io.raster.TransparencyImageFilter;

public class PxRaster extends PxObj implements Projected {

        public GeoRasterFile geoFile = null;

        protected ImageObserver component = null;

        Vector pts = null;

        // Soporte para n bandas, visibles de 3 en 3, en ficheros separados

        protected GeoRasterFile [] colorBand = null;

        protected int rBand = 1, gBand = 2, bBand = 3;

        public RasterStats stats = new RasterStats();

        int transparente = 0x10ffff80;

        String vName = null;

        protected boolean pintaMarco = false; //true;

        IProjection proj = null;

        protected Extent extentOrig = null;

        ICoordTrans rp = null;

        public RasterFilterStack        filterStack = new RasterFilterStack(stats);

        /*public boolean transparencyFilterEnabled = false;

        public boolean enhancedFilterEnabled = false;

        public boolean tailFilterEnabled = false;*/

        /**

         * Constructor.

         * @param component

         */

        public PxRaster(ImageObserver component) {

                this.component = component;

        }

        public PxRaster(IProjection proj, String fname, ImageObserver component) {

                geoFile = GeoRasterFile.openFile(proj, fname);//loadECW(fname);

                geoFile.setUpdatable((Component) component);

                this.proj = proj;

                this.component = component;

                setExtent(geoFile.getExtent());

                geoFile.setView(geoFile.getExtent());

                extentOrig = extent;

                if (geoFile.getBandCount()>2) {

                        setBand(GeoRasterFile.RED_BAND, 0);

                        setBand(GeoRasterFile.GREEN_BAND, 1);

                        setBand(GeoRasterFile.BLUE_BAND, 2);

                } else {

                        setBand(GeoRasterFile.RED_BAND|GeoRasterFile.GREEN_BAND|GeoRasterFile.BLUE_BAND, 0);

                }

        }

        /*public PxRaster(String fname, ImageObserver component, Extent view) {

                geoFile = GeoRasterFile.openFile(null, fname);//loadECW(fname);

                this.component = component;

                setExtent(geoFile.getExtent());

                geoFile.setView(view);

                extentOrig = extent;

                //double x = 680800,y = 4128600;

                //setView(new Extent(x, y, x+4200, y-4200),"Huelva capital");

        }*/

        public PxRaster(IProjection proj, String [] fnames, ImageObserver component) {

                this.proj = proj;

                this.component = component;

                colorBand = new GeoRasterFile[fnames.length];

                for (int i=0; i<colorBand.length; i++) {

                    colorBand[i] = GeoRasterFile.openFile(proj, fnames[i]);//loadECW(fname);

                    colorBand[i].setUpdatable((Component) component);

                    setExtent(colorBand[i].getExtent());

                    colorBand[i].setView(colorBand[i].getExtent());

                }

                geoFile = colorBand[0];

                extentOrig = extent;

                if (fnames.length >= 3 || geoFile.getBandCount()>2) {

                        setBand(GeoRasterFile.RED_BAND, 0);

                        setBand(GeoRasterFile.GREEN_BAND, 1);

                        setBand(GeoRasterFile.BLUE_BAND, 2);

                } else {

                        setBand(GeoRasterFile.RED_BAND|GeoRasterFile.GREEN_BAND|GeoRasterFile.BLUE_BAND, 0);

                }

        }

        public PxRaster(GeoRasterFile eFile, ImageObserver component, Extent view) {

                geoFile = eFile;//loadECW(fname);

                geoFile.setUpdatable((Component) component);

                setProjection(geoFile.getProjection());

                this.component = component;

                setExtent(geoFile.getExtent());

                geoFile.setView(view); //geoFile.getExtent());

                extentOrig = extent;

                if (geoFile.getBandCount()>2) {

                        setBand(GeoRasterFile.RED_BAND, 0);

                        setBand(GeoRasterFile.GREEN_BAND, 1);

                        setBand(GeoRasterFile.BLUE_BAND, 2);

                } else {

                        setBand(GeoRasterFile.RED_BAND|GeoRasterFile.GREEN_BAND|GeoRasterFile.BLUE_BAND, 0);

                }

        }

        public int getBandCount() { return geoFile.getBandCount(); }

        public GeoRasterFile [] getFiles() {

                if (colorBand != null)

                        return colorBand;

                GeoRasterFile [] ret = {geoFile};

                return ret;

        }

        /**

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

                if (colorBand != null) {

                        if ((flag & GeoRasterFile.RED_BAND) == GeoRasterFile.RED_BAND)

                                rBand = nBand;

                        else if ((flag & GeoRasterFile.GREEN_BAND) == GeoRasterFile.GREEN_BAND)

                                gBand = nBand;

                        else if ((flag & GeoRasterFile.BLUE_BAND) == GeoRasterFile.BLUE_BAND)

                                bBand = nBand;

                } else

                        geoFile.setBand(flag, nBand);

        }

        /**

         * Devuelve el colorBand activo en la banda especificada.

         * @param flag banda.

         */

        public int getBand(int flag) {

                if (colorBand != null) {

                        if (flag == GeoRasterFile.RED_BAND)

                                return rBand;

                        else if (flag == GeoRasterFile.GREEN_BAND)

                                return gBand;

                        else if (flag == GeoRasterFile.BLUE_BAND)

                                return bBand;

                        else

                                return -1;

                } else

                        return geoFile.getBand(flag);

        }

        public void setDrawBorder(boolean pm) { pintaMarco = pm; }

        public String getFName() {

                return geoFile.getName();

        }

        /**

         * Devuelve la anchura total del fichero, en pixeles.

         * @return ancho en pixeles

         */

        public int getFWidth() {

                return geoFile.getWidth();

        }

        /**

         * Devuelve la altura total del fichero, en pixeles.

         * @return alto en pixeles

         */

        public int getFHeight() {

                return geoFile.getHeight();

        }

        public void setTransparency(boolean t) {geoFile.setTransparency(t);}

        public void setTransparency(int t) {geoFile.setTransparency(t);}

        public int getAlpha() { return geoFile.getAlpha(); }

        public void setExtent(Extent e) {

                super.extent = e;

                pts = new Vector();

                pts.add(proj.createPoint(e.minX(), e.minY()));

                pts.add(proj.createPoint(e.maxX(), e.minY()));

                pts.add(proj.createPoint(e.maxX(), e.maxY()));

                pts.add(proj.createPoint(e.minX(), e.maxY()));

        }

        /**

         * Cambia la vista (viewport) sobre el raster.

         *

         * @param v

         * @param vName

         */

        public void setView(Extent v, String vName) {

                geoFile.setView(v);

                this.vName = vName;

        }

        /**

         * Obtiene la escala.

         *

         * @param width

         * @param height

         * @return

         */

        public double[] getScale(int width, int height) {

                double scale[] = new double[2];

                scale[0] = ((double) width) /geoFile.getView().width();

                scale[1] = ((double) height)/geoFile.getView().height();

                return scale;

        }

        /**

         * 'Normaliza' la vista en funci?n del extent del raster.

         *

         * @param mat

         * @param sz

         */

        protected void calculateNewView(Extent sz) {

                double vx = sz.minX(), vy = sz.minY(), vx2 = sz.maxX(), vy2 = sz.maxY();

                if (sz.minX() < extent.minX()) vx = extent.minX();

                if (sz.minY() < extent.minY()) vy = extent.minY();

                if (sz.maxX() > extent.maxX()) vx2 = extent.maxX();

                if (sz.maxY() > extent.maxY()) vy2 = extent.maxY();

                if (colorBand != null) { // multiBands

                        for (int i=0; i<colorBand.length; i++)

                                colorBand[i].setView(new Extent(vx, vy, vx2, vy2));

                } else if (geoFile != null) { // Una sola banda

                        geoFile.setView(new Extent(vx, vy, vx2, vy2));

                } else { // no cargada

                        System.err.println("PxRaster.calculateNewView(): Foto no cargada.");

                }

        }

        /**

         * Dibuja el raster

         */

        public void draw(Graphics2D g, ViewPortData vp) {

                Image geoImage = null;

                long t2, t1 = new Date().getTime();

                System.out.println("PxRaster.draw(): vp.extent = "+ vp.getExtent());

                System.out.println("PxRaster.draw():    extent = "+ getExtent());

                if (vp.getExtent().minX()> extent.maxX()) return;

                if (vp.getExtent().minY()> extent.maxY()) return;

                if (vp.getExtent().maxX()< extent.minX()) return;

                if (vp.getExtent().maxY()< extent.minY()) return;

                calculateNewView(vp.getExtent());

                Extent v = geoFile.getView();

                double x = v.minX();

                double y = v.minY();

                double w = v.width();

                double h = v.height();

                System.out.println("Pinto PxRaster:" + v);

                double scalex = vp.mat.getScaleX()        /* g.getTransform().getScaleX()*/ ,

                        scaley = vp.mat.getScaleY()                /* g.getTransform().getScaleY() */;

                int wImg = (int) Math.abs(w*scalex)+1, hImg = (int) Math.abs(h*scaley)+1;

                System.out.println("Sz=("+wImg+","+hImg+"); scale=("+scalex+","+scaley+")");

                if (wImg <= 0 || hImg <= 0) return;

                Point2D.Double pt = new Point2D.Double(x, y+h);

                try {

                        System.out.println("Dibujando PxRaster: pt0 = "+pt);

                        vp.mat.transform(pt, pt);

                        System.out.println("Dibujando PxRaster: pt1 = "+pt);

                        if (colorBand == null && geoFile instanceof GdalFile &&

                                (geoFile.getDataType() != DataBuffer.TYPE_BYTE)) {

                                System.out.println("PxRaster: Has dado con un Raster de 16 bits");

                                System.out.println("Dibujando PxRaster sz=("+wImg+","+hImg+"...");

                                RasterBuf raster = ((GdalFile) geoFile).getRaster(wImg, hImg, rp);

                                t2 = new Date().getTime();

                                System.out.println("Dibujando PxRaster: "+(t2-t1)/1000D+", secs. Obteniendo"); t1 = t2;

                                geoImage = renderizeRaster(raster);

                                t2 = new Date().getTime();

                                System.out.println("Dibujando PxRaster: "+(t2-t1)/1000D+", secs. Filtrando/Renderizando");t1 = t2;

                                filterStack.setDataTypeInFilter(RasterBuf.TYPE_SHORT);

                                filterStack.setInitRasterBuf(raster);

                                g.drawImage(geoImage, (int) Math.round(pt.getX()), (int) Math.round(pt.getY()), component);

                                t2 = new Date().getTime();

                                System.out.println("Dibujando PxRaster: "+(t2-t1)/1000D+", secs. Dibujando");

                        } else if (colorBand != null) { // multiBands

                                System.out.println("Dibujando PxRaster (Multifile) ...");

                            //if (doTransparency)

                            //geoImage = new BufferedImage(wImg, hImg, BufferedImage.TYPE_INT_ARGB);

                            //else

                            //        geoImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

                        geoImage = colorBand[rBand].updateImage(wImg, hImg, rp); //, geoImage, GeoRasterFile.RED_BAND);

                        geoImage = colorBand[gBand].updateImage(wImg, hImg, rp, geoImage, GeoRasterFile.GREEN_BAND);

                        geoImage = colorBand[bBand].updateImage(wImg, hImg, rp, geoImage, GeoRasterFile.BLUE_BAND);

                        filterStack.setDataTypeInFilter(RasterBuf.TYPE_IMAGE); //Image

                        filterStack.setInitRasterBuf(geoImage);

                                geoImage = renderizeRaster(geoImage);

                        g.drawImage(geoImage, (int) Math.round(pt.getX()), (int) Math.round(pt.getY()), component);

                                t2 = new Date().getTime();

                                System.out.println("Dibujando PxRaster: "+(t2-t1)/1000D+", secs.");

                        } else if (geoFile != null) { // Una sola banda

                        geoImage = geoFile.updateImage(wImg, hImg, rp);

                                System.out.println("Dibujando PxRaster sz=("+wImg+","+hImg+"...");

                                filterStack.setDataTypeInFilter(RasterBuf.TYPE_IMAGE); //Image

                                filterStack.setInitRasterBuf(geoImage);

                                geoImage = renderizeRaster(geoImage);

                                g.drawImage(geoImage, (int) Math.round(pt.getX()), (int) Math.round(pt.getY()), component);

                                t2 = new Date().getTime();

                                System.out.println("Dibujando PxRaster: "+(t2-t1)/1000D+", secs.");

                        } else { // no cargada

                                System.err.println("Dibujando PxRaster: Foto no cargada.");

                        }

                } catch (Exception e) {

                        e.printStackTrace();

                };

                if (pintaMarco) {

                        drawMarco(g, vp);

                }

        }

        /**

         *

         * @param raster

         * @return

         */

        public Image renderizeRaster(RasterBuf raster) {

                if (filterStack != null){

                        filterStack.execute(raster);

                }

                //Aplicamos el filtro para convertir a Image

                RasterToImageFilter rti = new RasterToImageFilter();

                rti.addParam("raster", raster);

                rti.addParam("alpha", new Integer(this.getAlpha()));

                rti.execute();

                raster = null;

                return (Image)rti.getResult("raster");

        }

        /**

         *

         * @param image

         * @return

         */

        public Image renderizeRaster(Image image) {

                if (filterStack != null){

                        filterStack.execute(image);

                }

                return image;

        }

        /**

         *

         * @param g

         * @param vp

         */

        public void drawMarco(Graphics2D g, ViewPortData vp) {

//                Color color = new Color(255,222,165,128), fillColor = new Color(255,214,132,128);

                Color color = new Color(128,128,128), fillColor = new Color(255,220,220,0x20);

                GeneralPath gp = newGP(vp);

                g.setColor(fillColor);

                g.fill(gp);

                g.setColor(color);

                g.draw(gp);

        }

        private GeneralPath newGP(ViewPortData vp) {

                //if (gp != null) return;

                GeneralPath gp = new GeneralPath();

                Point2D.Double pt0 = new Point2D.Double(0.0, 0.0);

                Point2D.Double pt1 = new Point2D.Double(0.0, 0.0);

                Point2D.Double pt2 = new Point2D.Double(0.0, 0.0);

                Point2D.Double pt3 = new Point2D.Double(0.0, 0.0);

                vp.mat.transform((Point2D) pts.get(0), pt0);

                vp.mat.transform((Point2D) pts.get(1), pt1);

                vp.mat.transform((Point2D) pts.get(2), pt2);

                vp.mat.transform((Point2D) pts.get(3), pt3);

                // Aspa desde el extent

                gp.moveTo( (float) pt0.getX(), (float) pt0.getY() );

                gp.lineTo( (float) pt2.getX(), (float) pt2.getY() );

                gp.moveTo( (float) pt1.getX(), (float) pt1.getY() );

                gp.lineTo( (float) pt3.getX(), (float) pt3.getY() );

                // Extent

                gp.moveTo( (float) pt0.getX(), (float) pt0.getY() );

                gp.lineTo( (float) pt1.getX(), (float) pt1.getY() );

                gp.lineTo( (float) pt2.getX(), (float) pt2.getY() );

                gp.lineTo( (float) pt3.getX(), (float) pt3.getY() );

                if (extentOrig != extent) {

                        gp.lineTo( (float) pt0.getX(), (float) pt0.getY() );

                        Vector pts = new Vector();

                        pts.add(proj.createPoint(extentOrig.minX(), extentOrig.minY()));

                        pts.add(proj.createPoint(extentOrig.maxX(), extentOrig.minY()));

                        pts.add(proj.createPoint(extentOrig.maxX(), extentOrig.maxY()));

                        pts.add(proj.createPoint(extentOrig.minX(), extentOrig.maxY()));

                        vp.mat.transform((Point2D) pts.get(0), pt0);

                        vp.mat.transform((Point2D) pts.get(1), pt1);

                        vp.mat.transform((Point2D) pts.get(2), pt2);

                        vp.mat.transform((Point2D) pts.get(3), pt3);

                        gp.moveTo( (float) pt0.getX(), (float) pt0.getY() );

                        gp.lineTo( (float) pt1.getX(), (float) pt1.getY() );

                        gp.lineTo( (float) pt2.getX(), (float) pt2.getY() );

                        gp.lineTo( (float) pt3.getX(), (float) pt3.getY() );

                }

                gp.closePath();

                return gp;

        }

        public IProjection getProjection() { return proj; }

        public void setProjection(IProjection p) { proj = p; }

        public void reProject(ICoordTrans rp) {

                this.rp = rp.getInverted();

                System.out.println("PxRaster: reProject()");

                //geoFile.reProject(rp);

                Vector savePts = pts;

                pts = new Vector();

                extent = new Extent();

                Point2D ptDest = null;

                for (int i=0; i<savePts.size(); i++) {

                        ptDest = rp.getPDest().createPoint(0.0,0.0);

                        ptDest = rp.convert((Point2D) savePts.get(i), ptDest);

                        pts.add(ptDest);

                        extent.add(ptDest);

                }

                setProjection(rp.getPDest());

        }

}