| gvSIG desktop 1

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2005 IVER T.I. and Generalitat Valenciana.

 *

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

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package com.iver.cit.gvsig.fmap.layers;

import java.awt.Dimension;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.io.File;

import javax.swing.JOptionPane;

import org.cresques.geo.ViewPortData;

import org.cresques.io.GdalFile;

import org.cresques.io.GeoRasterFile;

import org.cresques.io.rasterOld.ComputeMinMaxFilter;

import org.cresques.io.rasterOld.GreyscaleRasterToImageFilter;

import org.cresques.io.rasterOld.LinearEnhancementFilter;

import org.cresques.io.rasterOld.RasterBuf;

import org.cresques.io.rasterOld.RasterStats;

import org.cresques.io.rasterOld.RasterToImageFilter;

import org.cresques.px.Extent;

import org.cresques.px.PxRaster;

import com.hardcode.driverManager.Driver;

import com.iver.cit.gvsig.fmap.DriverException;

import com.iver.cit.gvsig.fmap.ViewPort;

import com.iver.cit.gvsig.fmap.drivers.WCSDriver;

import com.iver.cit.gvsig.fmap.drivers.wcs.FMapWCSDriver;

import com.iver.cit.gvsig.fmap.operations.Cancellable;

import es.gva.cit.jgdal.Gdal;

import es.gva.cit.jgdal.GdalBuffer;

import es.gva.cit.jgdal.GdalException;

import es.gva.cit.jgdal.GdalRasterBand;

import es.gva.cit.jgdal.GeoTransform;

import es.uji.lsi.wcs.client.ServerErrorResponseException;

/**

 * @author jaume - jaume.dominguez@iver.es

 *

 */

public class FMapWCSAdaptor {

        private boolean driverInitialized = false;

        private WCSDriver driver;

        private Rectangle2D fullExtent, bbox;

        private static final double METROSXGRADO = 111120D;

        private String coverageName;

        private String SRS;

        private String format;

        private String time;

        private String parameter;

        private String coverageQuery;

        private String lastCoverageQuery = "";

        private File fCoverage = null;

        /**

         * Establece el driver sobre el que act?a el adaptador 

         */

        public void setDriver(Driver d) {

                driver = (WCSDriver) d;

        }

        /**

         * Obtiene una referencia al objeto que implementa la interfaz vectorial con

         *  el fin de que las Strategy puedan optimizar en funci?n del driver.

         */

        public Driver getDriver(){

                return driver;

        }

        /**

         * @see com.iver.cit.gvsig.fmap.layers.LayerOperations#draw(java.awt.image.BufferedImage, java.awt.Graphics2D, com.iver.cit.gvsig.fmap.ViewPort)

         */

        public void draw(BufferedImage image, Graphics2D g,

                        ViewPort viewPort, Cancellable cancel) throws DriverException {

                if (viewPort.getExtent().getMinX() > fullExtent.getMaxX())

                        return;

                if (viewPort.getExtent().getMinY() > fullExtent.getMaxY())

                        return;

                if (viewPort.getExtent().getMaxX() < fullExtent.getMinX())

                        return;

                if (viewPort.getExtent().getMaxY() < fullExtent.getMinY())

                        return;

                setBBox(viewPort.getAdjustedExtent());

                double x = bbox.getMinX();

                double y = bbox.getMinY();

                double w = bbox.getWidth();

                double h = bbox.getHeight();

                double scalex = viewPort.getAffineTransform().getScaleX()        /* g.getTransform().getScaleX()*/ ,

                scaley = viewPort.getAffineTransform().getScaleY()                /* g.getTransform().getScaleY() */;

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

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

                setCoverageQuery(bbox, new Dimension(wImg, hImg));

                try {

                        if (lastCoverageQuery.compareTo(coverageQuery) != 0) {

                                setWCSClientCoverageQuery(coverageQuery);

                                fCoverage = driver.getCoverage();

                        }

                        if (fCoverage != null) {

                                //drawJaume(g, viewPort, fCoverage);

                                drawLWS(g, viewPort, fCoverage);

                        }

                } catch (ServerErrorResponseException e) {

                        JOptionPane.showMessageDialog(null, e.getMessage(), "Error",

                                        JOptionPane.ERROR_MESSAGE);

                        //throw new DriverException(e);

                }

        }

        /**

         * Pinta usando PxRaster

         */        

        private void drawLWS(Graphics2D g, ViewPort viewPort, File fCoverage) {

                GeoRasterFile rasterFile = new GdalFile(viewPort.getProjection(), fCoverage.getAbsolutePath());

                Extent e = new Extent(bbox);

                PxRaster raster = new PxRaster(rasterFile, null, rasterFile.getExtent());

                // ? PxRaster raster = new PxRaster(rasterFile, null, e);

                raster.setTransparency(false);

                ViewPortData vpData = new ViewPortData(viewPort.getProjection(), e, viewPort.getImageSize() );

                vpData.setMat(viewPort.getAffineTransform());

                raster.draw(g, vpData);

        }

        public void setBBox(Rectangle2D rect) {

                double x1 = rect.getMinX();

                double y1 = rect.getMinY();

                double x2 = rect.getMaxX();

                double y2 = rect.getMaxY();

                if (x1 < fullExtent.getMinX())

                        x1 = fullExtent.getMinX();

                if (y1 < fullExtent.getMinY())

                        y1 = fullExtent.getMinY();

                if (x2 > fullExtent.getMaxX())

                        x2 = fullExtent.getMaxX();

                if (y2 > fullExtent.getMaxY())

                        y2 = fullExtent.getMaxY();

                if (bbox == null)

                        bbox = new Rectangle2D.Double();

                bbox.setRect(x1, y1, x2 - x1, y2 - y1);

        }

        /**

         * Para establecer los valores iniciales que se incluiran en la consulta.

         * 

         * @param layersRectangle

         * @param srs

         * @param format

         * @param parametro

         * @param times

         */

        public void setCoverageQuery(Rectangle2D bBox, Dimension sz) {

                String coverage = "COVERAGE=" + coverageName;

                String crs = "&CRS=" + SRS;

                String boundingBox = "&BBOX=" + bBox.getMinX() + "," + bBox.getMinY()

                + "," + bBox.getMaxX() + "," + bBox.getMaxY();

                String time = this.time != null ? "&" + this.time : "";

                String param = parameter != null ? "&" + parameter : "";

                double res = bBox.getWidth() / sz.getWidth();

                // Calculo cutre para ver si son grados (o metros). Si da menos de 180

                // es que son grados y lo paso a metros. (LWS)

                if (bBox.getMaxX() < 181D)

                        res *= METROSXGRADO;

                System.out.println(" resolucion = " + res);

                String resX = "&RESX=" + res;

                String resY = "&RESY=" + res;

                //                String width = "&WIDTH="+ (int) sz.getWidth();

                //                String height = "&HEIGHT="+ (int) sz.getHeight();

                String format = "&FORMAT=" + this.format;

                coverageQuery = coverage + crs + boundingBox + time + param + resX        + resY + format;

        }

        /**

         * Recoge los par?metros de la capa y los pasa al cliente WCS. Despu?s de

         * esto, ya se puede lanzar una Getcoverage

         *  

         */

        private void setWCSClientCoverageQuery(String query) {

                lastCoverageQuery = query;

                ((FMapWCSDriver) driver).setGetCoverageParams(query);

        }

        public String getCoverageName() {

                return coverageName;

        }

        public void setCoverageName(String coverageName) {

                this.coverageName = coverageName;

        }

        public String getCoverageQuery() {

                return coverageQuery;

        }

        public void setCoverageQuery(String coverageQuery) {

                this.coverageQuery = coverageQuery;

        }

        public String getFormat() {

                return format;

        }

        public void setFormat(String format) {

                this.format = format;

        }

        public Rectangle2D getFullExtent() {

                return fullExtent;

        }

        public void setFullExtent(Rectangle2D fullExtent) {

                this.fullExtent = fullExtent;

        }

        public String getParameter() {

                return parameter;

        }

        public void setParameter(String parameter) {

                this.parameter = parameter;

        }

        public String getSRS() {

                return SRS;

        }

        public void setSRS(String srs) {

                SRS = srs;

        }

        public String getTime() {

                return time;

        }

        public void setTime(String time) {

                this.time = time;

        }

        public String getHost() {

                return ((FMapWCSDriver) driver).getHost();

        }

        public void setHost(String host) {

                ((FMapWCSDriver) driver).setHost(host);

        }

        private void drawJaume(Graphics2D g, ViewPort viewPort, File fCoverage) {

                Image coverage = renderizeRaster(getRaster(fCoverage));

                Point2D p1 = new Point2D.Double(bbox.getMinX(), bbox.getMaxY());

                //Point2D p2 = new Point2D.Double(bbox.getMaxX(), bbox.getMinY());

                viewPort.getAffineTransform().transform(p1, p1);

                //viewPort.getAffineTransform().transform(p2, p2);

                g.drawImage(coverage, (int) p1.getX(), (int) p1.getY(), null);

                /*g.setColor(Color.RED);

                 g.drawRect((int) p1.getX(), (int) p1.getY(),

                 ((int) (p2.getX() - p1.getX())), ((int) (p2.getY() - p1

                 .getY())));*/

        }

        /**

         * Computa el r?ster del fichero geogr?fico

         * 

         * @param coverage

         * @return RasterBuf

         */

        private RasterBuf getRaster(File coverage) {

                RasterBuf raster = null;

                Gdal migdal = new Gdal();

                GeoTransform gt = null;

                int ancho = 0, alto = 0;

                GdalRasterBand mirasterband = null;

                int rastercount = 0;

                try {

                        migdal.open(coverage.getAbsolutePath(), Gdal.GA_ReadOnly);

                } catch (Exception ge) {

                        ge.printStackTrace();

                }

                try {

                        gt = migdal.getGeoTransform();

                        //        System.out.println("Origin =

                        // ("+gt.adfgeotransform[0]+","+gt.adfgeotransform[3]+")");

                        //        System.out.println("Pixel Size =

                        // ("+gt.adfgeotransform[1]+","+gt.adfgeotransform[5]+")");

                } catch (GdalException e) {

                        System.out

                        .println("I can't obtain the array geoTransform for this image");

                }

                try {

                        rastercount = migdal.getRasterCount();

                        ancho = migdal.getRasterXSize();

                        alto = migdal.getRasterYSize();

                        int ngcp = migdal.getGCPCount();

                        //System.out.println("NGCP="+ngcp);

                } catch (GdalException ge) {

                        ge.printStackTrace();

                        //...

                }

                try {

                        int dataType = migdal.getRasterBand(1).getRasterDataType();

                        GdalBuffer buf = null;

                        /*

                         * Evita el problema de que haya m?s de 3 bandas en el fichero esto

                         * deberia hacerse asignando a las 3 bandas del raster una banda

                         * distinta del fichero (no necesariamente 1->0, 2->1 y 3->2

                         */

                        if (rastercount > 3)

                                rastercount = 3;

                        if (dataType == Gdal.GDT_Byte) {

                                raster = new RasterBuf(RasterBuf.TYPE_INT, ancho, alto,

                                                rastercount, null);

                                for (int iBand = 0; iBand < rastercount; iBand++) {

                                        mirasterband = migdal.getRasterBand(iBand + 1);

                                        buf = mirasterband.readRaster(0, 0, ancho, alto, ancho,

                                                        alto, dataType);

                                        for (int y = 0; y < alto; y++)

                                                for (int x = 0; x < ancho; x++)

                                                        raster.setPixelInt(x, y, iBand, buf.buffByte[y

                                                                                                                                                 * ancho + x] & 0xff);

                                }

                                migdal.close();

                        } else if (dataType == Gdal.GDT_CInt16

                                        || dataType == Gdal.GDT_UInt16

                                        || dataType == Gdal.GDT_Int16) {

                                raster = new RasterBuf(RasterBuf.TYPE_INT, ancho, alto,

                                                rastercount, null);

                                for (int iBand = 0; iBand < rastercount; iBand++) {

                                        // System.out.println("Banda:"+iBand);

                                        mirasterband = migdal.getRasterBand(iBand + 1);

                                        buf = mirasterband.readRaster(0, 0, ancho, alto, ancho,

                                                        alto, dataType);

                                        for (int y = 0; y < alto; y++)

                                                for (int x = 0; x < ancho; x++)

                                                        raster.setPixelInt(x, y, iBand, buf.buffShort[y

                                                                                                                                                  * ancho + x] & 0xffff);

                                }

                                migdal.close();

                        }

                } catch (GdalException e1) {

                        e1.printStackTrace();

                }

                return raster;

        }

        /**

         * Construye un objeto Image a partir de un RasterBuf

         * 

         * @param raster

         * @return Image

         */

        public Image renderizeRaster(RasterBuf raster) {

                RasterStats stats = new RasterStats(raster.getBandNr());

                int alpha = 255; // transparencia

                boolean debug = false;

                ComputeMinMaxFilter filter = new ComputeMinMaxFilter(raster, stats);

                LinearEnhancementFilter lEFilter = new LinearEnhancementFilter(raster,

                                stats);

                Image image = null;

                if (raster.getBandNr() == 1)

                        image = new GreyscaleRasterToImageFilter(raster, alpha).getImage();

                else

                        image = new RasterToImageFilter(raster, alpha).getImage();

                if (debug)

                        stats.pinta();

                return image;

        }        

}