Application: gvSIG desktop » gvSIG tools: Vector editing

org.gvsig.vectorediting.lib.prov.explode.ExplodeEditingLibrary

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2014 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.explode;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.dynobject.DynObject;

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

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

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

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

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

/**

 * @author llmarques

 *

 */

public class ExplodeEditingProviderFactory extends AbstractEditingProviderFactory {

    public static final String PROVIDER_NAME = "modify-explode-geometry";

    private final static String PROVIDER_DESCRIPTION =

        "Explodes aggregate geometry in single geometries";

    public ExplodeEditingProviderFactory() {

        super(PROVIDER_NAME, PROVIDER_DESCRIPTION);

    }

    @Override

    public EditingServiceInfo getServiceInfo() {

        EditingServiceInfo serviceInfo =

            new DefaultEditingServiceinfo(PROVIDER_NAME, "", false, null,

                new int[] { Geometry.TYPES.MULTIPOINT,

                    Geometry.TYPES.MULTILINE, Geometry.TYPES.MULTIPOLYGON, 

                    Geometry.TYPES.MULTICURVE, Geometry.TYPES.MULTISURFACE

                });

        return serviceInfo;

    }

    @Override

    protected Provider doCreate(DynObject parameters, ProviderServices services) {

        return new ExplodeEditingProvider(services, parameters);

    }

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2014 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.explode;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

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

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

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

/**

 * 

 * @author llmarques

 *

 */

public class ExplodeEditingLibrary extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsServiceOf(EditingLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        EditingProviderManager manager =

            EditingProviderLocator.getProviderManager();

        manager.addProviderFactory(new ExplodeEditingProviderFactory());

        manager.registerIcon("vectorediting-tools", "modify-explode-geometry",

            this.getClass().getClassLoader(), this.getClass().getName());

        registerTranslations();

    }

    private void registerTranslations() {

        I18nManager manager = ToolsLocator.getI18nManager();

        manager.addResourceFamily("i18n/text",

            this.getClass().getClassLoader(), "modidy-explode-geometry");

    }

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2014 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.explode;

import java.util.ArrayList;

import java.util.List;

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.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.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.tools.dynobject.DynObject;

import org.gvsig.tools.exception.BaseException;

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

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

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

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

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

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

/**

 * @author llmarques

 *

 */

public class ExplodeEditingProvider extends AbstractEditingProvider implements

    EditingProvider {

    private final EditingServiceParameter selectionParameter;

    private final FeatureStore featureStore;

    private FeatureSelection value;

    /**

     * Default constructor.

     *

     * @param providerServices

     *            available services for this provider

     * @param parameters

     */

    public ExplodeEditingProvider(ProviderServices providerServices,

        DynObject parameters) {

        super(providerServices);

        this.featureStore =

            (FeatureStore) parameters

                .getDynValue(EditingProviderFactory.FEATURE_STORE_FIELD);

        this.selectionParameter =

            new DefaultEditingServiceParameter("selection", "selection",

                TYPE.SELECTION);

    }

    @Override

    public EditingServiceParameter next() {

        if (value == null) {

            return selectionParameter;

        }

        return null;

    }

    @Override

    public boolean mustRestartAtFinish() {

        return false;

    }

    @Override

    public DrawingStatus getDrawingStatus(Point mousePosition)

        throws DrawServiceException {

        return null;

    }

    @Override

    public void stop() throws StopServiceException {

        value = null;

    }

    @Override

    public List<EditingServiceParameter> getParameters() {

        List<EditingServiceParameter> parameters =

            new ArrayList<>();

        parameters.add(selectionParameter);

        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 object) throws InvalidEntryException {

        if (parameter == selectionParameter) {

            if (object instanceof FeatureSelection) {

                final FeatureSelection selection = (FeatureSelection) object;

                try {

                    selection.accept((Object obj) -> {

                        Feature feature = (Feature) obj;

                        Geometry defaultGeometry =

                                feature.getDefaultGeometry();

                        if (defaultGeometry instanceof MultiPrimitive) {

                            MultiPrimitive multiPrimitive =

                                    (MultiPrimitive) defaultGeometry;

                            if (multiPrimitive.getPrimitivesNumber() > 1) {

                                value = selection;

                                return;

                            }

                        }

                        throw new InvalidEntryException(null);

                    });

                } catch (BaseException e) {

                    throw new InvalidEntryException(e);

                }

            }

        }

    }

    @Override

    public Geometry finish() throws FinishServiceException {

        return null;

    }

    @Override

    public void finishAndStore() throws FinishServiceException {

        if (value != null) {

            try {

                final EditingProviderServices editingProviderServices =

                    (EditingProviderServices) getProviderServices();

                value.accept((Object obj) -> {

                    Feature feature = (Feature) obj;

                    MultiPrimitive defaultGeometry =

                            (MultiPrimitive) feature.getDefaultGeometry();

                    GeometryType geomType = defaultGeometry.getGeometryType();

                    for (int i = 0; i < defaultGeometry

                            .getPrimitivesNumber(); i++) {

                        Primitive primitive =

                                defaultGeometry.getPrimitiveAt(i);

                        GeometryManager geometryManager =

                                GeometryLocator.getGeometryManager();

                        int subtype =

                                editingProviderServices

                                        .getSubType(featureStore);

                        Geometry geometry = null;

                        if (geomType.isTypeOf(MULTIPOINT)) {

                            MultiPoint multiPoint =

                                    geometryManager.createMultiPoint(subtype);

                            multiPoint.addPoint((Point) primitive);

                            geometry = multiPoint;

                        } else if (geomType.isTypeOf(MULTICURVE)) {

                            MultiCurve multiCurve =

                                    geometryManager.createMultiCurve(subtype);

                            multiCurve.addCurve((Curve) primitive);

                            geometry = multiCurve;

                        } else if (geomType.isTypeOf(MULTISURFACE)) {

                            MultiSurface multiSurface =

                                    geometryManager.createMultiSurface(subtype);

                            multiSurface.addSurface((Surface) primitive);

                            geometry = multiSurface;

                        }

                        if (geometry != null) {

                            EditableFeature newFeature =

                                    editingProviderServices

                                            .getFeatureCopyWithoutUniqueIndex(featureStore,

                                                    feature);

                            newFeature.setDefaultGeometry(geometry);

                            editingProviderServices

                                    .insertFeatureIntoFeatureStore(newFeature,

                                            featureStore);

                        }

                    }

                    editingProviderServices

                            .deleteFeatureFromFeatureStore(feature,

                                    featureStore);

                });

                featureStore.getFeatureSelection().deselectAll();

                value.dispose();

            } catch (BaseException e) {

                throw new FinishServiceException(e);

            }

        }

    }

    @Override

    public void start() throws StartServiceException, InvalidEntryException {

        this.value = null;

        FeatureSelection selected = null;

        if (featureStore != null) {

            try {

                selected = featureStore.getFeatureSelection();

            } catch (DataException e) {

                throw new StartServiceException(e);

            }

            try {

                setValue(selected);

            } catch (InvalidEntryException e) {

                throw new InvalidEntryException(e);

            }

        }

    }

    @Override

    public String getName() {

        return ExplodeEditingProviderFactory.PROVIDER_NAME;

    }

    @Override

    public Object getValue(EditingServiceParameter parameter) {

        if(parameter == this.selectionParameter){

            return value;

        }

        return null;

    }

}

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <parent>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.vectorediting.lib.prov</artifactId>

    <version>1.0.265</version>

  </parent>

  <artifactId>org.gvsig.vectorediting.lib.prov.explode</artifactId>

  <name>org.gvsig.vectorediting.lib.prov.explode</name>

</project>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <parent>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.vectorediting.lib.prov</artifactId>

    <version>1.0.265</version>

  </parent>

  <artifactId>org.gvsig.vectorediting.lib.prov.polarmatrix</artifactId>

  <name>org.gvsig.vectorediting.lib.prov.polarmatrix</name>

</project>

/**

 * 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 org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.Library;

import org.gvsig.tools.library.LibraryException;

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

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

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

/**

 * @author llmarques

 *

 */

public class PolarMatrixEditingLibrary extends AbstractLibrary implements

    Library {

    @Override

    public void doRegistration() {

        registerAsServiceOf(EditingLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        EditingProviderManager manager =

            EditingProviderLocator.getProviderManager();

        manager.addProviderFactory(new PolarMatrixEditingProviderFactory());

        manager.registerIcon("vectorediting-tools", "insert-polar-matrix", this

            .getClass().getClassLoader(), this.getClass().getName());

        registerTranslations();

    }

    private void registerTranslations() {

        I18nManager manager = ToolsLocator.getI18nManager();

        manager.addResourceFamily("i18n/text",

            this.getClass().getClassLoader(), "insert-polar-matrix-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.Collections;

import java.util.HashMap;

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

    private List<Feature> selectedFeatures;

    /**

     * 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();

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

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

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

        if (CollectionUtils.isNotEmpty(selectedFeatures) && 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);

            }

            try {

                for (Feature feature : selectedFeatures) {

                    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);

            }

        }

        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();

        this.selectedFeatures = Collections.EMPTY_LIST;

    }

    @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);

                this.selectedFeatures = this.getSelectedFeaturesCopy(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 ( CollectionUtils.isNotEmpty(selectedFeatures) && elementsNumberValue != null

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

            && elementAngleValue != null) {

            try {

                for (Feature feature : selectedFeatures) {

                    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<>();

        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(selection, selected);

                this.selectedFeatures = this.getSelectedFeaturesCopy(selected);

            }

        }

    }

    @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;

    }

}

/**

 * 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 org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.dynobject.DynObject;

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

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

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

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

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

/**

 * @author llmarques

 *

 */

public class PolarMatrixEditingProviderFactory extends AbstractEditingProviderFactory {

    public final static String PROVIDER_NAME = "insert-polar-matrix";

    public final static String PROVIDER_DESCRIPTION =

        "Creates a polar matrix of geometries";

    public PolarMatrixEditingProviderFactory() {

        super(PROVIDER_NAME, PROVIDER_DESCRIPTION);

    }

    @Override

    public EditingServiceInfo getServiceInfo() {

        EditingServiceInfo serviceInfo =

            new DefaultEditingServiceinfo(PROVIDER_NAME, PROVIDER_DESCRIPTION, true, null,

                new int[] { 

                    Geometry.TYPES.POINT, Geometry.TYPES.MULTIPOINT,

                    Geometry.TYPES.CURVE, Geometry.TYPES.LINE, 

                    Geometry.TYPES.MULTICURVE, Geometry.TYPES.MULTILINE,

                    Geometry.TYPES.SURFACE, Geometry.TYPES.POLYGON, 

                    Geometry.TYPES.MULTISURFACE, Geometry.TYPES.MULTIPOLYGON });

        return serviceInfo;

    }

    @Override

    protected Provider doCreate(DynObject parameters, ProviderServices services) {

        return new PolarMatrixEditingProvider(parameters,services);

    }

}

org.gvsig.vectorediting.lib.prov.polarmatrix.PolarMatrixEditingLibrary

org.gvsig.vectorediting.lib.prov.splitline.SplitLineEditingLibrary

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2014 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.splitline;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.dynobject.DynObject;

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

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

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

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

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

/**

 * @author llmarques

 *

 */

public class SplitLineEditingProviderFactory extends AbstractEditingProviderFactory {

    public final static String PROVIDER_NAME = "modify-split-line";

    public final static String PROVIDER_DESCRIPTION =

        "Splits provider by a point";

    public SplitLineEditingProviderFactory() {

        super(PROVIDER_NAME, PROVIDER_DESCRIPTION);

    }

    @Override

    public EditingServiceInfo getServiceInfo() {

        EditingServiceInfo serviceInfo =

            new DefaultEditingServiceinfo(PROVIDER_NAME, "", false, null,

                new int[] { 

                    Geometry.TYPES.LINE, Geometry.TYPES.MULTILINE, 

                    Geometry.TYPES.CURVE, Geometry.TYPES.MULTICURVE 

                });

        return serviceInfo;

    }

    @Override

    protected Provider doCreate(DynObject parameters, ProviderServices services) {

        return new SplitLineEditingProvider(parameters, services);

    }

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2014 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.splitline;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.Library;

import org.gvsig.tools.library.LibraryException;

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

import org.gvsig.vectorediting.lib.prov.splitline.operation.ArcSplitLineOperation;

import org.gvsig.vectorediting.lib.prov.splitline.operation.CurveSplitLineOperation;

import org.gvsig.vectorediting.lib.prov.splitline.operation.SplitLineOperationUtils;

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

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

/**

 * @author llmarques

 *

 */

public class SplitLineEditingLibrary extends AbstractLibrary implements Library {

    @Override

    public void doRegistration() {

        registerAsServiceOf(EditingLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        EditingProviderManager manager =

            EditingProviderLocator.getProviderManager();

        manager.addProviderFactory(new SplitLineEditingProviderFactory());

        manager.registerIcon("vectorediting-tools", "modify-split-line", this

            .getClass().getClassLoader(), this.getClass().getName());

        SplitLineOperationUtils.register(new CurveSplitLineOperation(),

            Geometry.TYPES.CURVE);

        //Dejamos que la operacion para los ARC sea la de la CURVE porque

        //no se puede hacer con ARC transformados (elipses)

        SplitLineOperationUtils.register(new ArcSplitLineOperation(),

            Geometry.TYPES.ARC);

        SplitLineOperationUtils.register(new CurveSplitLineOperation(),

            Geometry.TYPES.LINE);

        //FIXME: Comprobar si el comportamiento de la operaci?n SplineSplitLineOperation es el deseado

        // y si s?, registrarla en lugar de CurveSpliLineOperation para Splines

        SplitLineOperationUtils.register(new CurveSplitLineOperation(),

            Geometry.TYPES.SPLINE);

        registerTranslations();

    }

    private void registerTranslations() {

        I18nManager manager = ToolsLocator.getI18nManager();

        manager.addResourceFamily("i18n/text",

            this.getClass().getClassLoader(), "split-line-editing");

    }

}

/**

 * gvSIG. Desktop Geographic Information System.

 *