Application: gvSIG desktop » gvSIG raster

package org.gvsig.raster.roimask.app;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.File;

import java.util.HashMap;

import java.util.List;

import javax.swing.JComponent;

import javax.swing.JPanel;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.plugins.Extension;

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

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

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

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

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

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

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

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.table.exceptions.NotInitializeException;

import org.gvsig.i18n.Messages;

import org.gvsig.raster.algorithm.RasterBaseAlgorithmLibrary;

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

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

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

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

import org.gvsig.raster.mainplugin.RasterMainPluginUtils;

import org.gvsig.raster.roi.ROI;

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

import org.gvsig.raster.roimask.app.toolbox.ToolboxROIMaskLoader;

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

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

import org.gvsig.raster.swing.RasterSwingLibrary;

import org.gvsig.raster.swing.RasterSwingLocator;

import org.gvsig.raster.swing.newlayer.CreateNewLayerPanel;

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

import org.gvsig.raster.util.RasterNotLoadException;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.extensionpoint.ExtensionPoint;

import org.gvsig.tools.extensionpoint.ExtensionPointManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class ROIMaskExtension extends Extension implements ActionListener, IProcessActions {

        private int                      windowWidth         = 600;

        private int                      windowHeight        = 370;

        private IWindow                  window              = null;

        private PreviewPanel             previewPanel        = null;

        private ROIMaskPreview           processPreview      = null;

        private ROIMaskPanel             panel               = null;

        private CreateNewLayerPanel      newLayerPanel       = null;

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

    public void initialize() {

            // Adds an entry to the TOC's floating menu to those layers defined in this extension

                //ExtensionPoint exPoint = ToolsLocator.getExtensionPointManager().add("My_TocActions");

                //exPoint.append("MyMenuEntry", "", new ROIMaskTocMenuEntry());

        // Adds a new tab to the "add layer" dialog

            //AddLayer.addWizard(ROIMaskWizard.class);

            // Adds a new button in the raster bar

                ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

                ExtensionPoint point = extensionPoints.add("GenericToolBarMenu");

                point.append("ROIMask", "", ROIMaskTocMenuEntry.getSingleton());

                ROIMaskTocMenuEntry.setExtension(this);

        Messages.addResourceFamily("org.gvsig.raster.roimask.app.i18n.text",

                        ROIMaskExtension.class.getClassLoader(),

                        ROIMaskExtension.class.getClass().getName()); 

            initilizeIcons();

            //new ToolboxROIMaskLoader().registerTool();

    }

        public void postInitialize() {

        }

    public void execute(String actionCommand) {

            if (actionCommand.compareTo("ROIMask") == 0) {

                    if(getSelectedLayer() == null) {

                            RasterSwingLibrary.messageBoxError("layer_not_selected", null);

                            return;

                    }

                    try {

                            initializeMainPanel();

                    } catch (ReadException e) {

                            logger.error("Error initializing the main panel", e);

                    } catch (ROIException e) {

                            logger.error("Error getting ROI", e);

                        }

            }

    }

    /**

     * Creates and initializes the main panel

     * @throws ReadException

     * @throws ROIException 

     */

    private void initializeMainPanel() throws ReadException, ROIException {

            try {

                    loadROIMaskPanel();

            } catch (NotInitializeException e) {

                    throw new ReadException("Error loading the table", e);

            }

            MainPanel mainPanel = new MainPanel(

                            getROIMaskPanel().getComponent(), 

                            (JComponent)getNewLayerPanel());

            window = new ROIMaskWindow(

                            mainPanel, 

                            (JPanel)getPreviewPanel(), 

                            Messages.getText("roimask"), 

                            windowWidth, 

                            windowHeight,

                            false,

                            this);

            PluginServices.getMDIManager().addWindow(window);

            getPreviewPanel().previewInitializeSizes();

            getPreviewPanel().refreshPreview();

    }

    /**

     * Loads the main panel with the data

     * @throws NotInitializeException 

     * @throws ROIException 

     */

    private void loadROIMaskPanel() throws NotInitializeException, ROIException {

            FLyrRaster lyr = getSelectedLayer();

            LayerElement element = new LayerElement(lyr);

            getROIMaskPanel().getDataModel().setInputLayer(element);

            ColorInterpretation ci = lyr.getDataStore().getColorInterpretation();

            if(ci.isRGB() || ci.isRGBA()) {

                    getROIMaskPanel().activeSlider(true);

            } else

                    getROIMaskPanel().activeSlider(false);

            if(lyr.getRois() == null || lyr.getRois().size() == 0)

                    getROIMaskPanel().showWarning(true);

            else

                    getROIMaskPanel().showWarning(false);

                getROIMaskPanel().getDataModel().clearROIs();

            List<ROI> roisArray = lyr.getRois();

                if (roisArray != null) {

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

                                ROI roi = (ROI) roisArray.get(i);

                                Object row[] = {"", "", ""};

                                boolean active = false;

                                row[0] = new Boolean(active);

                                row[1] = roi.getName(); 

                                row[2] = new Integer(i);

                                getROIMaskPanel().getDataModel().addROI(row);

                        }

                }

                if(lyr != null) {

                        switch(lyr.getDataStore().getDataType()[0]) {

                        case Buffer.TYPE_BYTE:

                                getROIMaskPanel().getDataModel().setValueNoData(RasterLibrary.defaultByteNoDataValue);

                                break;

                        case Buffer.TYPE_SHORT:

                                getROIMaskPanel().getDataModel().setValueNoData(RasterLibrary.defaultShortNoDataValue);

                                break;

                        case Buffer.TYPE_INT:

                                getROIMaskPanel().getDataModel().setValueNoData(RasterLibrary.defaultIntegerNoDataValue);

                                break;

                        case Buffer.TYPE_FLOAT:

                                getROIMaskPanel().getDataModel().setValueNoData(RasterLibrary.defaultFloatNoDataValue);

                                break;

                        case Buffer.TYPE_DOUBLE:

                                getROIMaskPanel().getDataModel().setValueNoData(RasterLibrary.defaultDoubleNoDataValue);

                                break;

                        }

                }

    }

    /**

     * Gets the list of layers from the gvSIG view

     * @return

     */

    private FLayers getLayers() {

        MapControl mapControl = null;

        IWindow[] windowList = PluginServices.getMDIManager().getAllWindows();

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

            if (windowList[i] instanceof AbstractViewPanel)

                mapControl = ((AbstractViewPanel) windowList[i]).getMapControl();

        }

        if (mapControl != null)

            return mapControl.getMapContext().getLayers();

        return null;

    }

    /**

     * Gets the selected layer

     * @return

     */

    private FLyrRaster getSelectedLayer() {

            FLayers lyrs = getLayers();

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

                        FLayer lyr = lyrs.getLayer(i);

                        if(lyr.isActive() && lyr instanceof FLyrRaster)

                                return (FLyrRaster)lyr;

                }

            return null;

    }

    public boolean isEnabled() {

        return false;

    }

    public boolean isVisible() {

        return false;

    }

    void initilizeIcons() {

                IconThemeHelper.registerIcon(null, "gvsig-icon", this);

                IconThemeHelper.registerIcon(null, "mask-icon", this);

                IconThemeHelper.registerIcon(null, "gvsig-icon16x16", this);

    }

    /**

     * Gets the {@link ROIMaskPanel}

     * @return {@link ROIMaskPanel}

     */

    private CreateNewLayerPanel getNewLayerPanel() {

            if(newLayerPanel == null)

                     newLayerPanel = RasterSwingLocator.getSwingManager().createNewLayerPanel(

                                     Messages.getText("create_output_layer"));

            return newLayerPanel;

    }

    /**

     * Gets the {@link PreviewPanel}

     * @return {@link PreviewPanel}

     */

    private PreviewPanel getPreviewPanel() {

            if(previewPanel == null)

                    previewPanel = RasterSwingLocator.getSwingManager().createSinglePreviewPanel(null, getDataSourcePreview());

            return previewPanel;

    }

    /**

     * Gets the {@link ROIMaskPreview}

     * @return {@link ROIMaskPreview}

     */

    private ROIMaskPreview getDataSourcePreview() {

            if(processPreview == null) {

                    processPreview = new ROIMaskPreview();

            }

            processPreview.setData(getROIMaskPanel().getDataModel());

            return processPreview;

    }

    /**

     * Gets the {@link ROIMaskPanel}

     * @return {@link ROIMaskPanel}

     */

    private ROIMaskPanel getROIMaskPanel() {

            if(panel == null) {

                    panel = ROIMaskSwingLocator.getSwingManager().createROIMaskPanel();

                    panel.addListener(this);

            }

            return panel;

    }

        public void actionPerformed(ActionEvent e) {

                if(window != null && 

                        (e.getSource() == ((ROIMaskWindow)window).getButtonsPanel().getButton(ButtonsPanel.BUTTON_ACCEPT) ||

                        e.getSource() == ((ROIMaskWindow)window).getButtonsPanel().getButton(ButtonsPanel.BUTTON_APPLY))) {

                        DataProcess task = null;

                        try {

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

                        } catch (ProcessException e1) {

                                RasterSwingLibrary.messageBoxError("error_processing_layer", null, e1);

                        }

                        task.setActions(this);

                        try {

                                getDataSourcePreview().addParams(task, 

                                                getNewLayerPanel().getDirectorySelected(), 

                                                getNewLayerPanel().getFileSelected());

                        } catch (ROIException e1) {

                                RasterSwingLibrary.messageBoxError("error_processing_layer", null, e1);

                        }

                        task.start();

                        return;

                }

                getPreviewPanel().refreshPreview();

        }

        @SuppressWarnings("unchecked")

        public void end(Object params) {

                if(params instanceof HashMap<?, ?>) {

                        HashMap<String, Object>  map = (HashMap<String, Object>) params;

                        String fName = (String)map.get(ROIMaskProcess.FILENAME);

                        long milis = (Long)map.get(ROIMaskProcess.TIME);

                        processFinalize(fName, milis);

                        RasterSwingLocator.getSwingManager().showSummaryProcessDialog(fName, milis);

                }

        }

        private void processFinalize(String fileName, long milis) {

                if (!new File(fileName).exists())

                        return;

                String viewName = getViewName();

                if(viewName != null) {

                        if (RasterSwingLibrary.messageBoxYesOrNot("cargar_toc", this)) {

                                try {

                                        RasterMainPluginUtils.loadLayer(viewName, fileName, null);

                                } catch (RasterNotLoadException e) {

                                        RasterSwingLibrary.messageBoxError("error_load_layer", null, e);

                                }

                        }

                }

        }

        private String getViewName() {

                FLyrRaster lyrRaster = getSelectedLayer();

                IWindow[] w = PluginServices.getMDIManager().getAllWindows();

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

                        if(w[i] instanceof AbstractViewPanel) {

                                FLayers lyrs = ((AbstractViewPanel)w[i]).getMapControl().getMapContext().getLayers();

                                for (int j = 0; j < lyrs.getLayersCount(); j++) {

                                        FLayer lyr = lyrs.getLayer(j);

                                        if(lyrRaster == lyr) {

                                                return PluginServices.getMDIManager().getWindowInfo((AbstractViewPanel) w[i]).getTitle();

                                        }

                                }

                        }

                }

                return null;

        }

        public void interrupted() {

        }

        public class LayerElement {

                private FLayer     lyr  = null;

                public LayerElement(FLayer lyr) {

                        this.lyr = lyr;

                }

                public FLayer getLayer() {

                        return lyr;

                }

                public String toString() {

                        return lyr.getName();

                }

                public int getNumOfElements() {

                        if(lyr instanceof FLyrRaster)

                                return ((FLyrRaster)lyr).getDataStore().getBandCount();

                        return 0;

                }

        }

        public void updateProgress(int current, int total) {

                // TODO Auto-generated method stub

        }

}