Application: gvSIG desktop » gvSIG raster

package org.gvsig.raster.tools.app.basic.raster.process;

import java.io.IOException;

import java.util.ArrayList;

import javax.swing.SwingUtilities;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.exception.CloseException;

import org.gvsig.i18n.Messages;

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

import org.gvsig.raster.tools.app.basic.raster.bean.previewbase.ParamStruct;

/**

 * Clase donde se hara todo el proceso de aplicar una lista de filtros a una

 * capa. Muestra una ventana de dialogo de incremento informativa.

 *

 * @author BorSanZa - Borja S?nchez Zamorano 

 */

public class FilterProcess extends RasterProcess {

        private String                   filename         = "";

        private RasterDataStore          rasterDataSource = null;

        private ArrayList<ParamStruct>   listFilterUsed   = null;

        private RasterFilterList         rasterFilterList = null;

        private RasterWriter             geoRasterWriter  = null;

        private FLyrRaster               lyr              = null;

        private RasterManager            rManager         = RasterLocator.getManager();

        public void init() {

                filename = getStringParam("filename");

                listFilterUsed = (ArrayList) getParam("listfilterused");

                lyr = (FLyrRaster)getParam("layer");

                rasterDataSource = lyr.getDataStore();

        }

        /**

         * Devuelve una interpretacion de color. Es usado cuando no conseguimos un

         * rendering y no podemos saber que interpretacion l?gica ten?a antes.

         * @param geoRasterWriter

         */

        private ColorInterpretation getColorIntepretation(Buffer buffer, RasterFilterList filterList) {

                ColorInterpretation colorInterpretation = null;

                do {

                        // Si tiene una tabla de color asignamos las tres bandas

                        if (filterList.isActive("colortable")) {

                                colorInterpretation = rManager.getDataStructFactory().createColorInterpretation(

                                                new String[] { 

                                                                ColorInterpretation.RED_BAND, 

                                                                ColorInterpretation.GREEN_BAND, 

                                                                ColorInterpretation.BLUE_BAND,

                                                                ColorInterpretation.ALPHA_BAND 

                                                                });

                                break;

                        }

                        // Si el numero de bandas coincide asignamos la misma interpretacion que tenia antes

                        if (buffer.getBandCount() == rasterDataSource.getBandCount()) {

                                colorInterpretation = rasterDataSource.getColorInterpretation();

                                break;

                        }

                        String[] colorInterp = new String[rasterDataSource.getColorInterpretation().getValues().length];

                        for (int i = 0; i < rasterDataSource.getColorInterpretation().getValues().length; i++) {

                                if (rasterDataSource.getColorInterpretation().getValues()[i].equals(ColorInterpretation.UNDEF_BAND)) {

                                        colorInterp[i] = ColorInterpretation.GRAY_BAND;

                                        continue;

                                }

                                colorInterp[i] = rasterDataSource.getColorInterpretation().getValues()[i];

                        }

                        colorInterpretation = rManager.getDataStructFactory().createColorInterpretation(colorInterp);

                } while (false);

                return colorInterpretation;

        }

        public void process() throws ProcessInterruptedException, ProcessException {

                DataServerWriter writerBufferServer = null;

                if(lyr != null)

                        lyr.setReadingData(Thread.currentThread().getId() + "");

                RasterDataStore dstoreCopy = null;

                RasterQuery query          = null;

                Buffer buffer              = null;

                Buffer buff                = null;

                Buffer alpha               = null;

                try {

                        insertLineLog(Messages.getText("leyendo_raster"));

                        //Creaci?n del BufferFactory

                        dstoreCopy = rasterDataSource.newNotTiledDataStore();

                        query = rManager.createQuery();

                        //if (!RasterBuffer.loadInMemory(dsetCopy))

                        query.setReadOnly(true);

                        //Asignaci?n de bandas

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

                        if (renderBands != null) {

                                // Si es gris, se reduce a una sola banda

                                if ((renderBands.length == 3) && (renderBands[0] == renderBands[1]) && (renderBands[1] == renderBands[2])) 

                                        renderBands = new int[] { renderBands[0] };

                                query.setDrawableBands(renderBands);

                        } else

                                query.setAllDrawableBands();

                        query.setAreaOfInterest();

                        buff = dstoreCopy.query(query);

                        if(buff.isReadOnlyBuffer()) 

                                buff.addDrawableBands(renderBands);

                        insertLineLog(Messages.getText("aplicando_filtros"));

                        rasterFilterList = rManager.createEmptyFilterList(dstoreCopy.getDataType()[0]);

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

                        filterLoader.addSrcBandCount(dstoreCopy.getBandCount());

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

                        filterLoader.addSrcStatistics(dstoreCopy.getStatistics());

                        filterLoader.addTransparency(dstoreCopy.getTransparency());

                        addSelectedFilters(rasterFilterList, listFilterUsed);

                        buffer = filterLoader.applyFilters(buff);

                        insertLineLog(Messages.getText("guardando_capa"));

                        writerBufferServer = rManager.createDataServerWriter();

                        writerBufferServer.setBuffer(buffer, -1);

                        // TODO: FUNCIONALIDAD: Poner los getWriter con la proyecci?n del fichero fuente

                        ColorInterpretation colorInterpretation = getColorInterpretation(buffer.getBandCount(), buffer.getDataType());

                        geoRasterWriter = rManager.createWriter(writerBufferServer, 

                                        filename,

                                        buffer.getBandCount(), 

                                        rasterDataSource.getAffineTransform(), 

                                        buffer.getWidth(), 

                                        buffer.getHeight(), 

                                        buffer.getDataType(), 

                                        rManager.createWriter(filename).getParams(), 

                                        null);

                        if (lyr.getRender() == null)

                                colorInterpretation = getColorIntepretation(buffer, rasterFilterList);

                        geoRasterWriter.setColorBandsInterpretation(colorInterpretation.getValues());

                        geoRasterWriter.dataWrite();

                        geoRasterWriter.writeClose();

                        geoRasterWriter = null;

                        // Guardamos en el RMF el valor NoData

                        //Si el del buffer tiene valor es porque alg?n filtro le ha salvado valor nodata por lo que se pone ese

                        //sino se pone el de la imagen original

                        NoData nodataOrigin = (NoData)rasterDataSource.getNoDataValue();

                        NoData nodataBuffer =  (NoData)buffer.getNoDataValue();

                        if(nodataBuffer != null && nodataBuffer.isDefined()) {

                                nodataBuffer.setFileName(filename);

                                nodataBuffer.save();

                        } else if(nodataOrigin != null && nodataOrigin.isDefined()) {

                                nodataOrigin.setFileName(filename);

                                nodataOrigin.save();

                        }

                        SwingUtilities.invokeLater(new Runnable() {

                                public void run() {

                                        if (externalActions != null)

                                                externalActions.end(filename);

                                }

                        });

                } catch (NotSupportedExtensionException e) {

                        throw new ProcessException("error_writer_notsupportedextension", e);

                } catch (RasterDriverException e) {

                        throw new ProcessException("error_writer", e);

                } catch (IOException e) {

                        throw new ProcessException("error_writer", e);

                } catch (FilterTypeException e) {

                        throw new ProcessException("error_adding_filters", e);

                } catch (QueryException e) {

                        throw new ProcessException("error_loading_data", e);

                } catch (FilterManagerException e) {

                        throw new ProcessException("error_adding_filters", e);

                } finally {

                        if(writerBufferServer != null)

                                writerBufferServer.dispose();

                        if(buff != null)

                                buff.dispose();

                        if(rasterFilterList != null)

                                rasterFilterList.dispose();

                        if(alpha != null)

                                alpha.dispose();

                        if(dstoreCopy != null)

                                try {

                                        dstoreCopy.close();

                                } catch (CloseException e) {

                                }

                        if(lyr != null)

                                lyr.setReadingData(null);

                        dispose();

                }

        }

        private ColorInterpretation getColorInterpretation(int nBands, int dataType) {

                //Si la fuente es con paleta, al aplicarle un filtro se genera un ARGB

                if(lyr.existColorTable()) 

                        return rManager.getDataStructFactory().createColorInterpretation(

                                        new String[] { ColorInterpretation.RED_BAND, ColorInterpretation.GREEN_BAND, ColorInterpretation.BLUE_BAND, ColorInterpretation.ALPHA_BAND });

                if(dataType == Buffer.TYPE_BYTE) {

                        if(nBands == 3)

                                return rManager.getDataStructFactory().createColorInterpretation(

                                                new String[] { ColorInterpretation.RED_BAND, ColorInterpretation.GREEN_BAND, ColorInterpretation.BLUE_BAND });

                        if(nBands == 4)

                                return rManager.getDataStructFactory().createColorInterpretation(

                                                new String[] { ColorInterpretation.RED_BAND, ColorInterpretation.GREEN_BAND, ColorInterpretation.BLUE_BAND, ColorInterpretation.ALPHA_BAND });

                        if(nBands == 2 || nBands > 4) {

                                return lyr.getRender().getRenderColorInterpretation();

                                /*int[] renderBands = lyr.getRender().getRenderBands();

                                String[] ci = new String[renderBands.length];

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

                                        switch (renderBands[i]) {

                                        case 0:ci[i] = ColorInterpretation.RED_BAND; break;

                                        case 1:ci[i] = ColorInterpretation.GREEN_BAND; break;

                                        case 2:ci[i] = ColorInterpretation.BLUE_BAND; break;

                                        default: ci[i] = ColorInterpretation.UNDEF_BAND; 

                                        }

                                }

                                return rManager.getDataStructFactory().createColorInterpretation(ci);*/

                        }

                }

                if(nBands == 1)

                        return rManager.getDataStructFactory().createColorInterpretation(

                                new String[] { ColorInterpretation.GRAY_BAND });

                else {

                        String[] ci = new String[nBands];

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

                                ci[i] = ColorInterpretation.UNDEF_BAND;

                        }

                        return rManager.getDataStructFactory().createColorInterpretation(ci);

                }

        }

        /**

         * Sustituye la lista de filtros de filterList por la que le pasamos en forma

         * de ArrayList

         * @param filterList

         * @param listFilterUsed

         * @throws FilterTypeException 

         * @throws FilterTypeException 

         */

        public void addSelectedFilters(RasterFilterList filterList, ArrayList<ParamStruct> listFilterUsed) throws FilterManagerException, FilterTypeException {

                filterList.clear();

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

                        ParamStruct aux = (ParamStruct) listFilterUsed.get(i);

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

                        filterManager.addFilter(aux.getFilterClass(), aux.getFilterParam());

                }

                filterList.resetPercent();

        }

        public int getPercent() {

                if (rasterFilterList == null)

                        return 0;

                if (rasterFilterList.getPercent() < 100)

                        return rasterFilterList.getPercent();

                if (geoRasterWriter == null)

                        return 0;

                return geoRasterWriter.getPercent();

        }

        public String getTitle() {

                return Messages.getText("aplicando_filtros");

        }

        public void dispose() {

                rasterDataSource = null;

                if(listFilterUsed != null) {

                        listFilterUsed.clear();

                        listFilterUsed = null;

                }

                rasterFilterList = null;

                geoRasterWriter  = null;

                lyr              = null;

        }

        @Override

        protected void finalize() throws Throwable {

                dispose();

                super.finalize();

        }

}