| gvSIG desktop 1

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

*

* Copyright (C) 2005 IVER T.I. and Generalitat Valenciana.

*

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

*/

package org.gvsig.rastertools.cutting;

import java.io.IOException;

import org.gvsig.gui.beans.incrementabletask.IncrementableEvent;

import org.gvsig.gui.beans.incrementabletask.IncrementableListener;

import org.gvsig.gui.beans.incrementabletask.IncrementableTask;

import org.gvsig.raster.buffer.BufferFactory;

import org.gvsig.raster.dataset.GeoRasterWriter;

import org.gvsig.raster.dataset.IBuffer;

import org.gvsig.raster.dataset.NotSupportedExtensionException;

import org.gvsig.raster.dataset.RasterDriverException;

import org.gvsig.raster.dataset.RasterMultiDataset;

import org.gvsig.raster.dataset.WriterParams;

import org.gvsig.raster.shared.Extent;

import org.gvsig.rastertools.cutting.ui.listener.CuttingPanelListener;

/**

 * <code>CuttingProcess</code> es un proceso que usa un <code>Thread</code>

 * para calcular el recorte de una capa.

 *

 * @version 24/04/2007

 * @author Borja S?nchez Zamorano (borja.sanchez@iver.es)

 */

public class CuttingProcess implements Runnable, IncrementableListener {

        private String                                                                 fileName = "";

        private IncrementableTask                        incrementableTask = null;

        private volatile Thread                                blinker = null;

        private WriterBufferServer                writerBufferServer = null;

        private RasterMultiDataset                rasterMultiDataset = null;

        private Extent                                                                extent = null;

        private boolean                                                                oneLayerPerBand = false;

        private int[]                                                                        drawableBands = null;

        private CuttingPanelListener        cuttingPanelListener = null;

        private int[]                                                                        dValues = null;

        /**

         * Variables de la resoluci?n de salida

         */

        private int                                                                                resolutionWidth = 0, resolutionHeight = 0;

        /**

         * Crea un <code>CuttingProcess</code> para generar un recorte

         * @param cuttingPanelListener

         * @param dValues

         * @param fileName

         * @param writerBufferServer

         * @param rasterMultiDataset

         * @param extent

         * @param drawableBands

         * @param oneLayerPerBand

         */

        public CuttingProcess(CuttingPanelListener cuttingPanelListener, int[] dValues, String fileName, WriterBufferServer writerBufferServer, RasterMultiDataset rasterMultiDataset, Extent extent, int[] drawableBands, boolean oneLayerPerBand) {

                this.fileName = fileName;

                this.writerBufferServer = writerBufferServer;

                this.rasterMultiDataset = rasterMultiDataset;

                this.extent = extent;

                this.oneLayerPerBand = oneLayerPerBand;

                this.drawableBands = drawableBands;

                this.cuttingPanelListener = cuttingPanelListener;

                this.dValues = dValues;

        }

        /**

         * Arranca el proceso de recorte de un layer

         */

        public void start() {

                blinker = new Thread(this);

                blinker.start();

        }

        /**

         * Establecer la resolucion de salida al crear el recorte

         * @param width

         * @param height

         */

        public void setResolution(int width, int height) {

                resolutionWidth = width;

                resolutionHeight = height;

        }

        /**

         * Escribir el recorte en disco usando las bandas especificadas

         * @param file Ruta completa del fichero

         * @param bands Array de bandas que se quieren guardar en dicho fichero

         * @throws NotSupportedExtensionException

         * @throws RasterDriverException

         * @throws IOException

         */

        private void WriteFile(String file, int[] bands)

                        throws NotSupportedExtensionException, RasterDriverException, IOException {

                BufferFactory bufferFactory = new BufferFactory(rasterMultiDataset);

                bufferFactory.addDrawableBands(bands);

                bufferFactory.setAreaOfInterest(dValues[0], dValues[3], dValues[2] - dValues[0], dValues[1] - dValues[3], resolutionWidth, resolutionHeight);

                IBuffer buffer = bufferFactory.getRasterBuf();

                writerBufferServer.setBuffer(buffer);

                WriterParams params = GeoRasterWriter.getWriter(file).getParams();

                GeoRasterWriter grw = GeoRasterWriter.getWriter(writerBufferServer, file,

                                buffer.getBandCount(), extent, buffer.getWidth(), buffer.getHeight(),

                                buffer.getDataType(), params);

                grw.dataWrite();

                grw.writeClose();

        }

        /**

         *

         */

        public void run() {

                try {

                        if (oneLayerPerBand) {

                                int[] drawableBandsAux = new int[1];

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

                                        drawableBandsAux[0] = drawableBands[i];

                                        WriteFile(fileName + "_B" + drawableBandsAux[0] + ".tif", drawableBandsAux);

                                        cuttingPanelListener.cutFinalize(fileName + "_B" + drawableBandsAux[0] + ".tif");

                                }

                        } else {

                                WriteFile(fileName + ".tif", drawableBands);

                                cuttingPanelListener.cutFinalize(fileName + ".tif");

                        }

                } catch (NotSupportedExtensionException e) {

                        e.printStackTrace();

                } catch (RasterDriverException e) {

                        e.printStackTrace();

                } catch (IOException e) {

                        e.printStackTrace();

                }

                if (incrementableTask != null)

                        incrementableTask.processFinalize();

        }

        /**

         * Asigna la tarea

         * @param value

         */

        public void setIncrementableTask(IncrementableTask value) {

                incrementableTask = value;

                incrementableTask.addIncrementableListener(this);

        }

        public void actionCanceled(IncrementableEvent e) {

        }

        public void actionResumed(IncrementableEvent e) {

        }

        public void actionSuspended(IncrementableEvent e) {

        }

}