| gvSIG desktop 1

/*

 * 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.px;

import java.awt.Color;

import java.awt.Component;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.geom.AffineTransform;

import java.awt.geom.GeneralPath;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.awt.image.BufferedImage;

import java.awt.image.DataBuffer;

import java.awt.image.ImageObserver;

import java.util.ArrayList;

import java.util.Date;

import java.util.Vector;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.cresques.filter.RasterFilterStack;

import org.cresques.filter.RasterFilterStackManager;

import org.cresques.filter.bands.PaletteFilter;

import org.cresques.filter.bands.PaletteStackManager;

import org.cresques.filter.bands.RasterByteToImageFilter;

import org.cresques.filter.bands.RasterDoubleToImageFilter;

import org.cresques.filter.bands.RasterFloatToImageFilter;

import org.cresques.filter.bands.RasterIntToImageFilter;

import org.cresques.filter.bands.RasterShortToImageFilter;

import org.cresques.filter.bands.RasterToImageFilter;

import org.cresques.filter.enhancement.TransparencyRange;

import org.cresques.geo.Projected;

import org.cresques.geo.ViewPortData;

import org.cresques.io.EcwFile;

import org.cresques.io.GdalFile;

import org.cresques.io.GeoRasterFile;

import org.cresques.io.data.RasterBuf;

import org.cresques.io.datastruct.Statistic;

import org.cresques.io.exceptions.SupersamplingNotSupportedException;

/**

 *

 * @author Luis W. Sevilla (sevilla_lui@gva.es)

 * @author Nacho Brodin (brodin_ign@gva.es)

 *

 */

public class PxRaster extends PxObj implements Projected {

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

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

    //protected GeoRasterFile [] colorBand = null;

    protected int gBand = 2;

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

    //protected GeoRasterFile [] colorBand = null;

    protected int bBand = 3;

    public Statistic stats = new Statistic();

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

    private BandSwitch bandSwitch = new BandSwitch();

    private boolean firstPxRaster = true;

    private final double percentFilterInit = 0.02;

    private RasterFilterStackManager stackManager = null;

    private Image geoImage = null;

    private ViewPortData lastViewPort = null;

    /**

     * Constructor.

     * @param component

     */

    public PxRaster(ImageObserver component) {

        this.component = component;

    }

    /**

     * Contructor para un solo fichero

     * @param proj        Proyeccci?n

     * @param fname Nombre del fichero

     * @param component

     */

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

        geoFile = new GeoRasterFile[1];

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

        geoFile[0].setUpdatable((Component) component);

        this.proj = proj;

        this.component = component;

        setExtent(geoFile[0].getExtent());

        setExtentForRequest(geoFile[0].getExtentForRequest());

        geoFile[0].setView(geoFile[0].getExtent());

        extentOrig = extent;

        bandSwitch.addFile(geoFile[0]);

        if (geoFile[0].getBandCount() >= 3) {

            setBand(GeoRasterFile.RED_BAND, 0);

            setBand(GeoRasterFile.GREEN_BAND, 1);

            setBand(GeoRasterFile.BLUE_BAND, 2);

        } else if (geoFile[0].getBandCount() == 2) {

            setBand(GeoRasterFile.RED_BAND, 0);

            setBand(GeoRasterFile.GREEN_BAND, 1);

            setBand(GeoRasterFile.BLUE_BAND, 1);

        } else if (geoFile[0].getBandCount() == 1) {

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

            setBand(GeoRasterFile.RED_BAND, 0);

            setBand(GeoRasterFile.GREEN_BAND, 0);

            setBand(GeoRasterFile.BLUE_BAND, 0);

        }

    }

    /**

     * Constructor para multiples ficheros

     */

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

        this.proj = proj;

        this.component = component;

        geoFile = new GeoRasterFile[fnames.length];

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

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

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

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

            setExtentForRequest(geoFile[i].getExtentForRequest());

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

            bandSwitch.addFile(geoFile[i]);

        }

        //geoFile = geoFile[0];

        extentOrig = extent;

        if ((fnames.length >= 3) || (geoFile[0].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 = new GeoRasterFile[1];

        geoFile[0] = eFile; //loadECW(fname);

        geoFile[0].setUpdatable((Component) component);

        setProjection(geoFile[0].getProjection());

        this.component = component;

        setExtent(geoFile[0].getExtent());

        setExtentForRequest(geoFile[0].getExtentForRequest());

        if(view != null){

                geoFile[0].setView(view); //geoFile.getExtent());

                extentOrig = extent;

                bandSwitch.addFile(eFile);

                if (geoFile[0].getBandCount() >= 3) {

                    setBand(GeoRasterFile.RED_BAND, 0);

                    setBand(GeoRasterFile.GREEN_BAND, 1);

                    setBand(GeoRasterFile.BLUE_BAND, 2);

                } else if (geoFile[0].getBandCount() == 2) {

                    setBand(GeoRasterFile.RED_BAND, 0);

                    setBand(GeoRasterFile.GREEN_BAND, 1);

                    setBand(GeoRasterFile.BLUE_BAND, 1);

                } else if (geoFile[0].getBandCount() == 1) {

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

                    setBand(GeoRasterFile.RED_BAND, 0);

                    setBand(GeoRasterFile.GREEN_BAND, 0);

                    setBand(GeoRasterFile.BLUE_BAND, 0);

                }

        }

    }

    /**

     * A?ade un GeoRasterFile al PxRaster

     * @param fileName Nombre del fichero

     */

    public GeoRasterFile addFile(String fileName) {

        if (geoFile != null) {

            GeoRasterFile[] listFiles = new GeoRasterFile[geoFile.length + 1];

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

                listFiles[i] = geoFile[i];

            listFiles[geoFile.length] = GeoRasterFile.openFile(proj, fileName);

            listFiles[geoFile.length].setUpdatable((Component) component);

            setExtent(listFiles[geoFile.length].getExtent());

            setExtentForRequest(listFiles[geoFile.length].getExtentForRequest());

            listFiles[geoFile.length].setView(listFiles[geoFile.length].getExtent());

            bandSwitch.addFile(listFiles[geoFile.length]);

            geoFile = listFiles;

            return listFiles[geoFile.length - 1];

        } else {

            System.err.println("PxRaster.addFile(): Imagen no cargada.");

            return null;

        }

    }

    /**

     * Devuelve el Extent de un fichero son necesidad de a?adirlo

     * al PxRaster

     * @param fileName

     * @return

     */

    public Extent testExtentFile(String fileName) {

        GeoRasterFile grf = GeoRasterFile.openFile(proj, fileName);

        return grf.getExtent();

    }

    /**

     * Obtiene el valor del pixel del Image en la posici?n wcx,wcy

     * @param wcx Posici?n x

     * @param wcx Posici?n y

     * @return valor de pixel

     */

    public int[] getPixel(double wcx, double wcy) {

        if (geoImage != null) {

            int ptox = 0;

            int ptoy = 0;

            try {

                //Extent de la imagen completa

                Extent extOrtofoto = geoFile[0].getExtent();

                //Variables q definen el extent del objeto image

                double minx = 0;

                //Variables q definen el extent del objeto image

                double miny = 0;

                //Variables q definen el extent del objeto image

                double maxx = 0;

                //Variables q definen el extent del objeto image

                double maxy = 0;

                if (lastViewPort.getExtent().getMin().getX() < extOrtofoto.minX()) {

                    minx = extOrtofoto.minX();

                } else {

                    minx = lastViewPort.getExtent().getMin().getX();

                }

                if (lastViewPort.getExtent().getMax().getX() > extOrtofoto.maxX()) {

                    maxx = extOrtofoto.maxX();

                } else {

                    maxx = lastViewPort.getExtent().getMax().getX();

                }

                if (lastViewPort.getExtent().getMin().getY() < extOrtofoto.minY()) {

                    miny = extOrtofoto.minY();

                } else {

                    miny = lastViewPort.getExtent().getMin().getY();

                }

                if (lastViewPort.getExtent().getMax().getY() > extOrtofoto.maxY()) {

                    maxy = extOrtofoto.maxY();

                } else {

                    maxy = lastViewPort.getExtent().getMax().getY();

                }

                //Comprobamos que estemos dentro del extent del Image

                if ((wcx < minx) || (wcx > maxx) || (wcy < miny) ||

                        (wcy > maxy)) {

                    int[] res = { -1, -1, -1, -1 };

                    return res;

                }

                //Pasamos a coordenadas del Image las coordenadas del mundo real

                int w = ((BufferedImage) geoImage).getWidth();

                int h = ((BufferedImage) geoImage).getHeight();

                double wcw = maxx - minx;

                double wch = maxy - miny;

                ptox = (int) (((wcx - minx) * w) / wcw);

                ptoy = (int) (((wcy - miny) * h) / wch);

                //Obtenemos el pto seleccionado del Image y extraemos el RGB

                int px = ((BufferedImage) geoImage).getRGB(ptox, h - ptoy);

                int[] values = new int[4];

                values[0] = ((px & 0xff000000) >> 24);

                values[1] = ((px & 0x00ff0000) >> 16);

                values[2] = ((px & 0x0000ff00) >> 8);

                values[3] = (px & 0x000000ff);

                return values;

            } catch (ArrayIndexOutOfBoundsException e) {

                e.printStackTrace();

            }

        }

        return null;

    }

    /**

     * Elimina un GeoRasterFile al PxRaster

     * @param finaName Nombre del fichero

     */

    public GeoRasterFile delFile(String fileName) {

        if (geoFile != null) {

            Vector grfTemp = new Vector();

            GeoRasterFile grfDelete = null;

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

                if (!fileName.endsWith(geoFile[i].getName())) {

                    grfTemp.add(geoFile[i]);

                }else

                        grfDelete = geoFile[i];

            }

            GeoRasterFile[] listFiles = new GeoRasterFile[grfTemp.size()];

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

                listFiles[i] = (GeoRasterFile) grfTemp.get(i);

            //Lo eliminamos del bandSwitch

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

                if (fileName.endsWith(geoFile[i].getName())) {

                    bandSwitch.removeFile(geoFile[i]);

                }

            }

            geoFile = listFiles;

            return grfDelete;

        } else {

            System.err.println("PxRaster.addFile(): Imagen no cargada.");

            return null;

        }

    }

    /**

     * Obtiene el tama?o de bloque

     * @return

     */

    public int getBlockSize() {

        return geoFile[0].getBlockSize();

    }

    /**

     *

     * @return

     */

    public GeoRasterFile[] getGeoFiles() {

        return geoFile;

    }

    public GeoRasterFile getGeoFile() {

        return geoFile[0];

    }

    /**

     * Obtiene el n?mero de bandas del PxRaster. Si ls longitud de geoFile es 1 quiere

     * decir que hay un solo fichero que contiene todas las bandas. Si hay m?s de un geoFile

     * el n?mero de bandas ser? la suma de todas las bandas de las im?genes que forman

     * el geoFile

     * @return N?mero de bandas

     */

    public int getBandCount() {

        return bandSwitch.getBandCount();

    }

    /**

     * Obtiene el tipo de dato del primer GeoRasterFile

     * @return

     */

    public int getDataType() {

        if (geoFile != null) {

            return geoFile[0].getDataType();

        } else {

            System.err.println("PxRaster.getDataType(): Imagen no cargada.");

        }

        return 0;

    }

    /**

     * Obtiene el vector de GeoRasterFile que componen el PxRaster

     * @return vector GeoRasterFile

     */

    public GeoRasterFile[] getFiles() {

        return geoFile;

    }

    /**

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

        bandSwitch.setBand(flag, nBand);

    }

    /**

     * Obtiene la posici?n del fichero asignado a la banda

     * que se le pasa por par?metro

     * @return

     */

    public int getPosFile(int flag) {

        if (flag == GeoRasterFile.RED_BAND) {

            return bandSwitch.getBandR().getPos();

        } else if (flag == GeoRasterFile.GREEN_BAND) {

            return bandSwitch.getBandG().getPos();

        } else if (flag == GeoRasterFile.BLUE_BAND) {

            return bandSwitch.getBandB().getPos();

        } else {

            return -1;

        }

    }

    /**

     * Devuelve el colorBand activo en la banda especificada.

     * @param flag banda.

     */

    public int getBand(int flag) {

        if (flag == GeoRasterFile.RED_BAND) {

            return bandSwitch.getBandR().getBand();

        } else if (flag == GeoRasterFile.GREEN_BAND) {

            return bandSwitch.getBandG().getBand();

        } else if (flag == GeoRasterFile.BLUE_BAND) {

            return bandSwitch.getBandB().getBand();

        } else {

            return -1;

        }

    }

    /**

     * @param pm

     */

    public void setDrawBorder(boolean pm) {

        pintaMarco = pm;

    }

    /**

     * Obtiene el nombre del fichero si solo hay uno

     * @return Nombre del fichero

     */

    public String getFName() {

        return geoFile[0].getName();

    }

    /**

     * Obtiene el nombre del fichero GeoRasterFile seleccionado

     * @param i        posici?n del GeoRasterFile

     * @return Nombre del fichero

     */

    public String getFName(int i) {

        if (geoFile != null) {

            if (i < geoFile.length) {

                return geoFile[i].getName();

            } else {

                return null;

            }

        } else {

            System.err.println("PxRaster.getFName(): Imagen no cargada.");

            return null;

        }

    }

    /**

     * Obtiene una lista de Strings con los nombres de todos los ficheros

     * que tiene el PxRaster

     * @return Lista de nombres

     */

    public String[] getLisName() {

        if (geoFile != null) {

            String[] list = new String[geoFile.length];

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

                list[i] = geoFile[i].getName();

            return list;

        } else {

            System.err.println("PxRaster.getListName(): Imagen no cargada.");

            return null;

        }

    }

    /**

     * Devuelve la anchura total del fichero, en pixeles.

     * @return ancho en pixeles

     */

    public int getFWidth() {

        if (geoFile != null) {

            return geoFile[0].getWidth();

        } else {

            System.err.println("PxRaster.getFWidth(): Imagen no cargada.");

            return 0;

        }

    }

    /**

     * Devuelve la anchura total del fichero, en pixeles.

     * @return ancho en pixeles

     */

    public int getFWidth(int i) {

        if (i < geoFile.length) {

            return geoFile[i].getWidth();

        } else {

            System.err.println("PxRaster.getFWidth(): Imagen no cargada.");

            return 0;

        }

    }

    /**

     * Devuelve la altura total del fichero, en pixeles.

     * @return alto en pixeles

     */

    public int getFHeight() {

        if (geoFile != null) {

            return geoFile[0].getHeight();

        } else {

            System.err.println("PxRaster.getFHeight(): Imagen no cargada.");

            return 0;

        }

    }

    /**

     * Devuelve la altura total del fichero, en pixeles.

     * @return alto en pixeles

     */

    public int getFHeight(int i) {

        if (i < geoFile.length) {

            return geoFile[i].getHeight();

        } else {

            System.err.println("PxRaster.getFHeight(): Imagen no cargada.");

            return 0;

        }

    }

    /**

     * Devuelve el n?mero de ficheros que componen el PxRaster

     * @return N?mero de ficheros

     */

    public int nFiles() {

        if (geoFile != null) {

            return geoFile.length;

        } else {

            return 0;

        }

    }

    /**

     * Activa o desactiva la transparencia de los ficheros que forman el PxRaster

     * @param t true o false para activar o desactivar transparencia

     */

    public void setTransparency(boolean t) {

        if (geoFile != null) {

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

                geoFile[i].setTransparency(t);

            }

        } else {

            System.err.println("PxRaster.setTransparency(): Imagen no cargada.");

            return;

        }

    }

    /**

     * Pone la transparencia de los ficheros de la imagen a un valor

     * @param t Valor para la transparencia

     */

    public void setTransparency(int t) {

        if (geoFile != null) {

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

                geoFile[i].setTransparency(t);

            }

        } else {

            System.err.println("PxRaster.setTransparency(): Imagen no cargada.");

            return;

        }

    }

    /**

     * Obtiene el alpha del primer fichero. Han de ser iguales en todos

     * los ficheros de la imagen.

     * @return alpha

     */

    public int getAlpha() {

        if (geoFile != null) {

            return geoFile[0].getAlpha();

        } else {

            System.err.println("PxRaster.getAlpha(): Imagen no cargada.");

            return 0;

        }

    }

    /**

     * Asigna el extent completo del raster. Este contiene las coordenadas reales tanto

     * para un raster rotado como sin rotar. Este extent coincide con requestExtent

     * cuando el raster no tiene rotaci?n.

     * @param Extent

     */

    public void setExtent(Extent e) {

        super.extent = e;

        if(e != null){

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

        }

    }

    /**

     * Asigna el extent sobre el que se ajusta una petici?n para que esta no exceda el

     * extent m?ximo del raster. Para un raster sin rotar ser? igual al extent

     * pero para un raster rotado ser? igual al extent del raster como si no

     * tuviera rotaci?n. Esto ha de ser as? ya que la rotaci?n solo se hace sobre la

     * vista y las peticiones han de hacerse en coordenadas de la imagen sin shearing

     * aplicado.

     * @param Extent

     */

    public void setExtentForRequest(Extent e) {

        super.requestExtent = e;

        if(e != null){

                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 extent

     * @param vName nombre

     */

    public void setView(Extent v, String vName) {

        if (geoFile != null) {

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

                geoFile[i].setView(v);

            }

        } else {

            System.err.println("PxRaster.setView(): Imagen no cargada.");

            return;

        }

        this.vName = vName;

    }

    /**

     * Obtiene la escala.

     *

     * @param width

     * @param height

     * @return

     */

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

        double[] scale = new double[2];

        if (geoFile != null) {

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

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

            return scale;

        } else {

            System.err.println("PxRaster.getScale(): Imagen no cargada.");

            return null;

        }

    }

    /**

     * Transforma la petici?n que est? en coordenadas de la imagen sin rotar a coordenadas de la imagen rotada

     * para que sea posible el calculo de la caja m?nima de inclusi?n. La coordenada superior izquierda de esta

     * ser? la que se use para posicionar la imagen sobre el graphics aplicandole la transformaci?n de la la vista.

     * @param v

     * @return

     */

    private Point2D coordULRotateRaster(double[] v){

        double vx = v[0];

        double vy = v[1];

        double vx2 = v[2];

        double vy2 = v[3];

            if (geoFile != null) {

                double[] transf = geoFile[0].getTransform();

                Point2D ul = new Point2D.Double(vx - requestExtent.minX(), vy2 - requestExtent.maxY());

                Point2D ur = new Point2D.Double(vx2 - requestExtent.minX(), vy2 - requestExtent.maxY());

                Point2D ll = new Point2D.Double(vx - requestExtent.minX(), vy - requestExtent.maxY());

                Point2D lr = new Point2D.Double(vx2 - requestExtent.minX(), vy - requestExtent.maxY());

                   if(transf != null && (transf[2] != 0 || transf[4] != 0)){

                double shearX = transf[2] / transf[1];

                double shearY = transf[4] / transf[5];

                        AffineTransform at = new AffineTransform();

                        at.setToShear(-shearX, -shearY);

                        at.transform(ul, ul);

                        at.transform(ur, ur);

                        at.transform(ll, ll);

                        at.transform(lr, lr);

                        ul = new Point2D.Double(ul.getX() + requestExtent.minX(), ul.getY() + requestExtent.maxY());

                        ur = new Point2D.Double(ur.getX() + requestExtent.minX(), ur.getY() + requestExtent.maxY());

                        ll = new Point2D.Double(ll.getX() + requestExtent.minX(), ll.getY() + requestExtent.maxY());

                        lr = new Point2D.Double(lr.getX() + requestExtent.minX(), lr.getY() + requestExtent.maxY());

                        vx2 = Math.max(Math.max(ul.getX(), ur.getX()), Math.max(ll.getX(), lr.getX()));

                        vy2 = Math.max(Math.max(ul.getY(), ur.getY()), Math.max(ll.getY(), lr.getY()));

                        vx = Math.min(Math.min(ul.getX(), ur.getX()), Math.min(ll.getX(), lr.getX()));

                        vy = Math.min(Math.min(ul.getY(), ur.getY()), Math.min(ll.getY(), lr.getY()));

                }

                   return ul;

        }

            return null;

    }

    /**

     * Ajusta la extensi?n pasada por par?metro y que corresponde al extent de la vista donde

     * se va a dibujar a los valores m?ximos y m?nimos de la imagen. Esto sirve para que la

     * petici?n al driver nunca sobrepase los l?mites de la imagen tratada aunque la vista

     * donde se dibuje sea de mayor tama?o.

     *

     * Antes de realizar este ajuste hay que transformar la petici?n que puede corresponder a

     * una imagen rotada a las coordenadas de la imagen sin rotar ya que las peticiones al

     * driver hay que hacerlas con estas coordenadas. Para esto trasladamos la petici?n al origen

     * de la imagen (esquina superior izquierda), aplicamos la transformaci?n inversa a las cuatro

     * esquinas obtenidas y volvemos a trasladar a su posici?n original.

     *

     * Se usa la transformaci?n inversa para trasladar un punto del raster rotado al mismo sin

     * rotar y la transformaci?n af?n normal para trasladar un punto sin rotar a uno rotado.

     *

     * @param sz Extent completo de la vista donde se va a dibujar.

     */

    protected double[] calculateNewView(ViewPortData vp) {

            Extent sz = vp.getExtent();

        double vx = sz.minX();

        double vy = sz.minY();

        double vx2 = sz.maxX();

        double vy2 = sz.maxY();

        //Trasladamos la petici?n si est? rotada a su posici?n sin rotar

        if (geoFile != null) {

                double[] transf = geoFile[0].getTransform();

                Point2D ul = new Point2D.Double(vx - requestExtent.minX(), vy2 - requestExtent.maxY());

                Point2D ur = new Point2D.Double(vx2 - requestExtent.minX(), vy2 - requestExtent.maxY());

                Point2D ll = new Point2D.Double(vx - requestExtent.minX(), vy - requestExtent.maxY());

                Point2D lr = new Point2D.Double(vx2 - requestExtent.minX(), vy - requestExtent.maxY());

                   if(transf != null && (transf[2] != 0 || transf[4] != 0)){

                double shearX = transf[2] / transf[1];

                double shearY = transf[4] / transf[5];

                        AffineTransform at = new AffineTransform();

                        at.setToShear(-shearX, -shearY);

                        try {

                                at.inverseTransform(ul, ul);

                                at.inverseTransform(ur, ur);

                                at.inverseTransform(ll, ll);

                                at.inverseTransform(lr, lr);

                                } catch (NoninvertibleTransformException e) {

                                        e.printStackTrace();

                                }

                        ul = new Point2D.Double(ul.getX() + requestExtent.minX(), ul.getY() + requestExtent.maxY());

                        ur = new Point2D.Double(ur.getX() + requestExtent.minX(), ur.getY() + requestExtent.maxY());

                        ll = new Point2D.Double(ll.getX() + requestExtent.minX(), ll.getY() + requestExtent.maxY());

                        lr = new Point2D.Double(lr.getX() + requestExtent.minX(), lr.getY() + requestExtent.maxY());

                        vx2 = Math.max(Math.max(ul.getX(), ur.getX()), Math.max(ll.getX(), lr.getX()));

                        vy2 = Math.max(Math.max(ul.getY(), ur.getY()), Math.max(ll.getY(), lr.getY()));

                        vx = Math.min(Math.min(ul.getX(), ur.getX()), Math.min(ll.getX(), lr.getX()));

                        vy = Math.min(Math.min(ul.getY(), ur.getY()), Math.min(ll.getY(), lr.getY()));

                }

        }

        if (vx < requestExtent.minX())

            vx = requestExtent.minX();

        if (vy < requestExtent.minY())

            vy = requestExtent.minY();

        if (vx2 > requestExtent.maxX())

            vx2 = requestExtent.maxX();

        if (vy2 > requestExtent.maxY())

            vy2 = requestExtent.maxY();

        if (geoFile != null) {

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

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

        } else {

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

        }

        double[] adjustedExtent = {vx, vy, vx2, vy2};

        return adjustedExtent;

    }

    /**

     * Aplica transparencia leyendo los metadatos

     */

    private void setTransparencyByPixel(){

            if(geoFile[0].getMetadata() != null){

                    if (stackManager == null){

                        TransparencyRange[] noData = geoFile[0].getMetadata().parserNodataInMetadata();

                        if(noData != null){

                        ArrayList entries = new ArrayList();

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

                                  entries.add(noData[i]);

                        stackManager = new RasterFilterStackManager(filterStack);

                        stackManager.addTransparencyFilter(        entries, 0x0, 0xff, 0xff, 0xff);

                        }

                        TransparencyRange noDataValue = geoFile[0].getMetadata().parserNodataByBand();

                        if(noData == null  && noDataValue != null){

                        ArrayList entries = new ArrayList();

                        entries.add(noDataValue);

                        stackManager = new RasterFilterStackManager(filterStack);

                        stackManager.addTransparencyFilter(        entries, 0x0, 0xff, 0xff, 0xff);

                        }

                    }

        }

    }

    /**

     * Dibuja el raster sobre el Graphics. Para ello debemos de pasar el viewPort que corresponde a la

     * vista. Este viewPort es ajustado a los tama?os m?ximos y m?nimos de la imagen por la funci?n

     * calculateNewView. Esta funci?n tambi?n asignar? la vista a los drivers. Posteriormente se calcula

     * el alto y ancho de la imagen a dibujar (wImg, hImg), as? como el punto donde se va a pintar dentro

     * del graphics (pt). Finalmente se llama a updateImage del driver para que pinte y una vez dibujado

     * se pasa a trav?s de la funci?n renderizeRaster que es la encargada de aplicar la pila de filtros

     * sobre el Image que ha devuelto el driver.

     *

     * Para calcular en que coordenada pixel (pt) se empezar? a pintar el BufferedImage con el raster le?do

     * se aplica sobre la esquina superior izquierda de esta la matriz de transformaci?n del ViewPortData

     * pasado vp.mat.transform(pt, pt). Si el raster no est? rotado este punto es el resultante de la

     * funci?n calculateNewView que devuelve la petici?n ajustada al extent de la imagen (sin rotar). Si

     * el raster est? rotado necesitaremos para la transformaci?n el resultado de la funci?n coordULRotateRaster.

     * Lo que hace esta ?ltima es colocar la petici?n que ha sido puesta en coordenadas de la imagen sin rotar

     * (para pedir al driver de forma correcta) otra vez en coordenadas de la imagen rotada (para calcular su

     * posici?n de dibujado).

     *

     * Para dibujar sobre el Graphics2D el raster rotado aplicaremos la matriz de transformaci?n con los

     * par?metros de Shear sobre este Graphics de forma inversa. Como hemos movido el fondo tendremos que

     * recalcular ahora el punto donde se comienza a dibujar aplicandole la transformaci?n sobre este

     * at.inverseTransform(pt, pt);. Finalmente volcamos el BufferedImage sobre el Graphics volviendo a dejar

     * el Graphics en su posici?n original al acabar.

     *

     * @param g Graphics sobre el que se pinta

     * @param vp ViewPort de la extensi?n a dibujar

     */

    public synchronized void draw(Graphics2D g, ViewPortData vp) {

        geoImage = null;

        long t2;

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

        lastViewPort = vp;

        if ((vp.getExtent().minX() > extent.maxX()) ||

                (vp.getExtent().minY() > extent.maxY()) ||

                (vp.getExtent().maxX() < extent.minX()) ||

                (vp.getExtent().maxY() < extent.minY())) {

            return;

        }

        double[] adjustedExtent = calculateNewView(vp);

        Point2D p2d = coordULRotateRaster(adjustedExtent);

        Extent v = geoFile[0].getView();

        double x = v.minX();

        double y = v.minY();

        double w = v.width();

        double h = v.height();

        double scalex = vp.mat.getScaleX();

        double scaley = vp.mat.getScaleY();

        /*int wImg = (int) Math.round(Math.abs(w * scalex));

        int hImg = (int) Math.round(Math.abs(h * scaley));*/

        int wImg = (int) Math.round(Math.abs((adjustedExtent[2] - adjustedExtent[0]) * scalex));

        int hImg = (int) Math.round(Math.abs((adjustedExtent[3] - adjustedExtent[1]) * scaley));

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

            return;

        //Para la transformaci?n usamos el extent que ha ajustado la funci?n calculateNewView y no usamos

        //el getView porque el getView puede haber  sufrido una transformaci?n en caso de que exista

        //fichero .rmf. En caso de no existir este fichero ser?a lo mismo aplicar la funci?n:

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

        double[] transf = bandSwitch.getBandR().getGeoRasterFile().getTransform();

        Point2D.Double pt = null;

               if(transf != null && (transf[2] != 0 || transf[4] != 0)) //Esta rotada

                       pt =  new Point2D.Double(p2d.getX(), p2d.getY());

               else        //No est? rotada

                       pt = new Point2D.Double(adjustedExtent[0], adjustedExtent[3]);

        try {

            vp.mat.transform(pt, pt);

            setTransparencyByPixel();

            if ((geoFile != null) && geoFile[0] instanceof GdalFile &&

                    (geoFile[0].getDataType() != DataBuffer.TYPE_BYTE)) {

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

                t2 = new Date().getTime();

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

                t1 = t2;

                filterStack.setInitRasterBuf(raster);

                //Si la imagen es de 16 bits lleva un filtro de realce por defecto

                if (stackManager == null){

                    stackManager = new RasterFilterStackManager(filterStack);

                    stackManager.addEnhancedFilter(false, geoFile[0].getName());

                    stackManager.removeFilter(stackManager.getTypeFilter("computeminmax"));

                    stackManager.addTailFilter(this.percentFilterInit, 0D, true);

                }

                //Para imagenes de una banda replicamos esta en el resto del rasterBuf

                if(raster.getBandCount() == 1){

                        raster.replicateBand(0, 1);

                        raster.replicateBand(0, 2);

                }

                geoImage = renderizeRaster(raster, vp, v);

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

            } else if((geoFile != null) && (geoFile.length > 1) &&

                            (!bandSwitch.getBandR().getGeoRasterFile().getName().equals(bandSwitch.getBandG().getGeoRasterFile().getName()) ||

                            !bandSwitch.getBandR().getGeoRasterFile().getName().equals(bandSwitch.getBandB().getGeoRasterFile().getName()) ||

                            !bandSwitch.getBandG().getGeoRasterFile().getName().equals(bandSwitch.getBandB().getGeoRasterFile().getName()))

                            ) { // multiFiles

                System.out.println("Dibujando PxRaster (Multifile) ... Bands " +