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.Image;

import java.awt.geom.Point2D;

import java.awt.image.BufferedImage;

import java.io.IOException;

import java.util.Vector;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.cresques.io.MrSidNative.Contour;

import org.cresques.io.data.BandList;

import org.cresques.io.data.RasterBuf;

import org.cresques.io.exceptions.SupersamplingNotSupportedException;

import org.cresques.px.Extent;

import es.gva.cit.jgdal.GdalBuffer;

import es.gva.cit.jgdal.GdalException;

import es.gva.cit.jgdal.GdalRasterBand;

import es.gva.cit.jmrsid.LTIColorSpace;

import es.gva.cit.jmrsid.LTIDataType;

import es.gva.cit.jmrsid.LTIGeoCoord;

import es.gva.cit.jmrsid.LTIImageStage;

import es.gva.cit.jmrsid.LTIMetadataDatabase;

import es.gva.cit.jmrsid.LTIMetadataRecord;

import es.gva.cit.jmrsid.LTIPixel;

import es.gva.cit.jmrsid.LTIScene;

import es.gva.cit.jmrsid.LTISceneBuffer;

import es.gva.cit.jmrsid.LTIUtils;

import es.gva.cit.jmrsid.MrSIDException;

import es.gva.cit.jmrsid.MrSIDImageReader;

/**

 * Soporte para los fichero MrSID de Lizardtech

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

 */

class MrSidNative extends MrSIDImageReader {

    static boolean WITH_OVERVIEWS = true;

    /**

     * Contorno en coordenadas geogr?ficas. (y Extent del raster).

     */

    public Contour                                         esq = new Contour();

    public int                                                 width = 0;

    public int                                                 height = 0;

    public double                                         originX = 0D;

    public double                                         originY = 0D;

    public String                                         version = "";

    public LTIMetadataDatabase                 metadata;

    public LTIPixel                                 pixel = null;

    private int                                         alpha = 0;

    protected int                                         rBandNr = 1;

    protected int                                         gBandNr = 2;

    protected int                                         bBandNr = 3;

    protected byte[]                                 bandR;

    protected byte[]                                 bandG;

    protected byte[]                                 bandB;

    private int                                         dataType = LTIDataType.LTI_DATATYPE_UINT8;

    //View

    private double                                         zoomoverview = 0.0;

    private int                                         eColorSpace;

    private int                                         eSampleType;

    private int                                         noverviews;

    public int                                                 xini;

    public int                                                 yini;

    /**

     * Ancho y alto de la overview

     */

    public int                                                 anchoOver;

    public int                                                 altoOver;

    public int                                                 blocksize = 1;

    /**

     * N?mero de bandas de la imagen

     */

    public int                                                 nbands;

    /**

     * N?mero de overview actualmente seleccionada

     */

    private int                                         currentOverview = -1;

    /**

     * Posici?n de la esquina superior izquierda en coordenadas pixel

     */

    private double                                         currentViewY = -1;

    private double                                         currentViewX = 0D;

    /**

     * Ancho y alto de la im?gen (pixeles en pantalla)

     */

    private int                                         currentViewWidth = -1;

    private int                                         currentViewHeight = -1;

    /**

     * Ancho y alto de la imagen completa en pixeles

     */

    private int                                         currentFullWidth = -1;

    private int                                         currentFullHeight = -1;

    /**

     * Escala del viewport en X e Y

     */

    private double                                         viewportScaleX = 0D;

    private double                                         viewportScaleY = 0D;

    /**

     * ?ltimo extent de la ventana seleccionada por el usuario. Este extent corresponde al de la

     * imagen, no al del viewport de la vista.

     */

    private double[]                                currentImageView = new double[4];

    /**

     * 

     */

        public int[]                                        stepArrayX = null, stepArrayY = null;

        /**

         * 

         */

        public boolean                                  isSupersampling = false;

        /**

         * Nombre del fichero MrSID

         */

        private String                                        fileName = null;

    /**

     * Constructor

     * @param fName

     * @throws MrSIDException

     * @throws IOException

     */

    public MrSidNative(String fName) throws MrSIDException, IOException {

        super(fName);

        init(fName);

    }

    /**

     * Inicializa las variables de instancia con los valores de la imagen

     * @param fName

     * @throws MrSIDException

     * @throws IOException

     */

    private void init(String fName) throws MrSIDException, IOException {

        this.initialize();

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

        fileName = fName;

        width = this.getWidth();

        height = this.getHeight();

        eSampleType = this.getDataType();

        nbands = this.getNumBands();

        eColorSpace = this.getColorSpace();

        noverviews = this.getNumLevels();

        metadata = this.getMetadata();

        double ox = 0D;

        double oy = 0D;

        double resx = 0D;

        double resy = 0D;

        LTIGeoCoord geoc = this.getGeoCoord();

        ox = geoc.getX();

        oy = geoc.getY();

        resx = geoc.getXRes();

        resy = geoc.getYRes();

        esq.add(new Point2D.Double(ox, oy));

        esq.add(new Point2D.Double(ox + (resx * width), oy));

        esq.add(new Point2D.Double(ox, oy + (resy * height)));

        esq.add(new Point2D.Double(ox + (resx * width), oy + (resy * height)));

        blocksize = this.getStripHeight();

    }

    /**

     * Asigna el valor de Alpha

     * @param a        alpha

     */

    public void setAlpha(int a) {

        alpha = a;

    }

    /**

     * Asigna el tipo de datos

     * @param dt        tipo de datos

     */

    public void setDataType(int dt) {

        dataType = dt;

    }

    /**

     * Obtiene un punto 2D con las coordenadas del raster a partir de uno en coordenadas

     * del punto real.

     * @param pt        punto en coordenadas del punto real

     * @return        punto en coordenadas del raster

     */

    public Point2D worldToRaster(Point2D pt) {

        double x = (((double) currentFullWidth) / (esq.maxX - esq.minX)) * (pt.getX() - esq.minX);

        double y = (((double) currentFullHeight) / (esq.maxY - esq.minY)) * (esq.maxY - pt.getY());

        Point2D ptRes = new Point2D.Double(x, y);

        return ptRes;

    }

    /**

     * Calcula el overview a usar de la imagen y el viewport a partir del ancho, alto y

     * coordenadas del mundo real

     * @param dWorldTLX        Coordenada X superior izquierda

     * @param dWorldTLY        Coordenada Y superior izquierda

     * @param dWorldBRX        Coordenada X inferior derecha

     * @param dWorldBRY        Coordenada Y inferior derecha

     * @param nWidth        ancho

     * @param nHeight        alto

     */

    public void setView(double dWorldTLX, double dWorldTLY, double dWorldBRX,

                        double dWorldBRY, int nWidth, int nHeight) {

            currentImageView[0] = dWorldTLX;

            currentImageView[1] = dWorldTLY;

            currentImageView[2] = dWorldBRX;

            currentImageView[3] = dWorldBRY;

        //Ancho y alto de la im?gen en pixeles (pixeles de la overview)

        currentFullWidth = width;

        currentFullHeight = height;

        //Ventana de la imagen. (en tama?o completo)

        //tl->esq sup izda en pixeles

        //br->esq inf der en pixeles

        Point2D tl = worldToRaster(new Point2D.Double(dWorldTLX, dWorldTLY));

        Point2D br = worldToRaster(new Point2D.Double(dWorldBRX, dWorldBRY));

        //Ancho y alto de la im?gen (pixeles en pantalla)

        currentViewWidth = nWidth;

        currentViewHeight = nHeight;

        //Posici?n de la esquina superior izquierda en coordenadas pixel

        currentViewX = tl.getX();

        currentViewY = tl.getY();

        //Escala de la vista en X e Y

        viewportScaleX = (double) currentViewWidth / (br.getX() - tl.getX());

        viewportScaleY = (double) currentViewHeight / (br.getY() - tl.getY());

        try {

            // calcula el overview a usar

            int[] dims = null;

            double zoom = 1.0;

            zoomoverview = 1.0;

            currentOverview = -1;

            if (WITH_OVERVIEWS && ((noverviews - 1) > 0)) {

                for (int i = (noverviews - 1); i > 0; i--) {

                    zoom = LTIUtils.levelToMag(i);

                    dims = this.getDimsAtMag(zoom);

                    if (dims[0] > (this.getWidth() * viewportScaleX)) {

                        currentOverview = i;

                        zoomoverview = zoom;

                        viewportScaleX /= zoomoverview;

                        viewportScaleY /= zoomoverview;

                        currentFullWidth = dims[0];

                        currentFullHeight = dims[1];

                        tl = worldToRaster(new Point2D.Double(dWorldTLX, dWorldTLY));

                        currentViewX = tl.getX();

                        currentViewY = tl.getY();

                        break;

                    }

                }

            }

            setDataType(eSampleType);

        } catch (MrSIDException e) {

            e.printStackTrace();

        }

    }

    /**

     * Muestra alguna informaci?n para la depuraci?n

     */

    void pintaInfo() {

        try {

            System.out.println("GeoTransform:");

            LTIGeoCoord geoc = this.getGeoCoord();

            System.out.println("  param[0]=" + geoc.getX());

            System.out.println("  param[0]=" + geoc.getY());

            System.out.println("  param[0]=" + geoc.getXRes());

            System.out.println("  param[0]=" + geoc.getYRes());

            System.out.println("  param[0]=" + geoc.getXRot());

            System.out.println("  param[0]=" + geoc.getYRot());

            System.out.println("Metadata:");

            LTIMetadataDatabase metadata = this.getMetadata();

            for (int i = 0; i < metadata.getIndexCount(); i++) {

                LTIMetadataRecord rec = null;

                rec = metadata.getDataByIndex(i);

                System.out.println(rec.getTagName());

                if (rec.isScalar()) {

                    System.out.println(rec.getScalarData());

                } else if (rec.isVector()) {

                    String[] s = rec.getVectorData();

                    for (int j = 0; j < s.length; j++)

                        System.out.println("V" + j + "->" + s[j]);

                } else if (rec.isArray()) {

                    String[] s = rec.getArrayData();

                    for (int j = 0; j < s.length; j++)

                        System.out.println("A" + j + "->" + s[j]);

                } else {

                    System.out.println("");

                }

            }

        } catch (MrSIDException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }

    void pintaPaleta() {

    }

    public LTISceneBuffer readBuffer(int x, int y, int SceneWidth, int SceneHeight)throws MrSIDException{

            LTISceneBuffer buffer = null;

            LTIScene scene = new LTIScene(x, y, SceneWidth, SceneHeight, zoomoverview);

            buffer = new LTISceneBuffer(pixel, SceneWidth, SceneHeight, true);

            ((LTIImageStage) this).read(scene, buffer);

            return buffer;

    }

    /**

         * Esta funci?n calcula los arrays de steps en X e Y para que cuando hay supersampleo 

         * se aplique el filtro solo a la esquina superior izquierda de cada pixel. 

         */

        private void calcArraySteps(int w, int h, double stepX, double stepY, double offsetX, double offsetY){

                if(stepX < 1 && stepY < 1){

                        isSupersampling = true;

                        this.stepArrayX = new int[w];

                        for (double j = offsetX; j < w; j += stepX) 

                                        stepArrayX[(int)(j)] ++;

                        this.stepArrayY = new int[h];

                        for (double j =  offsetY; j < h; j += stepY) 

                                stepArrayY[(int)(j)] ++;

                }else{

                        isSupersampling = false;

                        this.stepArrayX = this.stepArrayY = null;

                }

        }

    /**

     * Lee la escena de la imagen correspondiente a la vista seleccionada con

     * currentView a trav?s de la libreria de MrSid. Esta escena es cargada sobre

     * un buffer y asignada al par?metro de salida.

     * @param line        Escena leida

     * @throws MrSIDException Lanzada si ocurre un error en la lectura de la escena

     */

    public void readScene(int[] line) throws MrSIDException {

            //Posici?n de inicio de la escena en entero para la petici?n a la libreria

        int x = (int) Math.floor(currentViewX);

        int y = (int) Math.floor(currentViewY);

        //Ancho y alto de la escena en pixeles

        int SceneWidth = 0;

        int SceneHeight = 0;

        try {

                        SceneWidth = (int) Math.ceil((((double) currentViewWidth) / viewportScaleX) + 1);

                        if (SceneWidth > currentFullWidth)

                                SceneWidth = currentFullWidth;

                        SceneHeight = (int) Math.ceil((((double) currentViewHeight) / viewportScaleY) + 1);

                    if (SceneHeight > currentFullHeight)

                               SceneHeight = currentFullHeight;

            if (SceneWidth == 0) 

                SceneWidth = 1;

            if (SceneHeight == 0)

                SceneHeight = 1;

            if (pixel == null)

                pixel = new LTIPixel(eColorSpace, nbands, eSampleType);

            LTISceneBuffer buffer = null;

            boolean  sizeOk = false;

                        while (!sizeOk){

                                sizeOk = true;

                    try {

                            buffer = readBuffer(x, y, SceneWidth, SceneHeight);

                    } catch (MrSIDException ex) {

                            SceneWidth-- ;

                            try{

                                    buffer = readBuffer(x, y, SceneWidth, SceneHeight);

                            } catch (MrSIDException ex1) {

                                    SceneWidth++;

                                    SceneHeight--;

                                try{

                                        buffer = readBuffer(x, y, SceneWidth, SceneHeight);

                                } catch (MrSIDException ex2) {

                                        SceneWidth-- ;

                                    try{

                                            buffer = readBuffer(x, y, SceneWidth, SceneHeight);

                                    } catch (MrSIDException ex3) {

                                            sizeOk = false;

                                    }

                                }

                            }

                    }

                        }

            if ((dataType == LTIDataType.LTI_DATATYPE_UINT8) ||

                    (dataType == LTIDataType.LTI_DATATYPE_SINT8) ||

                    (dataType == LTIDataType.LTI_DATATYPE_SINT16) ||

                    (dataType == LTIDataType.LTI_DATATYPE_SINT32) ||

                    (dataType == LTIDataType.LTI_DATATYPE_UINT16) ||

                    (dataType == LTIDataType.LTI_DATATYPE_UINT32)) {

                int kd;

                int k;

                double scaleX = 1 / viewportScaleX;

                double scaleY = 1 / viewportScaleY;

                int alpha = (this.alpha & 0xff) << 24;

                if (rBandNr == 1) {

                    bandR = buffer.buf1;

                } else if (rBandNr == 2) {

                    bandR = buffer.buf2;

                } else if (rBandNr == 3) {

                    bandR = buffer.buf3;

                }

                if (gBandNr == 1) {

                    bandG = buffer.buf1;

                } else if (gBandNr == 2) {

                    bandG = buffer.buf2;

                } else if (gBandNr == 3) {

                    bandG = buffer.buf3;

                }

                if (bBandNr == 1) {

                    bandB = buffer.buf1;

                } else if (bBandNr == 2) {

                    bandB = buffer.buf2;

                } else if (bBandNr == 3) {

                    bandB = buffer.buf3;

                }

                //Desplazamiento para la X y la Y leidas. Estas tienen efecto cuando un pixel no empieza a visualizarse

                //justo en su esquina superior izquierda y tiene que ser cortado en la visualizaci?n.

                double offsetX = Math.abs(currentViewX - ((int)currentViewX));

                double offsetY = Math.abs(currentViewY - ((int)currentViewY));

                calcArraySteps(SceneWidth, SceneHeight, scaleX, scaleY, offsetX, offsetY);

                for (int y1 = 0; y1 < currentViewHeight; y1++){

                   for (int x1 = 0; x1 < currentViewWidth; x1++){

                      kd = (y1 * currentViewWidth) + x1;

                      k = (((int) ((y1 * scaleY) + offsetY)) * SceneWidth) + (int) ((x1 * scaleX) + offsetX);

                      try {

                            line[kd] = alpha + ((0xff & bandR[k]) << 16) + ((0xff & bandG[k]) << 8) + (0xff & bandB[k]);

                      } catch (java.lang.ArrayIndexOutOfBoundsException e) {

                      }

                   }

                }

            }

            buffer = null;

        } catch (MrSIDException e) {

            e.printStackTrace();

        }

    }

        /**

         * Lee una ventana de datos sin resampleo a partir de coordenadas en pixeles.

         * @param buf Buffer donde se almacenan los datos

         * @param bandList Lista de bandas que queremos leer y sobre que bandas del buffer de destino queremos escribirlas

         * @param x Posici?n X en pixeles

         * @param y Posici?n Y en pixeles

         * @param w Ancho en pixeles

         * @param h Alto en pixeles

         * @throws GdalException

         */

        public void readWindow(RasterBuf buf, BandList bandList, int x, int y, int w, int h) throws MrSIDException  {

                isSupersampling = false;

                if (pixel == null) {

            pixel = new LTIPixel(eColorSpace, nbands, eSampleType);

        }

        LTIScene scene = new LTIScene(x, y, w, h, 1.0);

        LTISceneBuffer buffer = new LTISceneBuffer(pixel, w, h, true);

        ((LTIImageStage) this).read(scene, buffer);

        int yMax = y + h;

        byte[] bandBuf = null;

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

                int[] drawableBands = bandList.getBufferBandToDraw(fileName, iBand);

                if(drawableBands == null || (drawableBands.length == 1 && drawableBands[0] == -1))

                                continue;

                switch(iBand) {

                case 0:  bandBuf = buffer.buf1; break;

                case 1:  bandBuf = buffer.buf2; break;

                case 2:  bandBuf = buffer.buf3; break;

            }

                for (int line = 0; line < h; line++){

                for (int col = 0; col < w; col++){

                   int kd = (line * w) + col;

                   buf.setElemByte(line, col, iBand, bandBuf[kd]);

                }

            }

        }

        }

    /**

     * Lee una ventana de la imagen y devuelve un buffer de bytes

     * @param ulX        Coordenada X de la esquina superior izquierda

     * @param ulY        Coordenada Y de la esquina superior izquierda

     * @param sizeX        Tama?o X de la imagen

     * @param sizeY        Tama?o Y de la image

     * @param band        N?mero de bandas

     * @return        buffer con la ventana leida

     * @throws MrSIDException

     */

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

                     throws MrSIDException {

        if (pixel == null) {

            pixel = new LTIPixel(eColorSpace, nbands, eSampleType);

        }

        LTIScene scene = new LTIScene(ulX, ulY, sizeX, sizeY, 1.0);

        LTISceneBuffer buffer = new LTISceneBuffer(pixel, sizeX, sizeY, true);

        ((LTIImageStage) this).read(scene, buffer);

        if (band == 1) {

            return buffer.buf1;

        } else if (band == 2) {

            return buffer.buf2;

        } else if (band == 3) {

            return buffer.buf3;

        }

        return null;

    }

    // Polilinea con extent

    class Contour extends Vector {

        final private static long serialVersionUID = -3370601314380922368L;

        public double minX = Double.MAX_VALUE;

        public double minY = Double.MAX_VALUE;

        public double maxX = -Double.MAX_VALUE;

        public double maxY = -Double.MAX_VALUE;

        public Contour() {

            super();

        }

        public void add(Point2D pt) {

            super.add(pt);

            if (pt.getX() > maxX) {

                maxX = pt.getX();

            }

            if (pt.getX() < minX) {

                minX = pt.getX();

            }

            if (pt.getY() > maxY) {

                maxY = pt.getY();

            }

            if (pt.getY() < minY) {

                minY = pt.getY();

            }

        }

    }

}

/**

 * @author Nacho Brodin <brodin_ign@gva.es>

 *

 * Clase encargada del acceso a los datos y repintado de imagenes MrSID. Estos

 * son registrados con la extensi?n sid

 */

public class MrSidFile extends GeoRasterFile {

    public final static int BAND_HEIGHT = 64;

    protected MrSidNative file = null;

    private Extent v = null;

    /**

     * Contructor. Abre el fichero mrsid

     * @param proj        Proyecci?n

     * @param fName        Nombre del fichero mrsid

     */

    public MrSidFile(IProjection proj, String fName) {

        super(proj, fName);

        extent = new Extent();

        try {

            file = new MrSidNative(fName);

            load();

            bandCount = file.nbands;

            if (bandCount > 2) {

                setBand(RED_BAND, 0);

                setBand(GREEN_BAND, 1);

                setBand(BLUE_BAND, 2);

            } else {

                setBand(RED_BAND | GREEN_BAND | BLUE_BAND, 0);

            }

        } catch (Exception e) {

            System.out.println("Error en constructor de MrSID");

            e.printStackTrace();

            file = null;

        }

    }

        /**

         * Obtenemos o calculamos el extent de la imagen.

         */

    public GeoFile load() {

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

                   requestExtent = extent;

            /*if((this.assignedExtent == GeoRasterFile.IMAGE_EXTENT || this.assignedExtent == GeoRasterFile.ORDER ) 

                    && file !=null        && file.esq != null){

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

                    return this;

            }

            if((this.assignedExtent == GeoRasterFile.ASSIGNED_EXTENT || this.assignedExtent == GeoRasterFile.ORDER ) 

                    && this.getTempExtent() != null){

                extent = this.getTempExtent();

                        file.esq = file.new Contour();

                          file.esq.add(new Point2D.Double(extent.minX(), extent.minY()));

                          file.esq.add(new Point2D.Double(extent.minX()+(extent.maxX() - extent.minX()), extent.minY()));

                          file.esq.add(new Point2D.Double(extent.minX(), extent.minY()+(extent.maxY() - extent.minY())));

                          file.esq.add(new Point2D.Double(extent.minX()+(extent.maxX() - extent.minX()), extent.minY()+(extent.maxY() - extent.minY())));

        }*/ 

        return this;

    }

    /**

     * Libera el objeto que ha abierto el fichero

     */

    public void close() {

            if(file != null){

                    file.close();

                    file = null;

            }

    }

    /**

     * Asigna una banda R, G o B

     */

    public void setBand(int flag, int bandNr) {

        super.setBand(flag, bandNr);

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

            file.rBandNr = bandNr + 1;

        }

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

            file.gBandNr = bandNr + 1;

        }

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

            file.bBandNr = bandNr + 1;

        }

    }

    /**

     * Asigna el extent de la vista

     */

    public void setView(Extent e) {

        v = new Extent(e);

    }

    /**

     * Obtiene el Extent de la vista

     */

    public Extent getView() {

        return v;

    }

    /**

     * Obtiene el ancho de la imagen

     */

    public int getWidth() {

        return file.width;

    }

    /**

     * Obtiene el alto de la imagen

     */

    public int getHeight() {

        return file.height;

    }

    public void reProject(ICoordTrans rp) {

        // TODO Auto-generated method stub        

    }

    /**

     * Actualiza la imagen. Se encarga de llamar a la funci?n que calcula la vista

     * y luego a la que lee la escena sobre un buffer. Vuelca la informaci?n obtenida

     * sobre el Image que la visualiza.

     */

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

        int line;

        int[] pRGBArray = null;

        Image image = null;

        if(mustVerifySize()){

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

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

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

                if (dFileAspect > dWindowAspect) {

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

                } else {

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

                }

        }

        // Set the view

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

                setStep(file.stepArrayX, file.stepArrayY);

        //Impedimos que los valores de ancho y alto de la im?gen sean menores que 1

        if (width <= 0) {

            width = 1;

        }

        if (height <= 0) {

            height = 1;

        }

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

        pRGBArray = new int[width * height];

        try {

            file.setAlpha(getAlpha());

            setBand(RED_BAND, rBandNr);

            setBand(GREEN_BAND, gBandNr);

            setBand(BLUE_BAND, bBandNr);

            file.readScene(pRGBArray);

            setStep(file.stepArrayX, file.stepArrayY);

            ((BufferedImage) image).setRGB(0, 0, width, height, pRGBArray, 0,

                                           width);

        } catch (Exception e) {

            e.printStackTrace();

        }

        return image;

    }

    /**

     * Muestra informaci?n del fichero abierto.

     *

     */

    private void showOnOpen() {

        // Report en la apertura (quitar)

        System.out.println("Fichero MrSID '" + getName() + "' abierto.");

        System.out.println("Version = " + file.version);

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

                           ")");

        System.out.println("   NumBands = (" + file.nbands + ")");

        //file.pintaInfo();

        file.pintaPaleta();

    }

    /**

     * Asigna al objeto Image los valores con los dato de la imagen contenidos en el

     * vector de enteros.

     * @param image        imagen con los datos actuales

     * @param startX        inicio de la posici?n en X dentro de la imagen

     * @param startY        inicio de la posici?n en X dentro de la imagen

     * @param w        Ancho de la imagen

     * @param h        Alto de la imagen

     * @param rgbArray        vector que contiene la banda que se va a sustituir

     * @param offset        desplazamiento

     * @param scansize        tama?o de imagen recorrida por cada p

     */

    protected void setRGBLine(BufferedImage image, int startX, int startY,

                              int w, int h, int[] rgbArray, int offset,

                              int scansize) {

        image.setRGB(startX, startY, w, h, rgbArray, offset, scansize);

    }

    /**

     * Asigna al objeto Image la mezcla entre los valores que ya tiene y los valores

     * con los datos de la imagen contenidos en el vector de enteros. De los valores RGB

     * que ya contiene se mantienen las bandas que no coinciden con el valor de flags. La

     * banda correspondiente a flags es sustituida por los datos del vector.

     * @param image        imagen con los datos actuales

     * @param startX        inicio de la posici?n en X dentro de la imagen

     * @param startY        inicio de la posici?n en X dentro de la imagen

     * @param w        Ancho de la imagen

     * @param h        Alto de la imagen

     * @param rgbArray        vector que contiene la banda que se va a sustituir

     * @param offset        desplazamiento

     * @param scansize        tama?o de imagen recorrida por cada paso

     * @param flags        banda que se va a sustituir (Ctes de GeoRasterFile)

     */

    protected void setRGBLine(BufferedImage image, int startX, int startY,

                              int w, int h, int[] rgbArray, int offset,

                              int scansize, int flags) {

        int[] line = new int[rgbArray.length];

        image.getRGB(startX, startY, w, h, line, offset, scansize);

        if (flags == GeoRasterFile.RED_BAND) {

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

                line[i] = (line[i] & 0x0000ffff) | (rgbArray[i] & 0xffff0000);

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

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

                line[i] = (line[i] & 0x00ff00ff) | (rgbArray[i] & 0xff00ff00);

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

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

                line[i] = (line[i] & 0x00ffff00) | (rgbArray[i] & 0xff0000ff);

        }

        image.setRGB(startX, startY, w, h, line, offset, scansize);

    }

    /**

     * Asigna al objeto Image la mezcla entre los valores que ya tiene y los valores

     * con los dato de la imagen contenidos en el vector de enteros. De los valores RGB

     * que ya contiene se mantienen las bandas que no coinciden con el valor de flags. La

     * banda correspondiente a flags es sustituida por los datos del vector.

     * @param image        imagen con los datos actuales

     * @param startX        inicio de la posici?n en X dentro de la imagen

     * @param startY        inicio de la posici?n en X dentro de la imagen

     * @param w        Ancho de la imagen

     * @param h        Alto de la imagen

     * @param rgbArray        vector que contiene la banda que se va a sustituir

     * @param offset        desplazamiento

     * @param scansize        tama?o de imagen recorrida por cada paso

     * @param origBand        Banda origen del GeoRasterFile

     * @param destBandFlag        banda que se va a sustituir (Ctes de GeoRasterFile)

     */

    protected void setRGBLine(BufferedImage image, int startX, int startY,

                              int w, int h, int[] rgbArray, int offset,

                              int scansize, int origBand, int destBandFlag) {

        int[] line = new int[rgbArray.length];

        image.getRGB(startX, startY, w, h, line, offset, scansize);

        if ((origBand == 0) && (destBandFlag == GeoRasterFile.RED_BAND)) {

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

                line[i] = (line[i] & 0x0000ffff) | (rgbArray[i] & 0xffff0000);

        } else if ((origBand == 1) &&

                       (destBandFlag == GeoRasterFile.GREEN_BAND)) {

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

                line[i] = (line[i] & 0x00ff00ff) | (rgbArray[i] & 0xff00ff00);

        } else if ((origBand == 2) &&

                       (destBandFlag == GeoRasterFile.BLUE_BAND)) {

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

                line[i] = (line[i] & 0x00ffff00) | (rgbArray[i] & 0xff0000ff);

        } else if ((origBand == 0) &&

                       (destBandFlag == GeoRasterFile.GREEN_BAND)) {

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

                line[i] = (line[i] & 0xffff00ff) |

                          ((rgbArray[i] & 0x00ff0000) >> 8);

        } else if ((origBand == 0) &&

                       (destBandFlag == GeoRasterFile.BLUE_BAND)) {

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

                line[i] = (line[i] & 0xffffff00) |

                          ((rgbArray[i] & 0x00ff0000) >> 16);

        } else if ((origBand == 1) && (destBandFlag == GeoRasterFile.RED_BAND)) {

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

                line[i] = (line[i] & 0xff00ffff) |

                          ((rgbArray[i] & 0x0000ff00) << 8);

        } else if ((origBand == 1) &&

                       (destBandFlag == GeoRasterFile.BLUE_BAND)) {

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

                line[i] = (line[i] & 0xffffff00) |

                          ((rgbArray[i] & 0x0000ff00) >> 8);

        } else if ((origBand == 2) && (destBandFlag == GeoRasterFile.RED_BAND)) {

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

                line[i] = (line[i] & 0xff00ffff) |

                          ((rgbArray[i] & 0x000000ff) << 16);

        } else if ((origBand == 2) &&

                       (destBandFlag == GeoRasterFile.GREEN_BAND)) {

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

                line[i] = (line[i] & 0xffff00ff) |

                          ((rgbArray[i] & 0x000000ff) << 8);

        }

        image.setRGB(startX, startY, w, h, line, offset, scansize);

    }

    /* (non-Javadoc)

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

     */

    public Image updateImage(int width, int height, ICoordTrans rp, Image img,

                             int origBand, int destBandFlag) throws SupersamplingNotSupportedException{

        int line;

        int[] pRGBArray = null;

        Image mrSidImage = null;

        if(mustVerifySize()){

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

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

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

                if (dFileAspect > dWindowAspect) {

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

                } else {

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

                }

        }

        // Set the view

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

        //Impedimos que los valores de ancho y alto de la im?gen sean menores que 1

        if (width <= 0) {

            width = 1;

        }

        if (height <= 0) {

            height = 1;

        }

        file.setAlpha(getAlpha());

        setBand(RED_BAND, rBandNr);

        setBand(GREEN_BAND, gBandNr);

        setBand(BLUE_BAND, bBandNr);

        pRGBArray = new int[width * height];

        if (img == null) { //Caso en el que se crea una imagen

            mrSidImage = new BufferedImage(width, height,

                                           BufferedImage.TYPE_INT_ARGB);

            try {

                file.readScene(pRGBArray);

                setStep(file.stepArrayX, file.stepArrayY);

                setRGBLine((BufferedImage) mrSidImage, 0, 0, width, height, pRGBArray, 0, width);

            } catch (Exception e) {

                e.printStackTrace();

            }

            return mrSidImage;

        } else { //Caso en el que se actualiza una banda del Image

            try {

                file.readScene(pRGBArray);

                setStep(file.stepArrayX, file.stepArrayY);

                setRGBLine((BufferedImage) img, 0, 0, width, height, pRGBArray, 0, width, origBand, destBandFlag);

            } catch (Exception e) {

                e.printStackTrace();

            }

            return img;

        }

    }

    /* (non-Javadoc)

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

     */

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

        // TODO Auto-generated method stub

        return null;

    }

    public RasterBuf getWindowRasterWithNoData(double x, double y, double w, double h, BandList bandList, RasterBuf rasterBuf) {

                return null;

        }

        /**

         * Obtiene una ventana de datos de la imagen a partir de coordenadas reales. 

         * No aplica supersampleo ni subsampleo sino que devuelve una matriz de igual tama?o a los

         * pixeles de disco. 

         * @param x Posici?n X superior izquierda

         * @param y Posici?n Y superior izquierda

         * @param w Ancho en coordenadas reales

         * @param h Alto en coordenadas reales

         * @param rasterBuf        Buffer de datos

         * @param bandList

         * @return Buffer de datos

         */

    public RasterBuf getWindowRaster(double x, double y, double w, double h, BandList bandList, RasterBuf rasterBuf) {                

                //Extent selectedExtent = new Extent(x, y, x + w, y - h);

                //setView(selectedExtent);

                int initX = (int)((x * file.width) / extent.width());

                int initY = (int)((y * file.height) / extent.height());

                int width = (int)((w * file.width) / extent.width());

                int height = (int)((h * file.height) / extent.height());

                return getWindowRaster(initX, initY, width, height, bandList, rasterBuf);

        }

        /**

         * Obtiene una ventana de datos de la imagen a partir de coordenadas pixel. 

         * No aplica supersampleo ni subsampleo sino que devuelve una matriz de igual tama?o a los

         * pixeles de disco. 

         * @param x Posici?n X superior izquierda

         * @param y Posici?n Y superior izquierda

         * @param w Ancho en coordenadas reales

         * @param h Alto en coordenadas reales

         * @param rasterBuf        Buffer de datos

         * @param bandList

         * @return Buffer de datos

         */

        public RasterBuf getWindowRaster(int x, int y, int w, int h, BandList bandList, RasterBuf rasterBuf) {

                try {

                        rasterBuf = new RasterBuf(getDataType(), w, h, bandList.getDrawableBandsCount(), true);

                        file.readWindow(rasterBuf, bandList, x, y, w, h);

                } catch (Exception e) {

                        e.printStackTrace();

                }

                return rasterBuf;

        }

    /**

     * Devuelve los datos de una ventana solicitada

     * @param ulX        coordenada X superior izda.

     * @param ulY        coordenada Y superior derecha.

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

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

     * @param band        Banda solicitada.

     */

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

        try {

            return file.getWindow(ulX, ulY, sizeX, sizeY, band);

        } catch (MrSIDException e) {

            e.printStackTrace();

        }

        return null;

    }

    /**

     * Devuelve el tama?o de bloque

     * @return Tama?o de bloque

     */

    public int getBlockSize() {

        return file.blocksize;

    }

    /**

         * Calcula la transformaci?n que se produce sobre la vista cuando la imagen tiene un fichero .rmf

         * asociado. En Ecw el origen de coordenadas en Y es el valor m?ximo y decrece hasta el m?nimo.

         * @param originX Origen de la imagen en la coordenada X

         * @param originY Origen de la imagen en la coordenada Y

         */

    public void setExtentTransform(double originX, double originY, double psX, double psY) {

        }

    /**

         * Informa de si el driver ha supersampleado en el ?ltimo dibujado. Es el driver el que colocar?

         * el valor de esta variable cada vez que dibuja. 

         * @return true si se ha supersampleado y false si no se ha hecho.

         */

        public boolean isSupersampling() {

                return file.isSupersampling;

        }

        public RasterBuf getWindowRaster(double minX, double minY, double maxX, double maxY, int bufWidth, int bufHeight, BandList bandList, RasterBuf rasterBuf) {

                // TODO Auto-generated method stub

                return null;

        }

        public Point2D rasterToWorld(Point2D pt) {

                // TODO Auto-generated method stub

                return null;

        }

        public Point2D worldToRaster(Point2D pt) {

                // TODO Auto-generated method stub

                return null;

        }

}