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.tools.app.basic.tool.saveviewtoraster.ui.listener;

import java.awt.Component;

import java.awt.Dimension;

import java.awt.event.ActionEvent;

import java.io.File;

import javax.swing.JOptionPane;

import org.cresques.cts.IProjection;

import org.gvsig.andami.PluginServices;

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.fmap.mapcontext.layers.FLayers;

import org.gvsig.fmap.mapcontrol.MapControl;

import org.gvsig.gui.beans.buttonspanel.ButtonsPanel;

import org.gvsig.gui.beans.buttonspanel.ButtonsPanelEvent;

import org.gvsig.gui.beans.buttonspanel.ButtonsPanelListener;

import org.gvsig.gui.beans.propertiespanel.PropertiesPanel;

import org.gvsig.raster.algorithm.RasterBaseAlgorithmLibrary;

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

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

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

import org.gvsig.raster.mainplugin.config.Configuration;

import org.gvsig.raster.swing.RasterSwingLibrary;

import org.gvsig.raster.tools.algorithm.swing.saveraster.SaveRasterPanel;

import org.gvsig.raster.tools.app.basic.tool.saveraster.ui.property.WriterPropertiesDialog;

import org.gvsig.raster.tools.app.basic.tool.saveviewtoraster.ui.SaveViewToRasterDialog;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Clase que gestiona los eventos de los botones del dialogo de Salvar a raster.

 *

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

 *

 */

public class SaveViewToRasterDialogListener implements ButtonsPanelListener {

        private static final GeometryManager         geomManager        = GeometryLocator.getGeometryManager();

        private Logger                          log         = LoggerFactory.getLogger(SaveViewToRasterDialogListener.class);

        private SaveViewToRasterDialog          dialog                 = null;

        private FLayers                                                        layers                = null;

        private MapControl                                                mapCtrl         = null;

        private RasterWriter                    writer                 = null;

        /**

         * Constructor

         * @param dialog

         */

        public SaveViewToRasterDialogListener(SaveViewToRasterDialog dialog, FLayers layers, MapControl mapCtrl) {

                this.dialog = dialog;

                this.layers = layers;

                this.mapCtrl = mapCtrl;

                dialog.addButtonPressedListener(this);

                //Captura de eventos para el bot?n de propiedades

                (dialog.getSaveRasterPanel()).getBProperties().addActionListener(new java.awt.event.ActionListener() {

                        public void actionPerformed(java.awt.event.ActionEvent evt) {

                                propsButtonActionPerformed(evt);

                        }

                });

        }

        public boolean isCorrectlyConfigured() {

                SaveRasterPanel controlPanel = dialog.getSaveRasterPanel();

                try {

                        double ulx = Double.parseDouble(controlPanel.getValueULX());

                        double uly = Double.parseDouble(controlPanel.getValueULY());

                        double lrx = Double.parseDouble(controlPanel.getValueLRX());

                        double lry = Double.parseDouble(controlPanel.getValueLRY());

                        if(Math.abs(uly - ulx) == 0 || Math.abs(lry - lrx) == 0) {

                                RasterSwingLibrary.messageBoxError("wc_wrong", controlPanel);

                                return false;

                        } 

                        if(controlPanel.isPixelMethodSelected()) {

                                int wpx = Integer.parseInt(controlPanel.getWidthPxValue());

                                int hpx = Integer.parseInt(controlPanel.getHeightPxValue());

                                double cellsize = Double.parseDouble(controlPanel.getCellSize());

                                if(wpx == 0) {

                                        RasterSwingLibrary.messageBoxError("width_cannot_be_zero", controlPanel);

                                        return false;

                                }

                                if(hpx == 0) {

                                        RasterSwingLibrary.messageBoxError("height_cannot_be_zero", controlPanel);

                                        return false;

                                }

                                if(cellsize == 0) {

                                        RasterSwingLibrary.messageBoxError("cellsize_cannot_be_zero", controlPanel);

                                        return false;

                                }

                        } else {

                                int cmsx = Integer.parseInt(controlPanel.getValueXCms());

                                int cmsy = Integer.parseInt(controlPanel.getValueYCms());

                                int scale = Integer.parseInt(controlPanel.getScaleValue());

                                if(cmsx == 0) {

                                        RasterSwingLibrary.messageBoxError("width_cannot_be_zero", controlPanel);

                                        return false;

                                }

                                if(cmsy == 0) {

                                        RasterSwingLibrary.messageBoxError("height_cannot_be_zero", controlPanel);

                                        return false;

                                }

                                if(scale == 0) {

                                        RasterSwingLibrary.messageBoxError("scale_cannot_be_zero", controlPanel);

                                        return false;

                                }

                        }

                        String fName = controlPanel.getLFileName().getText();

                        if(fName == null || fName.equals("")) {

                                RasterSwingLibrary.messageBoxError("filename_cannot_be_empty", controlPanel);

                                return false;

                        }

                } catch (NumberFormatException e) {

                        RasterSwingLibrary.messageBoxError("some_parameter_is_not_correct", controlPanel);

                        return false;

                }

                return true;

        }

        /**

         * Eventos para los botones de aplicar, aceptar y cancelar

         * @param e

         */

        public void actionButtonPressed(ButtonsPanelEvent e) {

                switch (e.getButton()) {

                case ButtonsPanel.BUTTON_APPLY:

                        if(isCorrectlyConfigured()) {

                                checkProjections();

                                acceptButtonActionPerformed(e);

                        }

                        break;

                case ButtonsPanel.BUTTON_CLOSE:

                        dialog.closeJDialog();

                        break;

                }

        }

        /**

         * Checks that the view projection be the same that every layer 

         * loaded in the TOC and shows a message if not

         * @return

         */

        private boolean checkProjections() {

                IProjection viewProj = mapCtrl.getProjection();

                for (int i = 0; i < layers.getLayersCount(); i++) {

                        FLayer lyr = layers.getLayer(i);

                        if(lyr.getProjection() == null || !lyr.getProjection().getAbrev().equals(viewProj.getAbrev())) {

                                RasterSwingLibrary.messageBoxInfo("different_projection", dialog);

                                return false;

                        }

                }

                return true;

        }

        /**

         * Acciones realizadas al aceptar.

         * @param e

         * @return true si se ha completado la operaci?n de escritura y false si no se ha hecho

         */

        private boolean acceptButtonActionPerformed(ButtonsPanelEvent e) {

                SaveRasterPanel controlPanel = dialog.getSaveRasterPanel();

                String fName = dialog.getDataInputListener().getFileName();

                int wpx = 0;

                int hpx = 0;

                if(controlPanel.isPixelMethodSelected()) {

                        wpx = Integer.valueOf(controlPanel.getWidthPxValue());

                        hpx = Integer.valueOf(controlPanel.getHeightPxValue());

                } else {

                        wpx = Integer.valueOf(controlPanel.getWidthPxPrint());

                        hpx = Integer.valueOf(controlPanel.getHeightPxPrint());

                }

                Dimension dimension = new Dimension(wpx, hpx);

                //Limitamos el tama?o

                if(wpx > 20000 || wpx > 20000) {

                        if(!RasterSwingLibrary.messageBoxYesOrNot("output_file_too_big", null))

                                return false;

                }

                //Comprobamos que el en la ruta de destino tengamos permisos de escritura

                File f = new File(fName);

                if(f.exists())

                        if(!RasterSwingLibrary.messageBoxYesOrNot("raster_error_file_exists", dialog))

                                return false;

                f = new File(fName.substring(0, fName.lastIndexOf(File.separator)));

                if(f.exists() && f.isDirectory() && !f.canWrite()) {

                        RasterSwingLibrary.messageBoxError("error_file_not_writable", dialog);

                        return false;

                }

                double lrX = Double.parseDouble(controlPanel.getValueLRX());

                double lrY = Double.parseDouble(controlPanel.getValueLRY());

                double ulX = Double.parseDouble(controlPanel.getValueULX());

                double ulY = Double.parseDouble(controlPanel.getValueULY());

                Envelope ext = null;

                try{

                        ext = geomManager.createEnvelope(ulX, lrY, lrX, ulY, SUBTYPES.GEOM2D);

                }catch(CreateEnvelopeException e1){

                        log.debug("Error creating the envelope", null, e1);

                }

                // Controlamos el tama?o en caso de un jpeg2000

                long bytes = RasterLocator.getManager().getRasterUtils().getBytesFromRaster((int)dimension.getWidth(),

                                (int)dimension.getHeight(), 0, 3);        

                long maxJp2 = 13000 * 12500 * 3;

                if (fName.endsWith(".jp2")) {

                        if (bytes > maxJp2) {

                                if(!RasterSwingLibrary.messageBoxYesOrNot("output_file_too_big_jpeg2000", null))

                                        return false;

                        }

                }

                Params params = getWriterParams(fName);

                int blockSize = getBlockSize(params, layers);

                ViewPort viewPort = new ViewPort(mapCtrl.getViewPort().getProjection());

                viewPort.setBackColor(mapCtrl.getViewPort().getBackColor());

                viewPort.setImageSize(dimension);

                viewPort.setEnvelope(ext);

                try {

                        DataProcess saveRasterProcess = RasterBaseAlgorithmLibrary.getManager().createRasterTask("SaveRasterProcess");

                        saveRasterProcess.setActions(new SaveRasterActions(dialog.getViewName()));

                        saveRasterProcess.addParam("ViewPort", viewPort);

                        saveRasterProcess.addParam("Dimension", dimension);

                        saveRasterProcess.addParam("Blocksize", blockSize);

                        saveRasterProcess.addParam("FileName", fName);

                        saveRasterProcess.addParam("FLyrs", layers);

                        saveRasterProcess.addParam("writerparams", params);

                        saveRasterProcess.addParam("Projection", mapCtrl.getProjection());

                        saveRasterProcess.start();

                } catch (ProcessException e1) {

                        RasterSwingLibrary.messageBoxError("error_processing", this, e1);

                }

                return true;

        }

        /**

         * Funci?n a ejecutar cuando se pulsa el bot?n de propiedades.

         * @param e ActionEvent

         */

        private void propsButtonActionPerformed(ActionEvent e){

                String name = dialog.getDataInputListener().getFileName();

                //Si no se ha seleccionado ning?n fichero salimos

                if(name == null || name.equals(""))

                        return;

                Params params = getWriterParams(name);

                PropertiesPanel panel = new PropertiesPanel();

                WriterPropertiesDialog dialog = new WriterPropertiesDialog(panel, params);

                PluginServices.getMDIManager().addWindow(dialog);

        }

        /**

         * Obtiene los par?metros del driver de escritura. Si el driver no se ha creado a?n se obtienen

         * unos par?metros con la inicializaci?n por defecto. Si se ha creado ya y se han modificado se

         * devuelven los par?metros con las modificaciones. Si se cambia de driver se devolver? un WriterParams

         * como si fuera la primera vez que se abre.

         * @param name Nombre del fichero sobre el que se salva.

         * @return WriterParams

         */

        private Params getWriterParams(String name) {

                RasterManager rManager = RasterLocator.getManager();

                String ext = rManager.getFileUtils().getExtensionFromFileName(name);

                try {

                        if(writer == null) //La primera vez que se obtiene el driver

                                writer = rManager.createWriter(name);

                        else {

                                String newType = rManager.getProviderServices().getWriteDriverType(ext);

                                String oldType = writer.getDriverName();

                                if(!newType.equals(oldType))  //Cambio de driver despu?s de haber seleccionado y modificado las propiedades de uno

                                        writer = rManager.createWriter(name);

                        }

                        if(writer == null)

                                JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(), PluginServices.getText(this, "no_driver_escritura"));

                        return writer.getParams();

                } catch (NotSupportedExtensionException e1) {

                        JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(), PluginServices.getText(this, "no_driver_escritura"));

                        return null;

                } catch (RasterDriverException e1) {

                        JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(), PluginServices.getText(this, "no_driver_escritura"));

                        return null;

                }

        }

        /**

         * Calculo del tama?o de bloque. Para ello comprueba si el raster est? siendo tileado. Si est? siendo

         * tileado se aplica el alto del tile menor para no pedir un bloque mayor que lo que un servidor puede

         * devolver. Si no est? siendo tileado se devuelve el tama?o de bloque de los par?metros.

         * @param flyrs Capas

         * @param params Par?metros del driver de escritura

         * @return tama?o de bloque

         */

        private int getBlockSize(Params params, FLayers flyrs) {

                int blockSize = Configuration.getValue("cache_blockheight", Integer.valueOf(RasterLibrary.blockHeight)).intValue();

                blockSize = RasterLibrary.blockHeight;

                //Recorremos todas las capas comprobando si alguna de ellas implementa RasterOperations y tilea.

                //En ese caso se obtiene el ancho de bloque. El ancho de bloque total ser? el menor obtenido.

                //Esto lo hacemos para que las capas que tilean WebMapService, WebCoverageService, ... no hagan demasiadas peticiones al servidor

                //por tener un ancho de bloque muy peque?o de modo que el ancho del bloque se ajuste al Tile menor

                //soportado por los servidores que intervienen en el salvado.

                int[] wBlock = null;

                boolean isTiling = false;

                int block = Integer.MAX_VALUE;

                for(int i = 0; i < flyrs.getLayersCount(); i++)

                        if(flyrs.getLayer(i) instanceof FLyrRaster)

                                if(((FLyrRaster)flyrs.getLayer(i)).isTiled()){

                                        wBlock = ((FLyrRaster)flyrs.getLayer(i)).getTileSize();

                                        if((wBlock[0] - 1)< block){

                                                block = wBlock[0] - 1;

                                                isTiling = true;

                                        }

                                }

                if(isTiling) {

                        params.changeParamValue("blocksize", String.valueOf(block));

                        return block;

                }

                return blockSize;

        }

}