Application: gvSIG desktop » gvSIG tools: Vector editing

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 gvSIG Association

 *

 * 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.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

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

import java.awt.geom.AffineTransform;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

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

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

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

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

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

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

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

import org.gvsig.symbology.SymbologyLocator;

import org.gvsig.symbology.SymbologyManager;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.text.ISimpleTextSymbol;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypes;

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.api.exceptions.StopServiceException;

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

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;

/**

 * @author llmarques

 *

 */

public class PolarMatrixEditingProvider extends AbstractEditingProvider

    implements EditingProvider {

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

    private final FeatureStore featureStore;

    private Map<EditingServiceParameter, Object> values;

    private final EditingServiceParameter selection;

    private final EditingServiceParameter elementsNumber;

    private final EditingServiceParameter centerPoint;

    private final EditingServiceParameter elementAngle;

    private final EditingServiceParameter rotateElements;

    /**

     * Default constructor.

     *

     * @param services

     *            available services for this provider

     * @param parameters

     *            of this provider

     */

    public PolarMatrixEditingProvider(DynObject parameters,

        ProviderServices services) {

        super(services);

        this.featureStore =

            (FeatureStore) parameters

                .getDynValue(EditingProviderFactory.FEATURE_STORE_FIELD);

        this.selection =

            new DefaultEditingServiceParameter("selection", "selection",

                TYPE.SELECTION);

        this.elementsNumber =

            new DefaultEditingServiceParameter("number_of_total_elements",

                "number_of_total_elements", TYPE.VALUE);

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        EditingProviderServices editingProviderServices =

            (EditingProviderServices) getProviderServices();

        DefaultEditingServiceParameterOptions options = new DefaultEditingServiceParameterOptions()

                .add(i18nManager.getTranslation("_yes"), true, i18nManager.getTranslation("_yes"))

                .add(i18nManager.getTranslation("_no"), false, i18nManager.getTranslation("_no"));

        String consoleMsg

                = editingProviderServices.makeConsoleMessage(

                        "rotate_elements", options);

        this.rotateElements =

            new DefaultEditingServiceParameter(

                    "rotate_elements",

                    consoleMsg,

                    options,

                    false,

                    TYPE.OPTION).setDataType(DataTypes.BOOLEAN);

        this.centerPoint =

            new DefaultEditingServiceParameter("center", "center",

                TYPE.POSITION);

        this.elementAngle =

            new DefaultEditingServiceParameter("angle_between_elements",

                "angle_between_elements", EditingServiceParameter.TYPE.VALUE,

                TYPE.POSITION);

    }

    @Override

    public EditingServiceParameter next() {

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

            return selection;

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

            return elementsNumber;

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

            return rotateElements;

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

            return centerPoint;

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

            return elementAngle;

        }

        return null;

    }

    @Override

    public DrawingStatus getDrawingStatus(Point mousePosition)

        throws DrawServiceException {

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        DefaultDrawingStatus drawingStatus = new DefaultDrawingStatus();

        EditingProviderServices editingProviderServices =

            (EditingProviderServices) getProviderServices();

        FeatureSelection featureSelection =

            (FeatureSelection) values.get(selection);

        Integer elementsNumberValue = (Integer) values.get(elementsNumber);

        Boolean rotateElementsValue = (Boolean) values.get(rotateElements);

        Point centerPointValue = (Point) values.get(centerPoint);

        if (featureSelection != null && elementsNumberValue != null

            && rotateElementsValue != null && centerPointValue != null) {

            Double angle = (Double) values.get(elementAngle);

            if (angle == null) {

                angle = GeometryUtils.calculateAngle(centerPointValue, mousePosition);

                Integer elements = (Integer) values.get(elementsNumber);

                if(elements != null){

                    if(angle > 2*Math.PI/(elements-1)){

                        angle = 2*Math.PI/(elements-1);

                    }

                }

//                try {

//                    angle =

//                        editingProviderServices.getAngle(centerPointValue,

//                            mousePosition);

//                } catch (BaseException e) {

//                    throw new DrawServiceException(e);

//                }

            }

            // Creation of symbology

            EditingProviderManager editingProviderManager =

                EditingProviderLocator.getProviderManager();

            ISymbol auxiliaryPointSymbolEditing =

                editingProviderManager

                    .getSymbol("auxiliary-point-symbol-editing");

            ISymbol ruleAxisSymbol =

                editingProviderManager.getSymbol("rule-axis-symbol");

            ISymbol auxiliaryLineSymbolEditing =

                editingProviderManager

                    .getSymbol("auxiliary-line-symbol-editing");

            try {

                LOGGER.info("centerPoint: "+centerPointValue.toString());

                drawingStatus.addStatus(centerPointValue,

                    auxiliaryPointSymbolEditing, "");

                // Grade indicator creation

                int subtype = centerPointValue.getGeometryType().getSubType();

                double textDistance =

                    3 * centerPointValue.distance(mousePosition) / 4;

                Geometry pointText =

                    geometryManager.createPoint(

                        centerPointValue.getX() + textDistance

                            * Math.cos(angle / 2),

                        centerPointValue.getY() + textDistance

                            * Math.sin(angle / 2), subtype);

                LOGGER.info("pointText: "+pointText.toString());

                drawingStatus.addStatus(pointText, getTextSymbol(),

                    degToDms(Math.toDegrees(angle)));

                // Horizontal line of angle indicator creation

                Line horizontalLine = geometryManager.createLine(subtype);

                horizontalLine.setPoints(centerPointValue, geometryManager

                    .createPoint(

                        centerPointValue.getX()

                            + centerPointValue.distance(mousePosition),

                        centerPointValue.getY(), subtype));

                LOGGER.info("horizontalLine: "+horizontalLine.toString());

                drawingStatus.addStatus(horizontalLine, ruleAxisSymbol, "");

                // Vertical line of angle indicator creation

                Line verticalLine = geometryManager.createLine(subtype);

                verticalLine.setPoints(centerPointValue, mousePosition);

                LOGGER.info("verticalLine: "+verticalLine.toString());

                drawingStatus.addStatus(verticalLine, ruleAxisSymbol, "");

                // Arc angle indicator creation

//                Double ext = (2 * Math.PI) - angle;

//                Arc arc =

//                    editingProviderServices.createArc(centerPointValue,

//                        centerPointValue.distance(mousePosition) / 2, 0, ext,

//                        subtype);

                Arc arc = GeometryUtils.createArc(

                        centerPointValue, 

                        centerPointValue.distance(mousePosition) / 2, 

                        0, 

                        angle, 

                        subtype

                );

                LOGGER.info("arc: "+arc.toString());

                drawingStatus.addStatus(arc, auxiliaryLineSymbolEditing, "");

            } catch (BaseException e) {

                throw new DrawServiceException(e);

            }

            DisposableIterator it = null;

            try {

                it = featureSelection.fastIterator();

                while (it.hasNext()) {

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

                    ISymbol previewSymbol = this.getPreviewSymbol(feature);

                    Geometry geometry = feature.getDefaultGeometry();

                    Geometry[] matrix =

                        createPolarMatrix(geometry, elementsNumberValue,

                            rotateElementsValue, centerPointValue, angle);

                    for (Geometry element : matrix) {

                        LOGGER.info("element: "+element.toString());

                        ISymbol symbol = getSymbol(element);

                        if (element instanceof Aggregate) {

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

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

                                LOGGER.info("primitive: "+j);

                                drawingStatus.addStatus(((Aggregate) element).getPrimitiveAt(j), symbol, "");

                                drawingStatus.addStatus(((Aggregate) element).getPrimitiveAt(j), previewSymbol, "");

                            }

                        } else {

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

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

                        }

                    }

                }

            } catch (BaseException e) {

                throw new DrawServiceException(e);

            } finally {

                DisposeUtils.disposeQuietly(it);

            }

        }

        return drawingStatus;

    }

    private ISymbol getSymbol(Geometry geometry) {

        EditingProviderManager editingProviderManager =

            EditingProviderLocator.getProviderManager();

        ISymbol auxiliaryPointSymbolEditing =

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

        ISymbol lineSymbolEditing =

            editingProviderManager.getSymbol("line-symbol-editing");

        ISymbol polygonSymbolEditing =

            editingProviderManager.getSymbol("polygon-symbol-editing");

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

            return lineSymbolEditing;

        } else if (geometry instanceof Surface

            || geometry instanceof MultiSurface) {

            return polygonSymbolEditing;

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

            return auxiliaryPointSymbolEditing;

        }

        return null;

    }

    private ISimpleTextSymbol getTextSymbol() {

        SymbologyManager symbologyManager =

            SymbologyLocator.getSymbologyManager();

        ISimpleTextSymbol textSymbol =

            symbologyManager.createSimpleTextSymbol();

        textSymbol.setFontSize(10);

        return textSymbol;

    }

    private String degToDms(double deg) {

        int d = (int) Math.floor(deg);

        double minfloat = (deg - d) * 60;

        int m = (int) Math.floor(minfloat);

        double secfloat = (minfloat - m) * 60;

        int s = (int) Math.round(secfloat);

        // After rounding, the seconds might become 60. These two

        // if-tests are not necessary if no rounding is done.

        if (s == 60) {

            m++;

            s = 0;

        }

        if (m == 60) {

            d++;

            m = 0;

        }

        return ("" + d + "\u00B0" + m + "\u2032" + s + "\u2033");

    }

    private Geometry[] createPolarMatrix(Geometry geometry,

        Integer elementsNumberValue, Boolean rotateElementsValue,

        Point centerPointValue, Double angle)

        throws GeometryOperationNotSupportedException,

        GeometryOperationException, CreateGeometryException {

        Geometry[] geometryMatrix = new Geometry[elementsNumberValue-1];

        for (int i = 0; i < elementsNumberValue-1; i++) {

            AffineTransform at = new AffineTransform();

            if (rotateElementsValue) {

                at = getRotateAffineTransform(centerPointValue, angle * (i+1));

            } else {

                at = getRotateAffineTransform(centerPointValue, angle * (i+1));

                double centerX = geometry.getEnvelope().getCenter(0);

                double centerY = geometry.getEnvelope().getCenter(1);

                GeometryManager geometryManager =

                    GeometryLocator.getGeometryManager();

                Point geometryCenter =

                    geometryManager.createPoint(centerX, centerY, GEOM2D);

                Point geometryCenterCloned = (Point) geometryCenter.cloneGeometry();

                geometryCenterCloned.transform(at);

                at = getMoveAffineTransform(geometryCenter, geometryCenterCloned);

            }

            Geometry clonedGeometry = geometry.cloneGeometry();

            clonedGeometry.transform(at);

            geometryMatrix[i] = clonedGeometry;

        }

        return geometryMatrix;

    }

    @Override

    public void stop() throws StopServiceException {

        values.clear();

    }

    @Override

    public List<EditingServiceParameter> getParameters() {

        List<EditingServiceParameter> parameters =

            new ArrayList<>();

        parameters.add(selection);

        parameters.add(elementsNumber);

        parameters.add(rotateElements);

        parameters.add(centerPoint);

        parameters.add(elementAngle);

        return parameters;

    }

    @Override

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

        validateAndInsertValue(parameter, value);

    }

    @Override

    public void setValue(Object value) throws InvalidEntryException {

        EditingServiceParameter parameter = next();

        validateAndInsertValue(parameter, value);

    }

    private void validateAndInsertValue(EditingServiceParameter parameter,

        Object value) throws InvalidEntryException {

        boolean insertedValue = false;

        if (parameter.equals(selection) && value instanceof FeatureSelection) {

            FeatureSelection featureSelection = (FeatureSelection) value;

            if (featureSelection.getSelectedCount() > 0) {

                values.put(parameter, featureSelection);

                insertedValue = true;

            }

        } else if (parameter.equals(elementsNumber) && value instanceof Number) {

                int number = ((Number) value).intValue();

                Number angle = ((Number) values.get(elementAngle));

                if(angle != null){

                    double radians = Math.toRadians(angle.doubleValue());

                    if(radians > 2*Math.PI/(number-1)){

                        throw new InvalidEntryException(null);

                    }

                }

                values.put(parameter, number);

                insertedValue = true;

        } else if (parameter.equals(rotateElements)) {

            values.put(parameter, parameter.getOptions2().getValue(value, parameter.getDefaultValue()));

            insertedValue = true;

        } else if (parameter.equals(centerPoint) && value instanceof Point) {

            values.put(centerPoint, value);

            insertedValue = true;

        } else if (parameter.equals(elementAngle)) {

            if (value instanceof Double) {

                LOGGER.info("value Double:"+value.toString());

                Integer elements = (Integer) values.get(elementsNumber);

                double radians = Math.toRadians((Double) value);

                if(elements != null){

                    if(radians > 2*Math.PI/(elements-1)){

                        throw new InvalidEntryException(null);

                    }

                }

                values.put(elementAngle, radians);

                insertedValue = true;

            } else if (value instanceof Point) {

                LOGGER.info("value Point:"+value.toString());

                Point centerPointValue = (Point) values.get(centerPoint);

                Point valuePoint = (Point) value;

                    double angle = GeometryUtils.calculateAngle(centerPointValue, valuePoint);

                    Integer elements = (Integer) values.get(elementsNumber);

                    if(elements != null){

                        if(angle > 2*Math.PI/(elements-1)){

                            throw new InvalidEntryException(null);

                        }

                    }

                    values.put(elementAngle, angle);

                    insertedValue = true;

//                try {

//                    double angle = 

//                        editingProviderServices.getAngle(centerPointValue,

//                            valuePoint);

//                } catch (BaseException e) {

//                    throw new InvalidEntryException(e);

//                }

            }

        }

        if (!insertedValue) {

            throw new InvalidEntryException(null);

        }

    }

    @Override

    public Geometry finish() throws FinishServiceException {

        return null;

    }

    @Override

    public void finishAndStore() throws FinishServiceException {

        final EditingProviderServices editingProviderServices =

            (EditingProviderServices) getProviderServices();

        FeatureSelection featureSelection =

            (FeatureSelection) values.get(selection);

        final Integer elementsNumberValue =

            (Integer) values.get(elementsNumber);

        final Boolean rotateElementsValue =

            (Boolean) values.get(rotateElements);

        final Point centerPointValue = (Point) values.get(centerPoint);

        final Double elementAngleValue = (Double) values.get(elementAngle);

        if (featureSelection != null && elementsNumberValue != null

            && rotateElementsValue != null && centerPointValue != null

            && elementAngleValue != null) {

            try {

                featureSelection.accept((Object obj) -> {

                    Feature feature = (Feature) obj;

                    Geometry geometry = feature.getDefaultGeometry();

                    LOGGER.info("elementAngleValue:"+elementAngleValue);

                    Geometry[] matrix =

                            createPolarMatrix(geometry, elementsNumberValue,

                                    rotateElementsValue, centerPointValue,

                                    elementAngleValue);

                    for (Geometry matrix1 : matrix) {

                        EditableFeature eFeature =

                                editingProviderServices

                                        .getFeatureCopyWithoutUniqueIndex(featureStore,

                                                feature);

                        eFeature.setDefaultGeometry(matrix1);

                        editingProviderServices

                                .insertFeatureIntoFeatureStore(eFeature,

                                        featureStore);

                    }

                });

            } catch (BaseException e) {

                throw new FinishServiceException(e);

            }

        }

    }

    @Override

    public void start() throws StartServiceException, InvalidEntryException {

        values = new HashMap<>();

        FeatureSelection selected = null;

        if (featureStore != null && values.get(selection) == null) {

            try {

                selected = featureStore.getFeatureSelection();

            } catch (DataException e) {

                throw new StartServiceException(e);

            }

            if (selected.getSelectedCount() > 0) {

                try {

                    setValue(selected);

                } catch (InvalidEntryException e) {

                    throw new InvalidEntryException(e);

                }

            }

        }

    }

    @Override

    public String getName() {

        return PolarMatrixEditingProviderFactory.PROVIDER_NAME;

    }

    private AffineTransform getMoveAffineTransform(Point p1, Point p2)

        throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        AffineTransform translate =

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

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

        return translate;

    }

    private AffineTransform getRotateAffineTransform(Point axisP1, Double angle)

        throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        AffineTransform translate =

            AffineTransform

                .getTranslateInstance(-axisP1.getX(), -axisP1.getY());

        AffineTransform rotate = AffineTransform.getRotateInstance(angle);

        AffineTransform inverseTranslate =

            AffineTransform.getTranslateInstance(axisP1.getX(), axisP1.getY());

        AffineTransform at = new AffineTransform(translate);

        at.preConcatenate(rotate);

        at.preConcatenate(inverseTranslate);

        return at;

    }

    @Override

    public Object getValue(EditingServiceParameter parameter) {

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

    }

}