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

import java.awt.Component;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.io.File;

import java.util.ArrayList;

import javax.swing.Icon;

import javax.swing.JOptionPane;

import javax.swing.filechooser.FileFilter;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.ui.mdiManager.IWindow;

import org.gvsig.app.project.documents.view.gui.AbstractViewPanel;

import org.gvsig.app.project.documents.view.toc.AbstractTocContextMenuAction;

import org.gvsig.app.project.documents.view.toc.ITocItem;

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

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

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

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

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

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

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

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

import org.gvsig.gui.beans.swing.JFileChooser;

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

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

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

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

import org.gvsig.raster.mainplugin.toolbar.IGenericToolBarMenuItem;

import org.gvsig.raster.swing.RasterSwingLibrary;

import org.gvsig.raster.tools.app.basic.RasterToolsUtil;

import org.gvsig.raster.tools.app.basic.raster.process.ClippingProcess;

import org.gvsig.raster.util.ExtendedFileFilter;

/**

 * <p>

 * Entrada del TOC que corresponde con la opci?n "Salvar Como" de raster. Esta se apoya

 * en el proceso de recorte de raster para salvar datos.

 * </p>

 * <p>

 * Cuando se abre el dialogo de "Salvar como" se cargan las extensiones soportadas en el

 * selector. Cada tipo de datos de la fuente soporta unas extensiones de escritura u otras.

 * Por ejemplo, si la capa de entrada  es FLOAT no podremos escribir a JPG2000 porque no

 * lo soporta, tendriamos que convertila primero a RGB.

 * </p>

 * <p>

 * Cambiando el tipo de extensi?n en el selector cambian el panel de propiedades asociado.

 * El fichero de salidad se salvar? con las propiedades ajustadas.

 * </P>

 * @version 30/05/2007

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

 *

 */

public class SaveAsTocMenuEntry extends AbstractTocContextMenuAction implements PropertyChangeListener, IGenericToolBarMenuItem {

        static private SaveAsTocMenuEntry singleton     = null;

        private JFileChooser              chooser       = null;

        private PropertiesComponent       panelProperty = null;

        /**

         * Nadie puede crear una instancia a esta clase ?nica, hay que usar el

         * getSingleton()

         */

        private SaveAsTocMenuEntry() {}

        /**

         * Devuelve un objeto unico a dicha clase

         * @return

         */

        static public SaveAsTocMenuEntry getSingleton() {

                if (singleton == null)

                        singleton = new SaveAsTocMenuEntry();

                return singleton;

        }

        public String getGroup() {

                return "RasterExport";

        }

        public int getGroupOrder() {

                return 50;

        }

        public int getOrder() {

                return 1;

        }

        public String getText() {

                return PluginServices.getText(this, "saveas");

        }

        public boolean isEnabled(ITocItem item, FLayer[] selectedItems) {

                if ((selectedItems == null) || (selectedItems.length != 1))

                        return false;

                if (!(selectedItems[0] instanceof ILayerState))

                        return false;

                if (!((ILayerState) selectedItems[0]).isOpen())

                        return false;

                return true;

        }

        public boolean isVisible(ITocItem item, FLayer[] selectedItems) {

                if ((selectedItems == null) || (selectedItems.length != 1))

                        return false;

                if (!(selectedItems[0] instanceof IRasterLayerActions))

                        return false;

                return (((IRasterLayerActions) selectedItems[0]).isActionEnabled(IRasterLayerActions.SAVEAS));

        }

        public void execute(ITocItem item, FLayer[] selectedItems) {

                FLayer lyr = null;

                IWindow w = PluginServices.getMDIManager().getActiveWindow();

                RasterManager rManager = RasterLocator.getManager();

                if (selectedItems.length != 1)

                        return;

                lyr = selectedItems[0];

                if (!(lyr instanceof FLyrRaster))

                        return;

                FLyrRaster fLayer = (FLyrRaster)lyr;

                chooser = new JFileChooser("SAVE_AS_TOC_MENU_ENTRY",JFileChooser.getLastPath("SAVE_AS_TOC_MENU_ENTRY", null));

                chooser.addPropertyChangeListener(this);

                chooser.setDialogTitle(PluginServices.getText(this, "seleccionar_fichero"));

                // Cargamos las extensiones en la lista

                ArrayList<String> extList = new ArrayList<String>();

                try {

                        ProviderServices serv = rManager.getProviderServices();

                        extList = serv.getExtensionsSupported(fLayer.getDataStore().getDataType()[0], fLayer.getDataStore().getBandCount());

                } catch (RasterDriverException e2) {

                        RasterSwingLibrary.messageBoxError("error_extensiones_soportadas", chooser, e2);

                        e2.printStackTrace();

                        return;

                }

                int selected_id = extList.size() - 1;

                FileFilter selected = null;

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

                        FileFilter filter = new ExtendedFileFilter((String) extList.get(i));

                        if (extList.get(i).equals("tif")) {

                                selected = filter;

                                selected_id = i;

                        }

                        chooser.addChoosableFileFilter(filter);

                }

                if (selected != null)

                        chooser.setFileFilter(selected);

                // Cargamos el panel de propiedades en el selector

                panelProperty = loadPanelProperties((String) extList.get(selected_id));

                chooser.setAccessory(panelProperty);

                chooser.setAcceptAllFileFilterUsed(false);

                if (w instanceof AbstractViewPanel) {

                        if (chooser.showSaveDialog(((AbstractViewPanel) w).getComponent(0)) == JFileChooser.APPROVE_OPTION) {

                                // Creaci?n de par?metros

                                String tit = PluginServices.getMDIManager().getWindowInfo(w).getTitle();

                                RasterDataStore datastore = ((FLyrRaster)fLayer).getDataStore();

                                int[] drawableBands = new int[fLayer.getDataStore().getBandCount()];

                                for (int i = 0; i < fLayer.getDataStore().getBandCount(); i++)

                                        drawableBands[i] = i;

                                JFileChooser.setLastPath("SAVE_AS_TOC_MENU_ENTRY", chooser.getCurrentDirectory());

                                String file =  ((ExtendedFileFilter) chooser.getFileFilter()).getNormalizedFilename(chooser.getSelectedFile());

                                long bytes = rManager.getRasterUtils().getBytesFromRaster((int)fLayer.getDataStore().getWidth(),

                                                (int) fLayer.getDataStore().getHeight(),

                                                fLayer.getDataStore().getDataType()[0],

                                                fLayer.getDataStore().getBandCount());

                                long maxJp2 = 13000 * 12500 * 3;

                                if (bytes > (20000 * 20000 * 3)) {

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

                                                return;

                                }

                                if(new File(file).exists()) {

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

                                                return;

                                }

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

                                        if (bytes > maxJp2) {

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

                                                        return;

                                        }

                                }

                                if (!RasterToolsUtil.canWrite(chooser.getCurrentDirectory().toString(), this))

                                        return;

                                Params params = null;

                                try {

                                        params = rManager.createWriter(file).getParams();

                                } catch (NotSupportedExtensionException e1) {

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

                                } catch (RasterDriverException e1) {

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

                                }

                                // Lanzamiento del proceso de guardado

                                DataProcess clippingProcess = new ClippingProcess();

                                clippingProcess.setActions(new SaveAsActions());

                                clippingProcess.addParam("viewname", tit);

                                if(fLayer.isRemote()) {

                                        Envelope env = ((AbstractViewPanel)w).getMapControl().getViewPort().getEnvelope();

                                        clippingProcess.addParam("realcoordinates", new double[] { env.getMinimum(0), env.getMaximum(1), env.getMaximum(0), env.getMinimum(1)});

                                        clippingProcess.addParam("resolution", new int[]{(int) fLayer.getDataStore().getWidth(),

                                                                                                                                          (int) fLayer.getDataStore().getHeight()});

                                } else {

                                        clippingProcess.addParam("pixelcoordinates", new int[] { 0, (int) fLayer.getDataStore().getHeight(), (int) fLayer.getDataStore().getWidth(), 0 });

                                        clippingProcess.addParam("resolution", new int[]{(int) fLayer.getDataStore().getWidth(),

                                                                                                                                          (int) fLayer.getDataStore().getHeight()});

                                }

                                int index = file.lastIndexOf(".");

                                if(index > 0) {

                                        String suffix = file.substring(index, file.length());

                                        if(suffix.length() == 4)

                                                clippingProcess.addParam("suffix", suffix);

                                }

                                clippingProcess.addParam("filename", file);

                                clippingProcess.addParam("layer", fLayer.getDataStore());

                                clippingProcess.addParam("drawablebands", drawableBands);

                                clippingProcess.addParam("colorInterpretation", datastore.getColorInterpretation());

                                clippingProcess.addParam("onelayerperband", new Boolean(false));

                                clippingProcess.addParam("interpolationmethod", new Integer(Buffer.INTERPOLATION_NearestNeighbour));

                                clippingProcess.addParam("affinetransform", datastore.getAffineTransform());

                                clippingProcess.addParam("viewProjection", ((AbstractViewPanel) w).getMapControl().getProjection());

                                if (params != null)

                                        RasterToolsUtil.loadWriterParamsFromPropertiesPanel(panelProperty, params);

                                clippingProcess.addParam("driverparams", params);

                                clippingProcess.start();

                        }

                }

        }

        /**

         * Evento que se produce al cambiar el driver de escritura. Esto

         * sustituye el panel properties por el del nuevo driver seleccionado

         */

        public void propertyChange(PropertyChangeEvent evt) {

                if (evt.getNewValue() instanceof ExtendedFileFilter) {

                        String ext = ((ExtendedFileFilter) evt.getNewValue()).getExtensions().get(0).toString();

                        panelProperty = loadPanelProperties(ext);

                        chooser.setAccessory(panelProperty);

                        chooser.revalidate();

                }

        }

        /**

         * Obtiene el objeto PropertiesComponent para una extensi?n concreta de fichero

         * sobre el que se va a escribir.

         * @param file Fichero raster sobre el que se escribir?

         * @return PropertiesComponent

         */

        private PropertiesComponent loadPanelProperties(String file) {

                PropertiesComponent panelProperty = new PropertiesComponent();

                Params params = null;

                try {

                        params = RasterLocator.getManager().createWriter(file).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;

                }

                RasterToolsUtil.loadPropertiesFromWriterParams(panelProperty, params, null);

                return panelProperty;

        }

        public Icon getIcon() {

                return IconThemeHelper.getImageIcon("layer-saveas");

        }

        public boolean isEnableEvents() {

                return true;

        }

}