Application: gvSIG desktop » gvSIG raster

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * 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., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.raster.impl.grid.render;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.geom.AffineTransform;

import java.awt.geom.Dimension2D;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.util.ArrayList;

import java.util.List;

import org.cresques.cts.ICoordTrans;

import org.gvsig.fmap.dal.coverage.RasterLocator;

import org.gvsig.fmap.dal.coverage.RasterManager;

import org.gvsig.fmap.dal.coverage.dataset.Buffer;

import org.gvsig.fmap.dal.coverage.datastruct.Extent;

import org.gvsig.fmap.dal.coverage.datastruct.Params;

import org.gvsig.fmap.dal.coverage.datastruct.ViewPortData;

import org.gvsig.fmap.dal.coverage.exception.FilterManagerException;

import org.gvsig.fmap.dal.coverage.exception.FilterTypeException;

import org.gvsig.fmap.dal.coverage.exception.ProcessInterruptedException;

import org.gvsig.fmap.dal.coverage.exception.QueryException;

import org.gvsig.fmap.dal.coverage.exception.ROIException;

import org.gvsig.fmap.dal.coverage.filter.FilterLoader;

import org.gvsig.fmap.dal.coverage.grid.FilterListChangeEvent;

import org.gvsig.fmap.dal.coverage.grid.FilterListChangeListener;

import org.gvsig.fmap.dal.coverage.grid.RasterFilter;

import org.gvsig.fmap.dal.coverage.grid.RasterFilterList;

import org.gvsig.fmap.dal.coverage.grid.RasterFilterListManager;

import org.gvsig.fmap.dal.coverage.grid.render.Render;

import org.gvsig.fmap.dal.coverage.grid.render.VisualPropertyEvent;

import org.gvsig.fmap.dal.coverage.grid.render.VisualPropertyListener;

import org.gvsig.fmap.dal.coverage.store.RasterDataStore;

import org.gvsig.fmap.dal.coverage.store.RasterQuery;

import org.gvsig.fmap.dal.coverage.store.props.ColorInterpretation;

import org.gvsig.fmap.dal.coverage.store.props.ColorTable;

import org.gvsig.fmap.dal.coverage.store.props.Statistics;

import org.gvsig.fmap.dal.coverage.store.props.Transparency;

import org.gvsig.fmap.dal.coverage.util.PropertyEvent;

import org.gvsig.fmap.dal.coverage.util.PropertyListener;

import org.gvsig.fmap.dal.coverage.util.RasterUtils;

import org.gvsig.raster.cache.tile.Tile;

import org.gvsig.raster.cache.tile.exception.TileGettingException;

import org.gvsig.raster.cache.tile.provider.TileListener;

import org.gvsig.raster.impl.datastruct.DefaultViewPortData;

import org.gvsig.raster.impl.datastruct.ExtentImpl;

import org.gvsig.raster.impl.grid.filter.band.ColorTableFilter;

import org.gvsig.raster.impl.store.properties.DataStoreColorInterpretation;

import org.gvsig.raster.roi.ROI;

import org.gvsig.raster.util.persistence.PersistencyFilterParams;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.task.TaskStatus;

import org.slf4j.LoggerFactory;

/**

 * Esta clase se encarga de la gesti?n del dibujado de datos le?dos desde la capa

 * "dataaccess" sobre objetos java. Para ello necesita una fuente de datos que tipicamente

 * es un buffer (RasterBuffer) y un objeto que realice la funci?n de escritura de datos a

 * partir de un estado inicial.

 * Esta capa del renderizado gestiona Extents, rotaciones, tama?os de vista pero la escritura

 * de datos desde el buffer al objeto image es llevada a cabo por ImageDrawer.

 *

 * Par?metros de control de la visualizaci?n:

 * <UL>

 * <LI>renderBands: Orden de visualizado de las bands.</LI>

 * <LI>replicateBands: Para visualizaci?n de raster de una banda. Dice si se replica sobre las otras dos bandas

 * de visualizaci?n o se ponen a 0.</LI>

 * <LI>enhanced: aplicaci?n de filtro de realce</LI>

 * <LI>removeEnds: Eliminar extremos en el filtro de realce. Uso del segundo m?ximo y m?nimo</LI>

 * <LI>tailTrim: Aplicacion de recorte de colas en el realce. Es un valor decimal que representa el porcentaje del recorte entre 100.

 * Es decir, 0.1 significa que el recorte es de un 10%</LI>

 * </UL>

 *

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class DefaultRender implements Render, PropertyListener, FilterListChangeListener, Persistent, TileListener {

        /**

         * Fuente de datos para el renderizado

         */

        private RasterDataStore dataStore                  = null;

        /**

         * N?mero de bandas a renderizar y en el orden que se har?. Esto es asignado

         * por el usuario de la renderizaci?n.

         */

        ColorInterpretation      renderColorInterpretation = null;

        //private int[]            renderBands              = { 0, 1, 2, 3 };

        private ImageDrawerImpl  drawer                    = null;

        /**

         * 

         */

        private Transparency     renderingTransparency     = null;

        private int              lastAlphaBand             = -1;

        /**

         * Lista de filtros aplicada en la renderizaci?n

         */

        private RasterFilterList filterList               = null;

        /**

         * Ancho y alto del objeto Image en una petici?n de dibujado a un raster

         * raster

         */

        private double           widthImage, heightImage;

        private Point2D          ulPxRequest, lrPxRequest;

        /**

         * Array de listeners que ser?n informados cuando cambia una propiedad en la visualizaci?n

         */

        private ArrayList<VisualPropertyListener>        

                                 visualPropertyListener   = new ArrayList<VisualPropertyListener>();

        private RasterUtils      util                     = RasterLocator.getManager().getRasterUtils();

        private boolean          isDrawing                = false;

        private Graphics2D       lastGraphics             = null;

        private ViewPortData     lastViewPortData         = null;

        private Dimension2D      viewDimension            = null;

        private RasterRenderReprojection

                                 reprojectionOnTheFly     = null;

        private RasterManager    rManager                 = null;

        /**

         * Constructor

         * @param grid

         */

        public DefaultRender() {

        }

        /**

         * Constructor

         * @param grid

         */

        public DefaultRender(RasterDataStore ds) {

                this.dataStore = ds;

                init();

        }

        private RasterManager getRasterManager() {

                if(rManager == null)

                        rManager = RasterLocator.getManager();

                return rManager;

        }

        public void createReprojectionOnTheFly(

                        RasterDataStore store, 

                        ICoordTrans coordTrans,

                        TaskStatus status) {

                reprojectionOnTheFly = new RasterRenderReprojection(

                                store, coordTrans, status); 

        }

        public boolean isReprojectingOnTheFly() {

                return reprojectionOnTheFly != null;

        }

        public RasterDataStore getDataStore() {

                return this.dataStore;

        }

        public void setDataStore(RasterDataStore dataStore) {

                this.dataStore = dataStore;

                init();

        }

        private void init() {

                if(dataStore == null || dataStore.getDataType() == null)

                        return;

                drawer = new ImageDrawerImpl();

                getRenderColorInterpretation();

        }

        /**

         * Asigna un listener a la lista que ser? informado cuando cambie una

         * propiedad visual en la renderizaci?n.

         * @param listener VisualPropertyListener

         */

        public void addVisualPropertyListener(VisualPropertyListener listener) {

                visualPropertyListener.add(listener);

        }

        /**

         * M?todo llamado cuando hay un cambio en una propiedad de visualizaci?n

         */

        private void callVisualPropertyChanged(Object obj) {

                if(visualPropertyListener != null) {

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

                                VisualPropertyEvent ev = new VisualPropertyEvent(obj);

                                ((VisualPropertyListener)visualPropertyListener.get(i)).visualPropertyValueChanged(ev);

                        }

                }

        }

        /**

         * Thread de dibujado

         */

        public void run() {

                try {

                        draw(lastGraphics, lastViewPortData, null);

                } catch (QueryException e) {

                        LoggerFactory.getLogger(getClass()).debug("Error in a query", e);

                } catch (ProcessInterruptedException e) {

                }

        }

        public void setGraphicInfo(Graphics2D g, ViewPortData vp) {

                this.lastGraphics = g;

                this.lastViewPortData = vp;

        }

        public void drawThread(Graphics2D g, ViewPortData vp) {

                //Se dibuja si cae dentro de la vista

                if(util.isOutside(vp.getExtent(), dataStore.getExtent())) 

                        return;

                setReading(true);

                setGraphicInfo(g, vp);

                new Thread(this).start();

                while(isReading()) {

                        try {

                                Thread.sleep(50);

                        } catch (InterruptedException e) {

                                break;

                        }

                }

        }

        public synchronized Buffer getLastRenderBuffer() 

                throws QueryException, ProcessInterruptedException {

                return draw(null, lastViewPortData, null);

        }

        public synchronized void drawTiledService(Graphics2D g, 

                        ViewPortData vp, 

                        Dimension2D viewDimension, 

                        TaskStatus taskStatus)

                throws QueryException, ProcessInterruptedException {

                lastGraphics = g;

                lastViewPortData = vp;

                this.viewDimension = viewDimension;

                int[] renderBands = getRenderColorInterpretation().buildRenderBands();

                if(util.isOutside(vp.getExtent(), dataStore.getExtent())) {

                        endReading();

                        return;

                }

                if (dataStore != null) {

                        lastAlphaBand = getRenderingTransparency().getAlphaBandNumber();

                        // Asignamos la banda de transparencia si existe esta

                        RasterQuery query = getRasterManager().createQuery();

                        query.setTaskStatus(taskStatus);

                        query.setTime(vp.getTime());

                        query.setSupersamplingOption(false); // Desactivamos el supersampleo en la carga del buffer.

                        if(dataStore.getColorInterpretation().isRGB())

                                renderBands[3] = 3;

                        query.setDrawableBands(renderBands);

                        if(dataStore.getDataType()[0] == Buffer.TYPE_BYTE) {

                                if(lastAlphaBand != -1)

                                        query.forceARGBRequest();

                                else if(renderBands.length == 3 || (renderBands.length == 4 && renderBands[3] == -1))

                                        query.forceRGBRequest();

                                else

                                        query.forceARGBRequest();

                        } else

                                query.forceRGBRequest();

                        query.setAreaOfInterest(vp.getExtent(), 

                                        (int)Math.round(vp.getWidth()), 

                                        (int)Math.round(vp.getHeight()), this);

                        dataStore.query(query);

                        query.setSupersamplingOption(true);

                } else

                        return;

        }

        public synchronized void tileReady(Tile loadedTile) throws TileGettingException {

                boolean crash = false;

                Boolean tiling = (Boolean)loadedTile.getDownloaderParams("Tiling");

                double[] step = (double[])loadedTile.getDownloaderParams("Step");

                AffineTransform transf = (AffineTransform)loadedTile.getDownloaderParams("AffineTransform");

                Extent e = getRasterManager().getDataStructFactory().

                createExtent(loadedTile.getUl().getX(), 

                                loadedTile.getUl().getY(), 

                                loadedTile.getLr().getX(), 

                                loadedTile.getLr().getY());

                Buffer buf = (loadedTile.getData() != null && loadedTile.getData().length > 0) ? (Buffer)loadedTile.getData()[0] : null;

                if(!loadedTile.dataIsLoaded()) {

                        if(loadedTile.getCrashARGB() == null)

                                return;

                        crash = true;

                        buf = (Buffer)loadedTile.getCrashARGB();

                } else {

                        if(buf == null)

                                return;

                        ColorTable tileColorTable = (loadedTile.getData() != null && loadedTile.getData().length > 2) ? (ColorTable)loadedTile.getData()[2] : null;

                        if(tiling == null || tiling.booleanValue()) {

                                if(filterList != null) 

                                        addTileColorTable(tileColorTable);

                        }

                }

                buf.setDataExtent(e.toRectangle2D());

                Transparency transparencyProcessed = null;

                if(tiling == null || tiling.booleanValue()) {

                        try {

                                FilterLoader filterLoader = bufferPreprocessing(buf);

                                transparencyProcessed = filterLoader.getTransparency();

                                buf = filterLoader.getBufferResult();

                        } catch (ProcessInterruptedException e3) {

                                return;

                        }

                }

                if(tiling == null || tiling.booleanValue()) {

                        //Reescalado de los tiles. El tama?o en pixels de un tile no tiene pq coincidir con el de la vista.

                        double w = lastViewPortData.getWidth();

                        double h = lastViewPortData.getHeight();

                        if(viewDimension != null) {

                                w = viewDimension.getWidth();

                                h = viewDimension.getHeight();

                        }

                        double viewScaleW = lastViewPortData.getExtent().width() / w;

                        double tileScaleW = e.width() / (double)buf.getWidth();

                        double scaleW = viewScaleW / tileScaleW;

                        double viewScaleH = lastViewPortData.getExtent().height() / h;

                        double tileScaleH = e.height() / (double)buf.getHeight();

                        double scaleH = viewScaleH / tileScaleH;

                        ImageDrawerImpl d = new ImageDrawerImpl();

                        d.setBuffer(buf);

                        d.setSupersamplingOn(null);

                        d.setOutputSize(buf.getWidth(), buf.getHeight());

                        d.setLastTransparency(transparencyProcessed);

                        Image geoImage;

                        try {

                                geoImage = d.drawBufferOverImageObject();

                        } catch (ProcessInterruptedException e2) {

                                return;

                        }

                        d.dispose();

                        AffineTransform at = new AffineTransform();

                        at.scale(1 / scaleW, 1 / scaleH);

                        try {

                                Point2D pt = new Point2D.Double(e.getULX(), e.getULY());

                                ((DefaultViewPortData)lastViewPortData).mat.transform(pt, pt);

                                at.inverseTransform(pt, pt);

                                lastGraphics.transform(at);

                                lastGraphics.drawImage(geoImage, (int) Math.round(pt.getX()), (int) Math.round(pt.getY()), null);

                                lastGraphics.transform(at.createInverse());

                                geoImage.flush();

                        } catch (NoninvertibleTransformException e1) {

                                e1.printStackTrace();

                        }

                } else {

                        try {

                                drawBufferOnImage(lastGraphics, lastViewPortData, buf, step, transf, e);

                        } catch (QueryException e1) {

                                LoggerFactory.getLogger(getClass()).debug("Error loading data", e1);

                        } catch (ProcessInterruptedException e1) {

                        }

                }

                if(!crash) { //Las im?genes de crash no se liberan ya que est?n en un hashmap global

                        if(buf != null)

                                buf.dispose();

                }

        }

        public synchronized Buffer draw(Graphics2D g, ViewPortData vp, TaskStatus taskStatus)

                throws QueryException, ProcessInterruptedException {

                lastGraphics = g;

                lastViewPortData = vp;

                if(util.isOutside(vp.getExtent(), dataStore.getExtent())) {

                        endReading();

                        return null;

                }

                Extent adjustedRotedRequest = request(vp, dataStore);

                if ((widthImage <= 0) || (heightImage <= 0)) {

                        endReading();

                        return null;

                }

                if (dataStore == null) 

                        return null;

                Buffer buf = null; 

                double[] step = null;

                int[] renderBands = getRenderColorInterpretation().buildRenderBands();

                if(reprojectionOnTheFly != null) {

                        buf = reprojectionOnTheFly.warp(adjustedRotedRequest, 

                                        (int)Math.round(widthImage), 

                                        (int)Math.round(heightImage), 

                                        vp.getTime(), 

                                        renderBands, 

                                        getRenderingTransparency());

                } else {

                        lastAlphaBand = getRenderingTransparency().getAlphaBandNumber();

                        RasterQuery query = getRasterManager().createQuery();

                        query.setTaskStatus(taskStatus);

                        query.setTime(vp.getTime());

                        query.setAreaOfInterest(adjustedRotedRequest, (int)Math.round(widthImage), (int)Math.round(heightImage));

                        query.setDrawableBands(renderBands);

                        if(dataStore.getDataType()[0] == Buffer.TYPE_BYTE) {

                                if(lastAlphaBand != -1)

                                        query.forceARGBRequest();

                                else if(renderBands.length == 3 || (renderBands.length == 4 && renderBands[3] == -1))

                                        query.forceRGBRequest();

                        } else {

                                if(renderBands.length == 4 && renderBands[3] != -1)

                                        query.forceARGBRequest();

                                else

                                        query.forceRGBRequest();

                        }

                        buf = dataStore.query(query);

                        step = query.getStep();

                }

                if(drawer == null) {

                        init();

                }

                return drawBufferOnImage(lastGraphics, 

                                        lastViewPortData, 

                                        buf, 

                                        step, 

                                        dataStore.getAffineTransform(), 

                                        adjustedRotedRequest);

        }

        private synchronized Buffer drawBufferOnImage(Graphics2D g, ViewPortData vp, Buffer buf, double[] step, AffineTransform transf, Extent adjustedRotedRequest)

                throws QueryException, ProcessInterruptedException {

                FilterLoader filterLoader = bufferPreprocessing(buf);

                Transparency transparencyProcessed = filterLoader.getTransparency(); 

                buf = filterLoader.getBufferResult();

                if(g == null)

                        return buf;

                drawer.setBuffer(buf); // Buffer de datos a renderizar

                drawer.setSupersamplingOn(step); // Desplazamiento para supersampleo

                drawer.setOutputSize((int)Math.round(widthImage), (int)Math.round(heightImage)); // Ancho y alto del buffer

                drawer.setLastTransparency(transparencyProcessed);

                Image geoImage = drawer.drawBufferOverImageObject(); // Acci?n de renderizado

                drawer.dispose();

                //En el caso de no tenga rotaci?n y el tama?o de pixel sea positivo en X y negativo en Y no aplicamos ninguna

                //transformaci?n. Esto no es necesario hacerlo, sin ello se visualiza igual. Unicamente se hace porque de esta

                //forma el raster resultante mejora un poco en calidad en ciertos niveles de zoom ya que al aplicar transformaciones

                //sobre el Graphics parece que pierde algo de calidad.

                if(transf.getScaleX() > 0 && transf.getScaleY() < 0 && transf.getShearX() == 0 && transf.getShearY() == 0) {

                        Point2D lastGraphicOffset = new Point2D.Double(adjustedRotedRequest.getULX(), adjustedRotedRequest.getULY());

                        ((DefaultViewPortData)vp).mat.transform(lastGraphicOffset, lastGraphicOffset);

                        g.drawImage(geoImage, (int) Math.round(lastGraphicOffset.getX()), (int) Math.round(lastGraphicOffset.getY()), null);

                        return buf;

                }

                /*

                 * Tenemos una matriz con la transformaci?n de la coordenadas de la vista a coordenadas reales vp.mat, adem?s tenemos

                 * la transformaci?n de coordenadas reales a coordenadas pixel (transf). Con ambas podemos obtener una matriz de trasformacion

                 * entre coordenadas de la vista a coordenadas pixel (transf X vp.mat). As? obtenemos la transformaci?n entre coordenadas

                 * de la vista y coordenadas pixel del raster. El problema es que a cada zoom la escala de la petici?n del raster varia

                 * por lo que habr? que calcular una matriz con la escala (escale). escale X transf X vp.mat

                 */

                double sX = Math.abs(ulPxRequest.getX() - lrPxRequest.getX()) / widthImage;

                double sY = Math.abs(ulPxRequest.getY() - lrPxRequest.getY()) / heightImage;

                AffineTransform scale = new AffineTransform(sX, 0, 0, sY, 0, 0);

                try {

                        AffineTransform at = (AffineTransform)scale.clone();

                        at.preConcatenate(transf);

                        at.preConcatenate(vp.getMat());

                        g.transform(at);

                        Point2D.Double pt = null;

                        //El punto sobre el que rota la imagen depende del signo de los tama?os del pixel

                        if(transf.getScaleX() < 0 && transf.getScaleY() < 0)

                                pt = new Point2D.Double(adjustedRotedRequest.maxX(), adjustedRotedRequest.maxY());

                        else if(transf.getScaleX() > 0 && transf.getScaleY() > 0)

                                pt = new Point2D.Double(adjustedRotedRequest.minX(), adjustedRotedRequest.minY());

                        else if(transf.getScaleX() < 0 && transf.getScaleY() > 0)

                                pt = new Point2D.Double(adjustedRotedRequest.maxX(), adjustedRotedRequest.minY());

                        else

                                pt = new Point2D.Double(adjustedRotedRequest.getULX(), adjustedRotedRequest.getULY());

                        vp.getMat().transform(pt, pt);

                        at.inverseTransform(pt, pt);

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

                        g.transform(at.createInverse());

                        geoImage.flush();

                } catch (NoninvertibleTransformException e) {

                        LoggerFactory.getLogger(getClass()).debug("Transformation error", e);

                }

                return buf;

                // long t2 = new Date().getTime();

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

        }

        /**

         * Applies filters and transparency on the buffer and returns the grid with the modified buffer.

         * @param buf

         * @param transparency

         * @throws ProcessInterruptedException

         */

        private FilterLoader bufferPreprocessing(Buffer buf) throws ProcessInterruptedException {

                //Asignamos los datos al objeto transparencia antes de aplicar la pila de filtros para que el valor NoData sea efectivo

                if (getRenderingTransparency().getNoData().isNoDataTransparent() || 

                                getRenderingTransparency().existAlphaBand())

                        getRenderingTransparency().setDataBuffer(buf);

                else {

                        getRenderingTransparency().setDataBuffer(null);

                }

                getRenderingTransparency().activeTransparency();

                List<ROI> roi = null;

                try {

                        roi = (List<ROI>)dataStore.getRois(lastViewPortData != null ? lastViewPortData.getProjection() : null);

                } catch (ROIException e) {

                }

                FilterLoader filterLoader = RasterLocator.getManager().createFilterLoader(filterList);

                filterLoader.addSrcBandCount(dataStore.getBandCount());

                filterLoader.addSrcDataType(dataStore.getDataType()[0]);

                filterLoader.addSrcStatistics(dataStore.getStatistics());

                filterLoader.addSrcROI(roi);

                filterLoader.addSrcHistogram(dataStore.getHistogramComputer());

                filterLoader.addTransparency(getRenderingTransparency());

                filterLoader.applyFilters(buf);

                return filterLoader;

        }

        /**

         * When tiles are renderized the color table in each tile could be diferent.

         * In this case the color table must be replaced

         */

        //@deprecated one color table by tiled layer

        private void addTileColorTable(ColorTable tileColorTable) {

                if(tileColorTable == null)

                        return;

                else {

                        if(filterList.getFilterClassByID("ColorTable") == null) {

                                try {

                                        RasterFilterListManager colorTableManager = filterList.getManagerByID("ColorTable");

                                        Params params = filterList.createEmptyFilterParams();

                                        params.setParam("colorTable", tileColorTable);

                                        colorTableManager.addFilter(params);

                                } catch (FilterManagerException e) {

                                        e.printStackTrace();

                                } catch (FilterTypeException e) {

                                        e.printStackTrace();

                                }

                        }

                }

        }

        public void endReading() {

                isDrawing = false;

        }

        public boolean isReading() {

                return isDrawing;

        }

        public void setReading(boolean reading) {

                isDrawing = reading;

        }

        /**

         * Calculamos la petici?n en coordenadas del mundo real con la transformaci?n del raster. Esto

         * permite obtener las coordenadas de la petici?n con la rotaci?n, si la tiene.

         * @param vp

         * @param ldatastore

         * @return

         */

        private Extent request(ViewPortData vp, RasterDataStore ldatastore) {

                if (ldatastore.isRotated()) {

                        //Obtenemos las cuatro esquinas de la selecci?n que hemos hecho en la vista

                        Point2D ul = new Point2D.Double(vp.getExtent().minX(), vp.getExtent().maxY());

                        Point2D ur = new Point2D.Double(vp.getExtent().maxX(), vp.getExtent().maxY());

                        Point2D ll = new Point2D.Double(vp.getExtent().minX(), vp.getExtent().minY());

                        Point2D lr = new Point2D.Double(vp.getExtent().maxX(), vp.getExtent().minY());

                        //Las pasamos a coordenadas pixel del raster

                        ul = ldatastore.worldToRaster(ul);

                        ur = ldatastore.worldToRaster(ur);

                        ll = ldatastore.worldToRaster(ll);

                        lr = ldatastore.worldToRaster(lr);

                        //Obtenemos los valores pixel m?ximos y m?nimos para X e Y

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

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

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

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

                        //Ajustamos las coordenadas pixel al ?rea m?xima del raster

                        pxMinX = Math.max(pxMinX, 0);

                        pxMinY = Math.max(pxMinY, 0);

                        pxMaxX = Math.min(pxMaxX, ldatastore.getWidth());

                        pxMaxY = Math.min(pxMaxY, ldatastore.getHeight());

                        //Petici?n en coordenadas pixel

                        ulPxRequest = new Point2D.Double(pxMinX, pxMinY);

                        lrPxRequest = new Point2D.Double(pxMaxX, pxMaxY);

                        //Calculamos el ancho y alto del buffer sobre el que se escribe la petici?n

                        widthImage = ((Math.abs(lrPxRequest.getX() - ulPxRequest.getX()) * vp

                                        .getWidth()) / Math.abs(pxMaxX - pxMinX));

                        heightImage = ((Math.abs(lrPxRequest.getY() - ulPxRequest.getY()) * vp

                                        .getHeight()) / Math.abs(pxMaxY - pxMinY));

                        //Convertimos la petici?n en coordenadas pixel a petici?n en coordenadas reales.

                        Point2D ulWC = ldatastore.rasterToWorld(ulPxRequest);

                        Point2D lrWC = ldatastore.rasterToWorld(lrPxRequest);

                        //Ajustamos la petici?n a los limites del raster, teniendo en cuenta la rotaci?n de este.

                        return new ExtentImpl(ulWC, lrWC);

                }

                Extent adjustedRotedExtent = util.calculateAdjustedView(vp.getExtent(), ldatastore.getAffineTransform(), ldatastore.getWidth(), ldatastore.getHeight());

                widthImage = (int)Math.round(Math.abs(adjustedRotedExtent.width() * vp.getMat().getScaleX()));

                heightImage = (int)Math.round(Math.abs(adjustedRotedExtent.height() * vp.getMat().getScaleY()));

                Point2D ul = new Point2D.Double(adjustedRotedExtent.getULX(), adjustedRotedExtent.getULY());

                Point2D lr = new Point2D.Double(adjustedRotedExtent.getLRX(), adjustedRotedExtent.getLRY());

                ul = ldatastore.worldToRaster(ul);

                lr = ldatastore.worldToRaster(lr);

                ulPxRequest = new Point2D.Double(ul.getX(), ul.getY());

                lrPxRequest = new Point2D.Double(lr.getX(), lr.getY());

                return adjustedRotedExtent;

        }

        public boolean isRenderingAsGray() {

                int[] renderBands = getRenderColorInterpretation().buildRenderBands();

                if ((renderBands != null) && (renderBands.length == 3 || renderBands.length == 4) && (renderBands[0] >= 0) &&

                                (renderBands[0] == renderBands[1]) && (renderBands[1] == renderBands[2]))

                        return true;

                return false;

        }

        public void setRenderColorInterpretation(ColorInterpretation ci) {

                this.renderColorInterpretation = ci;

        }

        public ColorInterpretation getRenderColorInterpretation() {

                if(renderColorInterpretation == null) {

                        //Initializes the color interpretation using the source but if the source does not have

                        //it will be figure out depending on the number of bands

                        renderColorInterpretation = dataStore.getColorInterpretation();

                        if(renderColorInterpretation == null || !renderColorInterpretation.hasInterpretation()) {

                                switch (dataStore.getBandCount()) {

                                case 1:

                                case 2:

                                        renderColorInterpretation = DataStoreColorInterpretation.createGrayInterpretation();

                                        break;

                                case 3:

                                        renderColorInterpretation = DataStoreColorInterpretation.createRGBInterpretation();

                                        break;

                                case 4:

                                        renderColorInterpretation = DataStoreColorInterpretation.createRGBAInterpretation();

                                default:

                                        renderColorInterpretation = DataStoreColorInterpretation.createRGBInterpretation();

                                        break;

                                }        

                        } else

                                renderColorInterpretation = dataStore.getColorInterpretation().cloneColorInterpretation();

                }

                return renderColorInterpretation;

        }

        /**

                 * Asigna el n?mero de bandas y el orden de renderizado. Cada posici?n del vector es una banda

         * del buffer y el contenido de esa posici?n es la banda de la imagen que se dibujar?

         * sobre ese buffer. A la hora de renderizar hay que tener en cuenta que solo se renderizan las

         * tres primeras bandas del buffer por lo que solo se tienen en cuenta los tres primeros

         * elementos. Por ejemplo, el array {1, 0, 3} dibujar? sobre el Graphics las bandas 1,0 y 3 de un

         * raster que tiene al menos 4 bandas. La notaci?n con -1 en alguna posici?n del vector solo tiene sentido

         * en la visualizaci?n pero no se puede as?gnar una banda del buffer a null.

         * Algunos ejemplos:

         * <P>

         * {-1, 0, -1} Dibuja la banda 0 del raster en la G de la visualizaci?n.

         * Si replicateBand es true R = G = B sino R = B = 0

         * {1, 0, 3} La R = banda 1 del raster, G = 0 y B = 3

         * {0} La R = banda 0 del raster. Si replicateBand es true R = G = B sino G = B = 0

         * </P>

         *

         *

                 * @param renderBands: bandas y su posici?n

                 */

        /*public void setRenderBands(int[] renderBands) {

                if(        renderBands[0] != this.renderBands[0] ||

                        renderBands[1] != this.renderBands[1] ||

                        renderBands[2] != this.renderBands[2] ||

                        renderBands[3] != this.renderBands[3])

                        callVisualPropertyChanged(renderBands);

                this.renderBands = renderBands;

                if (filterList != null)

                        for (int i = 0; i < filterList.lenght(); i++)

                                (filterList.get(i)).addParam("renderBands", renderBands);

        }

        public int[] getRenderBands() {

                return renderBands;

        }*/

        /**

         * Dado que la notaci?n de bandas para renderizado admite posiciones con -1 y la notaci?n del

         * buffer no ya que no tendria sentido. Esta funci?n adapta la primera notaci?n a la segunda

         * para realizar la petici?n setAreaOfInterest y cargar el buffer.

         * @param b Array que indica la posici?n de bandas para el renderizado

         * @return Array que indica la posici?n de bandas para la petici?n

         */

        public int[] formatArrayRenderBand(int[] b) {

                int cont = 0;

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

                        if(b[i] >= 0)

                                cont ++;

                if(cont <= 0)

                        return null;

                int[] out = new int[cont];

                int pos = 0;

                for(int i = 0; i < cont; i++) {

                        while(b[pos] == -1)

                                pos ++;

                        out[i] = b[pos];

                        pos ++;

                }

                return out;

        }

        public Transparency getRenderingTransparency() {

                //If the transparency hasn't been defined yet then we'll take that from the store

                if (renderingTransparency == null) {

                        renderingTransparency = dataStore.getTransparency().cloneTransparency();

                        renderingTransparency.addPropertyListener(this);

                }

                renderingTransparency.setColorInterpretation(getRenderColorInterpretation());

                return renderingTransparency;

        }

        public int getLastAlphaBandNumber() {

                return lastAlphaBand;

        }

        public void setLastTransparency(Transparency lastTransparency) {

                this.renderingTransparency = lastTransparency;

                if(this.renderingTransparency != null)

                        this.renderingTransparency.addPropertyListener(this);

        }

        public RasterFilterList getFilterList() {

                return filterList;

        }

        public void setFilterList(RasterFilterList filterList) {

                this.filterList = filterList;

                this.filterList.addFilterListListener(this);

        }

        public boolean existColorTable() {

                        return (filterList.getFilterByBaseClass(ColorTableFilter.class) != null);

        }

        public ColorTable getColorTable() {

                if(existColorTable()) {

                        RasterFilter f = filterList.getFilterByBaseClass(ColorTableFilter.class);

                        return ((ColorTableFilter)f).getColorTable();

                }

                return null;

        }

        /**

         * Asigna la factoria de buffer del renderizador

         * @param bf

         */

        public void setDataSource(RasterDataStore ds) {

                this.dataStore = ds;

        }

        /**

         * Evento activado cuando cambia una propiedad de transparencia.

         */

        public void actionValueChanged(PropertyEvent e) {

                callVisualPropertyChanged(new VisualPropertyEvent(e.getSource()));

        }

        /**

         * Evento activado cuando cambia la lista de filtros.

         */

        public void filterListChanged(FilterListChangeEvent e) {

                callVisualPropertyChanged(new VisualPropertyEvent(e.getSource()));

        }

        /**

         * Sets buffers to null

         */

        public void dispose() {

                if (renderingTransparency != null)

                        renderingTransparency.dispose();

                if (getFilterList() != null)

                        getFilterList().dispose();

                try {

                        finalize();

                } catch (Throwable e) {

                }

        }

        protected void finalize() throws Throwable {

                dataStore                = null;

        drawer                   = null;

                renderingTransparency    = null;

                filterList               = null;

        ulPxRequest              = null;

        lrPxRequest              = null;

                lastGraphics             = null;

                lastViewPortData         = null;

                viewDimension            = null;

                if(visualPropertyListener != null) {

                        visualPropertyListener.clear();

                        visualPropertyListener = null;

                }

                super.finalize();

        }

        //******************************

        //Persistence

        //******************************

        public static void registerPersistence() {

                PersistenceManager manager = ToolsLocator.getPersistenceManager();

                DynStruct definition = manager.getDefinition("DefaultRender_Persistent");

                if( definition == null ) {

                        definition = manager.addDefinition(

                                        DefaultRender.class,

                                        "DefaultRender_Persistent",

                                        "RasterRendering Persistent definition",

                                        null, 

                                        null

                                        );

                        definition.addDynFieldObject("lastTransparency")

                        .setClassOfValue(Transparency.class)

                        .setMandatory(false);

                        definition.addDynFieldObject("filterList")

                        .setClassOfValue(RasterFilterList.class)

                        .setMandatory(false);

                        definition.addDynFieldList("paramlist")

                        .setClassOfItems(PersistencyFilterParams.class)

                        .setMandatory(false);

                }

        }

        private List<PersistencyFilterParams> listFilterParameters = null;

        @SuppressWarnings("unchecked")

        public void loadFromState(PersistentState state)

                        throws PersistenceException {

                renderingTransparency = (Transparency)state.get("lastTransparency");        

                renderColorInterpretation = renderingTransparency.getColorInterpretation();

                filterList = (RasterFilterList)state.get("filterList");

                listFilterParameters = state.getList("paramlist");

        }

        public void saveToState(PersistentState state) throws PersistenceException {

                state.set("lastTransparency", getRenderingTransparency());

                state.set("filterList", getFilterList());

                state.set("paramlist", buildPersistencyFilterParamFromFilters());

        }

        /**

         * Builds the list of filter parameters to persist 

         * @return

         */

        private List<PersistencyFilterParams> buildPersistencyFilterParamFromFilters() throws PersistenceException {

                List<PersistencyFilterParams> filters = new ArrayList<PersistencyFilterParams>();

                for (int i = 0; i < getFilterList().lenght(); i++) {

                        RasterFilter f = getFilterList().get(i);

                        Params uipar = f.getUIParams(f.getName());

                        PersistencyFilterParams param = new PersistencyFilterParams();

                        param.setFilterParam(uipar);

                        param.setFilterName(f.getName());

                        try {

                                RasterFilterListManager manager = getFilterList().getManagerByFilterClass(f.getClass());

                                param.setManagerExtensionName(manager.getManagerID());

                        } catch (FilterManagerException e) {

                                throw new PersistenceException("Error getting filter manager ID", e);

                        }

                        filters.add(param);

                }

                return filters;

        }

        /**

         * Builds the filters from the list of classes <code>PersistencyFilterParam</code> recovered from a project

         * @param fList

         * @param listFilterUsed

         * @throws PersistenceException

         */

        public void buildFiltersFromPersistencyFilterParam(Statistics stats) throws PersistenceException {

                filterList.addEnvParam("SrcStatistics", stats);

                setFilterList(filterList);

                ArrayList<Exception> exc = new ArrayList<Exception>();

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

                        try {

                                PersistencyFilterParams pfp = (PersistencyFilterParams) listFilterParameters.get(i);

                                if(pfp != null && pfp.getFilterClass() != null && pfp.getFilterParams() != null) {

                                        RasterFilterListManager filterManager = filterList.getManagerByFilterClass(pfp.getFilterClass());

                                        filterManager.setFilterList(filterList);

                                        if(filterManager != null)

                                                filterManager.addFilter(pfp.getFilterClass(), pfp.getFilterParams());

                                }

                        } catch (FilterTypeException e) {

                                exc.add(e);

                        } catch (FilterManagerException e) {

                                exc.add(e);

                        }

                }

                if(exc.size() != 0) {

                        throw new PersistenceException("error_adding_filters", exc.get(0));

                }

        }

}