Application: gvSIG desktop » gvSIG tools: Derived geometries

/*

 * Copyright 2014 DiSiD Technologies S.L.L. All rights reserved.

 * 

 * Project  : DiSiD org.gvsig.derivedgeometries.swing.impl 

 * SVN Id   : $Id$

 */

package org.gvsig.derivedgeometries.swing.impl.processes;

import java.util.List;

import javax.swing.JOptionPane;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.derivedgeometries.swing.api.DerivedGeometriesParameters;

import org.gvsig.derivedgeometries.swing.impl.AbstractDerivedGeometriesProcess;

import org.gvsig.fmap.dal.feature.FeatureReference;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.threadsafedialogs.ThreadSafeDialogsManager;

import org.gvsig.tools.task.SimpleTaskStatus;

public class PointToPolygonDerivedGeometriesProcess extends

    AbstractDerivedGeometriesProcess {

    private static final Logger logger = LoggerFactory

        .getLogger(PointToPolygonDerivedGeometriesProcess.class);

    public PointToPolygonDerivedGeometriesProcess(

        DerivedGeometriesParameters parameters) {

        super("Point to polygon process", parameters);

    }

    public void run() {

        SimpleTaskStatus status = null;

        try {

            status = (SimpleTaskStatus) this.getTaskStatus();

            if (status.isCancellationRequested()) {

                status.cancel();

                return;

            }

            // Get data process

            DerivedGeometriesParameters parameters = super.getParameters();

            String outputLayerName = parameters.getOutPutLayerName();

            String outputLayerPath = parameters.getOutPutLayerPath();

            int outputLayerType = parameters.getOutPutLayerType();

            boolean addLayer = parameters.getAddLayer();

            boolean createNewFeatureStore =

                parameters.getCreateNewFeatureStore();

            FLyrVect sourceLayer = parameters.getSourceLayer();

            IProjection projection = sourceLayer.getProjection();

            FeatureType sourceFeatureType =

                sourceLayer.getFeatureStore().getDefaultFeatureType();

            List<FeatureReference> selectedFeatures =

                parameters.getSelectedFeatures();

            GeometryManager geomManager = GeometryLocator.getGeometryManager();

            GeometryType sourceGeomType =

                sourceLayer.getFeatureStore().getDefaultFeatureType()

                    .getDefaultGeometryAttribute().getGeomType();

            Polygon polygon =

                geomManager.createPolygon(sourceGeomType.getSubType());

            Point vertexAnt = null;

            status.setRangeOfValues(1, selectedFeatures.size());

            // Iterate over features getting geometries to create polygon

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

                // Si ha sido solicitada la cancelacion de la tarea

                // la marcamos como cancelada y salimos del proceso.

                if (status.isCancellationRequested()) {

                    status.cancel();

                    return;

                }

                // Informamos del progreso de la tarea

                status.setCurValue(i);

                FeatureReference featureReference = selectedFeatures.get(i);

                Geometry point =

                    featureReference.getFeature().getDefaultGeometry();

                if (vertexAnt == null || !vertexAnt.equals(point)) {

                    polygon.addVertex((Point) point);

                    vertexAnt = (Point) point;

                }

            }

            // Close polygon if it is necessary

            closeSurfaceIfNecessary(polygon);

            if (status.isCancellationRequested()) {

                status.cancel();

                return;

            }

            if (createNewFeatureStore) {

                // Creating new feature store

                createNewFeatureStore(sourceFeatureType, outputLayerType,

                    outputLayerPath, projection);

                // Set createNewFeatureStore false to avoid create new feature

                // if process is started again

                parameters.setCreateNewFeatureStore(false);

            }

            // Open the new feature store

            FeatureStore featureStore = parameters.getFeatureStore();

            if (featureStore == null) {

                featureStore = getFeatureStore(outputLayerPath, projection);

            }

            // Set feature store in edit mode

            setEditingMode(featureStore);

            // Add line

            insertGeometryIntoFeauteStore(featureStore, polygon);

            // Save changes and finish editing

            endEditingMode(featureStore);

            if (status.isCancellationRequested()) {

                status.cancel();

                return;

            }

            if (addLayer) {

                //Dispose feature store to liberate resources

                featureStore.dispose();

                // Add layer to MapControl

                featureStore =

                    addLayerToMapContex(outputLayerName, outputLayerPath,

                        projection);

                parameters.setAddLayer(false);

                parameters.setFeatureStore(featureStore);

            }

            this.postProcess();

        } catch (Exception e) {

            ThreadSafeDialogsManager dlgManager =

                ToolsSwingLocator.getThreadSafeDialogsManager();

            dlgManager.messageDialog("_process_error", "_error",

                JOptionPane.ERROR_MESSAGE);

            logger.info("Error in point to polygon process", e);

            if (status != null) {

                status.abort();

            }

        } finally {

            if (status != null) {

                // Mark process as terminate if it is running.

                if (status.isRunning()) {

                    status.terminate();

                }

            }

        }

    }

    private void postProcess() {

        ThreadSafeDialogsManager dlgManager =

            ToolsSwingLocator.getThreadSafeDialogsManager();

        String message = "_process_finished_successfully";

        String title = "_information";

        dlgManager.messageDialog(message, title,

            JOptionPane.INFORMATION_MESSAGE);

        // Repaint mapContext to view new derived geometries added.

        getParameters().getMapControl().getMapContext().invalidate();

    }

}