Application: gvSIG desktop » gvSIG raster

package org.gvsig.raster.roimask.app;

import java.awt.Graphics2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.io.File;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

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

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

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

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

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

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

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

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

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

import org.gvsig.gui.beans.imagenavigator.ImageUnavailableException;

import org.gvsig.raster.fmap.layers.FLyrRaster;

import org.gvsig.raster.roimask.algorithm.ROIMaskProcess;

import org.gvsig.raster.roimask.app.ROIMaskExtension.LayerElement;

import org.gvsig.raster.roimask.swing.ROIMaskData;

import org.gvsig.raster.swing.preview.DataSourcePreview;

import org.gvsig.raster.algorithm.RasterBaseAlgorithmLibrary;

import org.gvsig.raster.algorithm.process.ProcessException;

import org.gvsig.raster.algorithm.process.RasterProcess;

import org.gvsig.tools.task.Cancellable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("deprecation")

public class ROIMaskPreview implements DataSourcePreview {

        private FLyrRaster              inputLyr          = null;

        private Extent                  bbox              = null;

        private ROIMaskData             data              = null;

        private static final Logger     logger            = LoggerFactory.getLogger(ROIMaskPreview.class);

        public void setData(ROIMaskData data) {

                this.data = data;

                loadLayers();

        }

        private void loadLayers() {

                if(data == null)

                        return;

                Object obj = data.getInputLayer();

                if(obj != null)

                        inputLyr = (FLyrRaster)((LayerElement)data.getInputLayer()).getLayer();

                if(inputLyr != null)

                        bbox = inputLyr.getFullRasterExtent();                

        }

        public void closePreviewLayer() {

        }

        public double getCellSize() {

                if(inputLyr != null)

                        return inputLyr.getDataStore().getCellSize();

                return 1;

        }

        public DataSourcePreview cloneDataSourcePreview() {

                return this;

        }

        public void popStatus() {

        }

        public void pushStatus() {

        }

        public void draw(BufferedImage image, Graphics2D g, double[] coords, int w, int h, Cancellable cancel, double scale) throws ImageUnavailableException {

                //Posici?n de inicio dibujado dentro del Graphics

                int x = 0;

                int y = 0;

                //Coordenadas de la petici?n

                double iniX = coords[0];

                double iniY = coords[1];

                double endX = coords[2];

                double endY = coords[3];

                //Se ajustan las coordenadas de petici?n, ancho y alto en coordenadas p?xel, 

                //as? como la coordenada de inicio de dibujado 

                if(bbox.getULX() > coords[0]) {

                        iniX = bbox.getULX();

                        x = (int)(((iniX - coords[0]) * w) / Math.abs(coords[2] - coords[0]));

                }

                if(bbox.getULY() < coords[1]) {

                        iniY = bbox.getULY();

                        y = (int)(((coords[1] - iniY) * h) / Math.abs(coords[3] - coords[1]));

                }

                if(bbox.getLRX() < coords[2]) 

                        endX = bbox.getLRX();

                if(bbox.getLRY() > coords[3]) 

                        endY = bbox.getLRY();

                if(iniX != coords[0] || endX != coords[2]) {

                        w = (int)((Math.abs(endX - iniX) * w) / Math.abs(coords[2] - coords[0]));

                }

                if(iniY != coords[1] || endY != coords[3]) {

                        h = (int)((Math.abs(iniY - endY) * h) / Math.abs(coords[3] - coords[1]));

                }

                Extent ext = RasterLocator.getManager().getDataStructFactory().createExtent(iniX, iniY, endX, endY);

                BufferedImage img = throwProcess(ext, w, h);

                g.drawImage(img, x, y, null);

        }

        /**

         * Throws the process sequentially. Since the preview is small,

         * it should not taken a lot of time

         * is small

         * @param ext

         * @param w

         * @param h

         * @return

         */

        @SuppressWarnings("unchecked")

        private BufferedImage throwProcess(Extent ext, int w, int h) {

                loadLayers();

                RasterProcess task;

                try {

                        task = RasterBaseAlgorithmLibrary.getManager().createRasterTask("ROIMaskProcess");

                        task.addParam(ROIMaskProcess.RASTER_STORE1, inputLyr.getDataStore());

                        task.addParam(ROIMaskProcess.TEST_EXTENT, ext);

                        task.addParam(ROIMaskProcess.TEST_WIDTH, w);

                        task.addParam(ROIMaskProcess.TEST_HEIGHT, h);

                        task.addParam(ROIMaskProcess.ROIS, getROIsSelected());

                        task.addParam(ROIMaskProcess.ALPHA, data.getAlpha());

                        task.addParam(ROIMaskProcess.INVERSE, data.isInverse());

                        task.addParam(ROIMaskProcess.NODATA, getNoDataSelected());

                        task.addParam(ROIMaskProcess.EXPORT, false);

                } catch (ProcessException e1) {

                        e1.printStackTrace();

                        return null;

                } catch (ROIException e) {

                        e.printStackTrace();

                        return null;

                }

                task.init();

                try {

                        task.process();

                } catch (ProcessInterruptedException e1) {

                        return null;

                } catch (ProcessException e) {

                        logger.debug("Error in process");

                        return null;

                }

                HashMap<String, Object> map = (HashMap<String, Object>)task.getResult();

                Buffer buf = (Buffer)map.get(ROIMaskProcess.BUFFER);

                Buffer alphaBand = (Buffer)map.get(ROIMaskProcess.ALPHA_BAND);

                buf.setDataExtent(ext.toRectangle2D());

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

                        buf.replicateBand(0, 1);

                        buf.replicateBand(0, 2);

                }

                Transparency transparency = RasterLocator.getManager().getDataStructFactory().createTransparency();

                if(alphaBand != null) {

                        transparency.setAlphaBand(alphaBand);

                        transparency.activeTransparency();

                }

                ImageDrawer drawer = RasterLocator.getManager().createImageDrawerService();

                drawer.setBuffer(buf);

                drawer.setLastTransparency(transparency);

                try {

                        if(inputLyr.getDataStore().getDataType()[0] != Buffer.TYPE_BYTE)

                                drawer.addEnhanced(inputLyr.getDataStore().getStatistics(), true, 0.2);

                        return (BufferedImage)drawer.drawBufferOverImageObject();

                } catch (ProcessInterruptedException e) {

                        return null;

                } 

    }

        private NoData getNoDataSelected() {

                NoData nodata = RasterLocator.getManager().getDataStructFactory().createDefaultNoData(

                                inputLyr.getDataStore().getBandCount(), inputLyr.getDataStore().getDataType()[0]);

                nodata.setValue(data.getValueNoData());

                return nodata;

        }

        private ROI[] getROIsSelected() throws ROIException {

                List<ROI> roi = inputLyr.getRois();

                boolean[] roisSelected = data.getROIsSelected();

                List<ROI> roisToDraw = new ArrayList<ROI>(); 

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

                        if(roisSelected[i])

                                roisToDraw.add(roi.get(i));

                }

                return roisToDraw.toArray(new ROI[0]);

        }

        public Object getSource() {

                return null;

        }

        public Rectangle2D getBBoxRectangle() {

                if(inputLyr != null)

                        return inputLyr.getFullRasterExtent().toRectangle2D();

                return new Rectangle2D.Double();

        }

        public void addParams(RasterProcess task, String path, String fileName) throws ROIException {

                if(!fileName.matches("([*]\\.[???])")) {

                        fileName += ".tif";

                }

                task.addParam(ROIMaskProcess.PATH, path + File.separator + fileName);

                task.addParam(ROIMaskProcess.RASTER_STORE1, inputLyr.getDataStore());

                task.addParam(ROIMaskProcess.ROIS, getROIsSelected());

                task.addParam(ROIMaskProcess.ALPHA, data.getAlpha());

                task.addParam(ROIMaskProcess.INVERSE, data.isInverse());

                task.addParam(ROIMaskProcess.NODATA, getNoDataSelected());

                task.addParam(ROIMaskProcess.EXPORT, true);

        }

}