Application: gvSIG desktop » gvSIG tools: Vector editing

package org.gvsig.vectorediting.lib.prov.stretch;

import java.awt.geom.AffineTransform;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.apache.commons.collections4.CollectionUtils;

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.aggregate.Aggregate;

import org.gvsig.fmap.geom.aggregate.MultiCurve;

import org.gvsig.fmap.geom.aggregate.MultiPoint;

import org.gvsig.fmap.geom.aggregate.MultiPrimitive;

import org.gvsig.fmap.geom.aggregate.MultiSurface;

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

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

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

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

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

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

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

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.service.spi.ProviderServices;

import org.gvsig.vectorediting.lib.api.DrawingStatus;

import org.gvsig.vectorediting.lib.api.EditingServiceParameter;

import org.gvsig.vectorediting.lib.api.EditingServiceParameter.TYPE;

import org.gvsig.vectorediting.lib.api.exceptions.DrawServiceException;

import org.gvsig.vectorediting.lib.api.exceptions.FinishServiceException;

import org.gvsig.vectorediting.lib.api.exceptions.InvalidEntryException;

import org.gvsig.vectorediting.lib.api.exceptions.StartServiceException;

import org.gvsig.vectorediting.lib.prov.stretch.operation.StretchOperation;

import org.gvsig.vectorediting.lib.prov.stretch.operation.StretchOperationUtils;

import org.gvsig.vectorediting.lib.spi.AbstractEditingProvider;

import org.gvsig.vectorediting.lib.spi.DefaultDrawingStatus;

import org.gvsig.vectorediting.lib.spi.DefaultEditingServiceParameter;

import org.gvsig.vectorediting.lib.spi.EditingProvider;

import org.gvsig.vectorediting.lib.spi.EditingProviderFactory;

import org.gvsig.vectorediting.lib.spi.EditingProviderLocator;

import org.gvsig.vectorediting.lib.spi.EditingProviderManager;

import org.gvsig.vectorediting.lib.spi.EditingProviderServices;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class StretchEditingProvider extends AbstractEditingProvider implements

    EditingProvider {

    private static final Logger LOGGER = LoggerFactory.getLogger(StretchEditingProvider.class);

    private final EditingServiceParameter selectionParameter;

    private final EditingServiceParameter geometryParameter;

    private final EditingServiceParameter firstPointParameter;

    private final EditingServiceParameter secondPointParameter;

    private Map<EditingServiceParameter, Object> values;

    private final FeatureStore featureStore;

    private List<Feature> selectedFeatures;

    public StretchEditingProvider(ProviderServices providerServices,

        DynObject parameters) {

        super(providerServices);

        this.featureStore =

            (FeatureStore) parameters

                .getDynValue(EditingProviderFactory.FEATURE_STORE_FIELD);

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        this.selectionParameter =

            new DefaultEditingServiceParameter("selection",

                i18nManager.getTranslation("selection"), TYPE.SELECTION);

        this.geometryParameter =

            new DefaultEditingServiceParameter("Draw geometry",

                "draw_geometry_to_select_vertex", Geometry.TYPES.MULTISURFACE, TYPE.GEOMETRY);

        this.firstPointParameter =

            new DefaultEditingServiceParameter("first_point",

                i18nManager.getTranslation("first_point"), TYPE.VALUE, TYPE.POSITION);

        this.secondPointParameter =

            new DefaultEditingServiceParameter("second_point",

                i18nManager.getTranslation("second_point"), TYPE.VALUE, TYPE.POSITION);

    }

    @Override

    public List<EditingServiceParameter> getParameters() {

        List<EditingServiceParameter> list =

            new ArrayList<>();

        list.add(selectionParameter);

        list.add(geometryParameter);

        list.add(firstPointParameter);

        list.add(secondPointParameter);

        return list;

    }

    private void validateAndInsertValue(EditingServiceParameter param,

        Object value) throws InvalidEntryException {

        if (param == selectionParameter) {

            if (value instanceof FeatureSelection) {

                values.put(param, value);

                this.selectedFeatures = this.getSelectedFeaturesCopy((FeatureSelection)value);

            }

        } else if (param == firstPointParameter) {

            if (value instanceof Point) {

                values.put(param, value);

            }

        } else if (param == secondPointParameter) {

            if (value instanceof Point) {

                values.put(param, value);

            }

        } else if (param == geometryParameter) {

            if (value instanceof Geometry) {

                // Before set value checks if some geometry intersects the

                // geometry received as parameter.

                Geometry geometry = (Geometry) value;

                FeatureSelection selection =

                    (FeatureSelection) values.get(selectionParameter);

                DisposableIterator it = null;

                try {

                    it = selection.fastIterator();

                    while (it.hasNext()) {

                        Feature feature = (Feature) it.next();

                        Geometry defaultGeometry = feature.getDefaultGeometry();

                        if (defaultGeometry.intersects(geometry) || defaultGeometry.contains(geometry)) {

                            values.put(param, value);

                            return;

                        }

                    }

                    throw new InvalidEntryException(null);

                } catch (BaseException e) {

                    throw new InvalidEntryException(e);

                } finally {

                    DisposeUtils.disposeQuietly(it);

                }

            }

        }

    }

    @Override

    public EditingServiceParameter next() {

        if (values.get(selectionParameter) == null) {

            return this.selectionParameter;

        } else if (values.get(geometryParameter) == null) {

            return this.geometryParameter;

        } else if (values.get(firstPointParameter) == null) {

            return this.firstPointParameter;

        } else if (values.get(secondPointParameter) == null) {

            return this.secondPointParameter;

        }

        return null;

    }

    public static Geometry applyTransform(Geometry geometry, AffineTransform at,

        Geometry roi) throws CreateGeometryException,

        GeometryOperationNotSupportedException, GeometryOperationException {

        if (geometry instanceof MultiPrimitive) {

            GeometryManager geometryManager = GeometryLocator.getGeometryManager();

            MultiPrimitive aggregate = (MultiPrimitive)geometry;

            GeometryType geometryType = aggregate.getGeometryType();

            MultiPrimitive newAggregate = (MultiPrimitive) geometryManager.create(geometryType.getType(), geometryType.getSubType());

            for (int i = 0; i < aggregate.getPrimitivesNumber(); i++) {

                Primitive primitive = aggregate.getPrimitiveAt(i);

                StretchOperation operation = StretchOperationUtils.getOperation(primitive);

                if (operation != null) {

                    Geometry element = operation.transform(at, primitive, roi);

                    if (element instanceof MultiPrimitive) {

                        for (int j = 0; j < ((MultiPrimitive)element).getPrimitivesNumber(); j++) {

                            newAggregate.addPrimitive(((MultiPrimitive)element).getPrimitiveAt(j));

                        }

                    } else if(element instanceof Primitive){

                        newAggregate.addPrimitive((Primitive)element);

                    } else {

                        LOGGER.warn("StretchOperation has returned a not-supported geometry type. "+operation.toString()+" "+element.getClass().getName());

                    }

                } else {

                    newAggregate.addPrimitive(primitive);

                }

            }

            return newAggregate;

        } else if (geometry instanceof Primitive) {

            StretchOperation operation = StretchOperationUtils.getOperation((Primitive)geometry);

            if (operation != null) {

                return operation.transform(at, (Primitive)geometry, roi);

            }

        }

        return geometry;

    }

    public static List<Point> getSelectedVertex(Geometry geometry,

        Geometry roi) throws CreateGeometryException,

        GeometryOperationNotSupportedException, GeometryOperationException {

        List<Point> selectedVertex = new ArrayList<>();

        if (geometry instanceof MultiPrimitive) {

            MultiPrimitive aggregate = (MultiPrimitive)geometry;

            for (int i = 0; i < aggregate.getPrimitivesNumber(); i++) {

                Primitive primitive = aggregate.getPrimitiveAt(i);

                StretchOperation operation = StretchOperationUtils.getOperation(primitive);

                if (operation != null) {

                    selectedVertex.addAll(operation.getSelectedVertex(primitive, roi));

                }

            }

        } else if (geometry instanceof Primitive) {

            Primitive primitive = (Primitive)geometry;

            StretchOperation operation = StretchOperationUtils.getOperation(primitive);

            if (operation != null) {

                selectedVertex.addAll(operation.getSelectedVertex(primitive, roi));

            }

        }

        return selectedVertex;

    }

    @Override

    public DrawingStatus getDrawingStatus(Point mousePosition)

        throws DrawServiceException {

        DefaultDrawingStatus drawingStatus = new DefaultDrawingStatus();

        EditingProviderManager editingProviderManager =

            EditingProviderLocator.getProviderManager();

        ISymbol selectedVertexEditingSymbol = editingProviderManager.getSymbol("selected-vertex-symbol-editing");

        ISymbol lineSymbolEditing = editingProviderManager.getSymbol("line-symbol-editing");

        ISymbol polygonSymbolEditing = editingProviderManager.getSymbol("polygon-symbol-editing");

        ISymbol auxiliaryPointSymbolEditing = editingProviderManager.getSymbol("auxiliary-point-symbol-editing");

        FeatureSelection selection =

            (FeatureSelection) values.get(this.selectionParameter);

        try {

            if ( CollectionUtils.isNotEmpty(selectedFeatures) ) {

                Geometry geometry = (Geometry) values.get(this.geometryParameter);

                if (geometry != null) {

                    //

                    List<Point> selectedVertex = new ArrayList<>();

                    try {

                        for (Feature feature : selectedFeatures) {

                            Geometry featureGeometry = feature.getDefaultGeometry();

                            List<Point> vertex = getSelectedVertex(featureGeometry, geometry);

                            if(vertex != null){

                                selectedVertex.addAll(vertex);

                            }

                        }

                    } catch (BaseException e) {

                        throw new InvalidEntryException(e);

                    }

                    if(!selectedVertex.isEmpty()){

                        for (Point point : selectedVertex) {

                            drawingStatus.addStatus(point, selectedVertexEditingSymbol, "");

                        }

                    }

                    Point firstPoint = (Point) values.get(this.firstPointParameter);

                    if (firstPoint != null){

                        AffineTransform at = getMoveAffineTransform(firstPoint, mousePosition);

                        if(!selectedVertex.isEmpty()){

                            for (Iterator<Point> iterator = selectedVertex.iterator(); iterator.hasNext();) {

                                Point point = (Point) ((Point) iterator.next()).cloneGeometry();

                                point.transform(at);

                                drawingStatus.addStatus(point, selectedVertexEditingSymbol, "");

                            }

                        }

                        try {

                            for (Feature feature : selectedFeatures) {

                                ISymbol previewSymbol = this.getPreviewSymbol(feature);

                                Geometry featureGeometry = feature.getDefaultGeometry();

                                Geometry transformedGeometry = applyTransform(featureGeometry, at, geometry);

                                ISymbol symbol=null;

                                if(transformedGeometry instanceof Curve || transformedGeometry instanceof MultiCurve){

                                    symbol = lineSymbolEditing;

                                } else if(transformedGeometry instanceof Surface || transformedGeometry instanceof MultiSurface){

                                    symbol = polygonSymbolEditing;

                                } else if(transformedGeometry instanceof Point || transformedGeometry instanceof MultiPoint){

                                    symbol = auxiliaryPointSymbolEditing;

                                }

                                if(transformedGeometry instanceof Aggregate){

                                    int primitivesNumber = ((Aggregate)transformedGeometry).getPrimitivesNumber();

                                    for (int i = 0; i < primitivesNumber; i++) {

                                        drawingStatus.addStatus(((Aggregate)transformedGeometry).getPrimitiveAt(i), symbol, "");

                                        drawingStatus.addStatus(((Aggregate)transformedGeometry).getPrimitiveAt(i), previewSymbol, "");

                                    }

                                } else {

                                    drawingStatus.addStatus(transformedGeometry, symbol, "");

                                    drawingStatus.addStatus(transformedGeometry, previewSymbol, "");

                                }

                            }

                        } catch (BaseException e) {

                            throw new InvalidEntryException(e);

                        }

                    }

                }

                return drawingStatus;

            }

        } catch (Exception e) {

            throw new DrawServiceException(e);

        }

        return null;

    }

    private AffineTransform getMoveAffineTransform(Point p1, Point p2) {

        AffineTransform translate =

            AffineTransform.getTranslateInstance(p2.getX() - p1.getX(),

                p2.getY() - p1.getY());

        return translate;

    }

    @Override

    public void stop() {

        values.clear();

        this.selectedFeatures = Collections.EMPTY_LIST;

    }

    @Override

    public void setValue(EditingServiceParameter parameter, Object value) throws InvalidEntryException {

        validateAndInsertValue(parameter, value);

    }

    @Override

    public void setValue(Object value) throws InvalidEntryException {

        EditingServiceParameter param = next();

        validateAndInsertValue(param, value);

    }

    @Override

    public void finishAndStore() throws FinishServiceException {

        FeatureSelection selection

                = (FeatureSelection) values.get(selectionParameter);

        try {

            if ( CollectionUtils.isNotEmpty(selectedFeatures) ) {

                Geometry geometry = (Geometry) values.get(this.geometryParameter);

                if (geometry != null) {

                    Point firstPoint

                            = (Point) values.get(this.firstPointParameter);

                    if (firstPoint != null) {

                        Point secondPoint

                                = (Point) values.get(this.secondPointParameter);

                        if (secondPoint != null) {

                            AffineTransform at

                                    = getMoveAffineTransform(firstPoint, secondPoint);

                            try {

                                for (Feature feature : selectedFeatures) {

                                    Geometry featureGeometry

                                            = feature.getDefaultGeometry();

                                    Geometry geom

                                            = applyTransform(featureGeometry, at,

                                                    geometry);

                                    EditableFeature editableFeature

                                            = feature.getEditable();

                                    editableFeature.setDefaultGeometry(geom);

                                    ((EditingProviderServices) getProviderServices())

                                            .updateFeatureInFeatureStore(

                                                    editableFeature, featureStore);

                                }

                            } catch (BaseException e) {

                                throw new FinishServiceException(e);

                            }

                        }

                    }

                }

            }

        } catch (Exception e) {

            throw new FinishServiceException(e);

        }

    }

    @Override

    public Geometry finish() throws FinishServiceException {

        return null;

    }

    @Override

    public void start() throws StartServiceException {

        this.values = new HashMap<>();

        this.selectedFeatures = Collections.EMPTY_LIST;

        if (featureStore != null) {

            FeatureSelection selected = null;

            try {

                selected = (FeatureSelection) featureStore.getFeatureSelection().clone();

            } catch (DataException e) {

                throw new StartServiceException(e);

            } catch (CloneNotSupportedException ex) {

                LOGGER.debug("Can't init selection",ex);

            }

            if ((selected != null) && (selected.getSelectedCount() > 0)) {

                values.put(selectionParameter, selected);

                this.selectedFeatures = this.getSelectedFeaturesCopy(selected);

            }

        }

    }

    @Override

    public String getName() {

        return StretchEditingProviderFactory.PROVIDER_NAME;

    }

    @Override

    public Object getValue(EditingServiceParameter parameter) {

        return values!=null?values.get(parameter):null;

    }

}