Application: gvSIG desktop » gvSIG tools: Vector editing

<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.163</version>

  </parent>

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

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

</project>

org.gvsig.vectorediting.lib.prov.autopolygon.AutopolygonEditingLibrary

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

/**

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

 */

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;

public class AutopolygonEditingProviderFactory extends AbstractEditingProviderFactory {

    public final static String PROVIDER_NAME = "insert-autopolygon";

    public final static String PROVIDER_DESCRIPTION =

        "Creates autopolygons";

    public AutopolygonEditingProviderFactory() {

        super(PROVIDER_NAME, PROVIDER_DESCRIPTION);

    }

    @Override

    public EditingServiceInfo getServiceInfo() {

        EditingServiceInfo serviceInfo =

            new DefaultEditingServiceinfo(

                PROVIDER_NAME,

                "",

                false,

                null,

                new int[] { Geometry.TYPES.POLYGON, Geometry.TYPES.MULTIPOLYGON, Geometry.TYPES.SURFACE, Geometry.TYPES.MULTISURFACE });

        return serviceInfo;

    }

    @Override

    protected Provider doCreate(DynObject parameters, ProviderServices services) {

        return new AutopolygonEditingProvider(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.autopolygon;

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;

/**

 * Library for default implementation initialization and configuration.

 *

 * @author gvSIG team

 * @version $Id$

 */

public class AutopolygonEditingLibrary 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 AutopolygonEditingProviderFactory());

        manager.registerIcon("vectorediting-tools", "insert-autopolygon",

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

        registerTranslations();

    }

    private void registerTranslations() {

        I18nManager manager = ToolsLocator.getI18nManager();

        manager.addResourceFamily("i18n/text",

            this.getClass().getClassLoader(), "insert-autopolygon");

    }

}

/**

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

import java.util.ArrayList;

import java.util.List;

import org.cresques.cts.IProjection;

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

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

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

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

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

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

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

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.evaluator.Evaluator;

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

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

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

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

@SuppressWarnings("UseSpecificCatch")

public class AutopolygonEditingProvider extends AbstractEditingProvider

    implements EditingProvider {

    private final EditingServiceParameter geometryParameter;

    private final FeatureStore featureStore;

    private Geometry geometryValue;

    public AutopolygonEditingProvider(ProviderServices services,

        DynObject parameters) {

        super(services);

        this.featureStore =

            (FeatureStore) parameters

                .getDynValue(EditingProviderFactory.FEATURE_STORE_FIELD);

        this.geometryParameter =

            new DefaultEditingServiceParameter("Draw geometry",

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

    }

    @Override

    public EditingServiceParameter next() {

        if (geometryValue == null) {

            return geometryParameter;

        }

        return null;

    }

    @Override

    public DrawingStatus getDrawingStatus(Point mousePosition)

        throws DrawServiceException {

        return null;

    }

    @Override

    public void stop() throws StopServiceException {

        geometryValue = null;

    }

    @Override

    public List<EditingServiceParameter> getParameters() {

        List<EditingServiceParameter> list = new ArrayList<>();

        list.add(geometryParameter);

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

    }

    private void validateAndInsertValue(EditingServiceParameter param,

        Object value) throws InvalidEntryException {

        if (param == geometryParameter) {

            if (value instanceof Geometry ) {

                Geometry geometry = (Geometry)value;

                GeometryType geometryType = geometry.getGeometryType();

                if (geometryType.isTypeOf(Geometry.TYPES.MULTISURFACE) ||

                    geometryType.isTypeOf(Geometry.TYPES.SURFACE)) {

                    geometryValue = geometry;

                    return;

                }

            }

        }

        throw new InvalidEntryException(null);

    }

    @Override

    public void finishAndStore() throws FinishServiceException {

        EditingProviderServices editingProviderServices =

            (EditingProviderServices) getProviderServices();

        Geometry geometry = finish();

        editingProviderServices.insertGeometryIntoFeatureStore(geometry,

            featureStore);

    }

    @Override

    public Geometry finish() throws FinishServiceException {

        EditingProviderServices editingProviderServices =

            (EditingProviderServices) getProviderServices();

        Geometry geometry = geometryValue.cloneGeometry();

        FeatureQuery query;

        try {

            query = queryByGeometry(geometry);

            if (query != null) {

                FeatureSet features = featureStore.getFeatureSet(query);

                DisposableIterator featuresIterator = features.fastIterator();

                while (featuresIterator.hasNext()) {

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

                    geometry =

                        geometry.difference(feature.getDefaultGeometry());

                }

                featuresIterator.dispose();

                features.dispose();

            }

            GeometryType storeGeomType =

                editingProviderServices.getGeomType(featureStore);

            if (storeGeomType.isTypeOf(MULTISURFACE)) {

                MultiSurface multisurface;

                multisurface =

                    GeometryLocator.getGeometryManager().createMultiSurface(

                        storeGeomType.getSubType());

                multisurface.addSurface((Surface)geometry);

                return multisurface;

            }

        } catch (Exception e) {

            throw new FinishServiceException(e);

        }

        return geometry;

    }

    @Override

    public void start() throws StartServiceException, InvalidEntryException {

        geometryValue = null;

    }

    @Override

    public String getName() {

        return AutopolygonEditingProviderFactory.PROVIDER_NAME;

    }

    private FeatureQuery queryByGeometry(Geometry geometry) throws DataException {

        FeatureQuery featureQuery = featureStore.createFeatureQuery();

        FeatureType featureType = featureStore.getDefaultFeatureType();

        String geomName = featureType.getDefaultGeometryAttributeName();

        featureQuery.setFeatureType(featureType);

        IProjection query_proj = featureType.getDefaultSRS();

        Evaluator iee = SpatialEvaluatorsFactory.getInstance().intersects(

            geometry, 

            query_proj, 

            featureStore

        );

        featureQuery.setFilter(iee);

        featureQuery.setAttributeNames(null);

        return featureQuery;

    }

    @Override

    public Object getValue(EditingServiceParameter parameter) {

        if(parameter == this.geometryParameter){

            return geometryValue;

        }

        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.163</version>

  </parent>

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

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

  <description>Edit Vertex Tool</description>

</project>

package org.gvsig.vectorediting.lib.prov.editvertex.operation;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.fmap.geom.Geometry;

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

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

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

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

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

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

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

/**

 * @author fdiaz

 *

 */

public class PointEditVertexOperation implements EditVertexOperation {

    /**

     *

     */

    public PointEditVertexOperation() {

        // TODO Auto-generated constructor stub

    }

    @Override

    public Geometry insertVertex(Primitive geom, int index) throws CreateGeometryException {

        return geom;

    }

    @Override

    public Geometry removeVertex(Primitive geom, int index) throws CreateGeometryException {

        return geom;

    }

    @Override

    public Geometry moveVertex(Primitive geom, int index, Point point) {

        if(index!=0) {

            return geom;

        }

        Point p = ((Point)geom);

        int min = point.getDimension() < p.getDimension() ? point.getDimension() : p.getDimension();

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

            p.setCoordinateAt(i, point.getCoordinateAt(i));

        }

        return p;

    }

    @Override

    public List<Point> getVertexesList(Primitive geom) {

        ArrayList<Point> vertexList = new ArrayList<>();

        if (geom instanceof Point) {

            Point point = (Point) geom;

            vertexList.add(point);

        }

        return vertexList;

    }

    @Override

    public int getNumVertex(Primitive geom) {

        return 1;

    }

    @Override

    public boolean canInsertVertex(Primitive geom, int index) {

        return false;

    }

    @Override

    public boolean canRemoveVertex(Primitive geom, int index) {

        return false;

    }

    @Override

    public boolean canMoveVertex(int index, Point point) {

        return true;

    }

    @Override

    public void addToDrawingStatus(DefaultDrawingStatus drawingStatus,

        Primitive primitive) {

        EditingProviderManager editingProviderManager =

            EditingProviderLocator.getProviderManager();

        ISymbol pointSymbolEditing =

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

        drawingStatus.addStatus(primitive, drawingStatus.getPreviewSymbol(), "");

        drawingStatus.addStatus(primitive, pointSymbolEditing, "");

    }

}

package org.gvsig.vectorediting.lib.prov.editvertex.operation;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

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

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

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

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

public class CircumferenceEditVertexOperation implements EditVertexOperation {

    public CircumferenceEditVertexOperation() {

        // TODO Auto-generated constructor stub

    }

    @Override

    public Geometry insertVertex(Primitive geom, int index)

        throws CreateGeometryException {

        return null;

    }

    @Override

    public Geometry removeVertex(Primitive geom, int index)

        throws CreateGeometryException {

        return null;

    }

    @Override

    public Geometry moveVertex(Primitive geom, int index, Point point) {

        Circumference result = (Circumference) geom.cloneGeometry();

        if(index == 0){

            result.setPoints(point, ((Circumference)geom).getRadious());

        } else if (index == 1){

            result.setPoints(((Circumference)geom).getCenter(), point);

        }

        return result;

    }

    @Override

    public List<Point> getVertexesList(Primitive geom) throws CreateGeometryException {

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        ArrayList<Point> vertexList = new ArrayList<>();

        Circumference circumference = (Circumference) geom;

        Point center = circumference.getCenter();

        vertexList.add(center);

        vertexList.add(geometryManager.createPoint(center.getX()

            + circumference.getRadious(), center.getY(), geom

            .getGeometryType().getSubType()));

        return vertexList;

    }

    @Override

    public int getNumVertex(Primitive geom) {

        return 2;

    }

    @Override

    public boolean canInsertVertex(Primitive geom, int index) {

        return false;

    }

    @Override

    public boolean canRemoveVertex(Primitive geom, int index) {

        return false;

    }

    @Override

    public boolean canMoveVertex(int index, Point point) {

        return true;

    }

    @Override

    public void addToDrawingStatus(DefaultDrawingStatus drawingStatus,

        Primitive primitive) {

        EditingProviderManager editingProviderManager =

            EditingProviderLocator.getProviderManager();

        ISymbol lineSymbolEditing =

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

        drawingStatus.addStatus(primitive, drawingStatus.getPreviewSymbol(), "");

        drawingStatus.addStatus(primitive, lineSymbolEditing, "");

    }

}

package org.gvsig.vectorediting.lib.prov.editvertex.operation;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

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

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

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

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

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

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

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

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

/**

 * @author fdiaz

 *

 */

public class FilledSplineEditVertexOperation implements EditVertexOperation {

    /**

     *

     */

    public FilledSplineEditVertexOperation() {

        // TODO Auto-generated constructor stub

    }

    @Override

    public Geometry insertVertex(Primitive geom, int index)

        throws CreateGeometryException {

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        GeometryType geomType = geom.getGeometryType();

        FilledSpline result =

            (FilledSpline) geometryManager.create(Geometry.TYPES.FILLEDSPLINE,geomType.getSubType());

        FilledSpline filledSpline = (FilledSpline) geom;

        int numVertices = filledSpline.getNumVertices();

        double[][] values = new double[geom.getDimension()][numVertices];

        for (int v = 0; v < numVertices; v++) {

            for (int d = 0; d < filledSpline.getDimension(); d++) {

                values[d][v] = filledSpline.getCoordinateAt(v, d);

            }

        }

        int auxIndex = index;

        if(index==0) {

            auxIndex = numVertices-1;

        }

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

            Point point = filledSpline.getVertex(i);

            if (i > 0 && i == auxIndex) {

                Point newPoint;

                try {

                    newPoint = (Point) geometryManager.create(geometryManager.getGeometryType(Geometry.TYPES.POINT, geomType.getSubType()));

                } catch (GeometryTypeNotSupportedException | GeometryTypeNotValidException e) {

                    throw new CreateGeometryException(Geometry.TYPES.POINT, geomType.getSubType(), e);

                }

                SplineCalculator splineDim;

                for(int d=0; d<geom.getDimension(); d++){

                    splineDim = new SplineCalculator(values[d]);

                    newPoint.setCoordinateAt(d, splineDim.fn(i-1, 0.5));

                }

                result.addVertex(newPoint);

            }

            result.addVertex(point);

        }

        return result;

    }

    @Override

    public Geometry removeVertex(Primitive geom, int index)

        throws CreateGeometryException {

        org.gvsig.fmap.geom.primitive.FilledSpline filledSpline = (org.gvsig.fmap.geom.primitive.FilledSpline) geom.cloneGeometry();

        if (index < 0) {

            return filledSpline;

        }

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        int numVertices = filledSpline.getNumVertices();

        if (index >= numVertices){

            return filledSpline;

        }

        if (filledSpline.getVertex(0).equals(filledSpline.getVertex(numVertices - 1))) {

            if (numVertices <= 4) {

                return filledSpline;

            }

            if(index == 0 || index == numVertices - 1){

                filledSpline.removeVertex(numVertices - 1);

                filledSpline.removeVertex(0);

                filledSpline.addVertex(filledSpline.getVertex(0));

                numVertices --;

                return filledSpline;

            }

            numVertices--;

        } else {

            if (numVertices <= 3) {

                return filledSpline;

            }

        }

        filledSpline.removeVertex(index);

        return filledSpline;

    }

    @Override

    public Geometry moveVertex(Primitive geom, int index, Point point) {

        FilledSpline result = (FilledSpline) geom.cloneGeometry();

        int numVertices = result.getNumVertices();

        if (result.getVertex(0).equals(result.getVertex(numVertices - 1))) {

            if (index == 0 || index == (result.getNumVertices() - 1)) {

                EditVertexOperationUtils.setVertex(result, 0, point);

                EditVertexOperationUtils.setVertex(result,

                    result.getNumVertices() - 1, (Point)point.cloneGeometry());

                return result;

            }

        }

        EditVertexOperationUtils.setVertex(result, index, point);

        return result;

    }

    @Override

    public List<Point> getVertexesList(Primitive geom) {

        ArrayList<Point> vertexList = new ArrayList<>();

        if (geom instanceof OrientablePrimitive) {

            OrientablePrimitive orientable = (OrientablePrimitive) geom;

            orientable.getNumVertices();

            for (int i = 0; i < orientable.getNumVertices(); i++) {

                vertexList.add(orientable.getVertex(i));

            }

        }

        return vertexList;

    }

    @Override

    public int getNumVertex(Primitive geom) {

        if (geom instanceof OrientablePrimitive) {

            OrientablePrimitive orientable = (OrientablePrimitive) geom;

            return orientable.getNumVertices();

        }

        return 0;

    }

    @Override

    public boolean canInsertVertex(Primitive geom, int index) {

        return true;

    }

    @Override

    public boolean canRemoveVertex(Primitive geom, int index) {

        return true;

    }

    @Override

    public boolean canMoveVertex(int index, Point point) {

        return true;

    }

    @Override

    public void addToDrawingStatus(DefaultDrawingStatus drawingStatus,

        Primitive primitive) {

        EditingProviderManager editingProviderManager =

            EditingProviderLocator.getProviderManager();

        ISymbol lineSymbolEditing =

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

        drawingStatus.addStatus(primitive, drawingStatus.getPreviewSymbol(), "");

        drawingStatus.addStatus(primitive, lineSymbolEditing, "");

    }

}

package org.gvsig.vectorediting.lib.prov.editvertex.operation;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

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

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

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

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

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

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

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

/**

 * @author fdiaz

 *

 */

public class SplineEditVertexOperation implements EditVertexOperation {

    /**

     *

     */

    public SplineEditVertexOperation() {

        // TODO Auto-generated constructor stub

    }

    @Override

    public Geometry insertVertex(Primitive geom, int index)

        throws CreateGeometryException {

        if (index == 0) {

            return geom;

        }

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        GeometryType geomType = geom.getGeometryType();

        org.gvsig.fmap.geom.primitive.Spline result =

            (org.gvsig.fmap.geom.primitive.Spline) geometryManager.create(Geometry.TYPES.SPLINE,geomType.getSubType());

        org.gvsig.fmap.geom.primitive.Spline spline = (org.gvsig.fmap.geom.primitive.Spline) geom;

        int numVertices = spline.getNumVertices();

        double[][] values = new double[geom.getDimension()][numVertices];

        for (int v = 0; v < numVertices; v++) {

            for (int d = 0; d < spline.getDimension(); d++) {

                values[d][v] = spline.getCoordinateAt(v, d);

            }

        }

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

            Point point = spline.getVertex(i);

            if (i>0 && i == index) {

                Point newPoint;

                try {

                    newPoint = (Point) geometryManager.create(geometryManager.getGeometryType(Geometry.TYPES.POINT, geomType.getSubType()));

                } catch (GeometryTypeNotSupportedException | GeometryTypeNotValidException e) {

                    throw new CreateGeometryException(Geometry.TYPES.POINT, geomType.getSubType(), e);

                }

                SplineCalculator splineDim;

                for(int d=0; d<geom.getDimension(); d++){

                    splineDim = new SplineCalculator(values[d]);

                    newPoint.setCoordinateAt(d, splineDim.fn(i-1, 0.5));

                }

                result.addVertex(newPoint);

            }

            result.addVertex(point);

        }

        return result;

    }

    @Override

    public Geometry removeVertex(Primitive geom, int index)

        throws CreateGeometryException {

        if (index < 0) {

            return geom;

        }

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        org.gvsig.fmap.geom.primitive.Spline result =

            (org.gvsig.fmap.geom.primitive.Spline) geometryManager.create(Geometry.TYPES.SPLINE,geom.getGeometryType().getSubType());

        org.gvsig.fmap.geom.primitive.Spline spline = (org.gvsig.fmap.geom.primitive.Spline) geom;

        int numVertices = spline.getNumVertices();

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

            Point point = spline.getVertex(i);

            if (i == index) {

                continue;

            }

            result.addVertex(point);

        }

        return result;

    }

    @Override

    public Geometry moveVertex(Primitive geom, int index, Point point) {

        org.gvsig.fmap.geom.primitive.Spline result = (org.gvsig.fmap.geom.primitive.Spline) geom.cloneGeometry();

        EditVertexOperationUtils.setVertex(result, index, point);

        return result;

    }

    @Override

    public List<Point> getVertexesList(Primitive geom) {

        ArrayList<Point> vertexList = new ArrayList<>();

        if (geom instanceof OrientablePrimitive) {

            OrientablePrimitive orientable = (OrientablePrimitive) geom;

            orientable.getNumVertices();

            for (int i = 0; i < orientable.getNumVertices(); i++) {

                vertexList.add(orientable.getVertex(i));

            }

        }

        return vertexList;

    }

    @Override

    public int getNumVertex(Primitive geom) {

        if (geom instanceof OrientablePrimitive) {

            OrientablePrimitive orientable = (OrientablePrimitive) geom;

            return orientable.getNumVertices();

        }

        return 0;

    }

    @Override

    public boolean canInsertVertex(Primitive geom, int index) {

        return index != 0;

    }

    @Override

    public boolean canRemoveVertex(Primitive geom, int index) {

        return true;

    }

    @Override

    public boolean canMoveVertex(int index, Point point) {

        return true;

    }

    @Override

    public void addToDrawingStatus(DefaultDrawingStatus drawingStatus,

        Primitive primitive) {

        EditingProviderManager editingProviderManager =

            EditingProviderLocator.getProviderManager();

        ISymbol lineSymbolEditing =

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

        drawingStatus.addStatus(primitive, drawingStatus.getPreviewSymbol(), "");

        drawingStatus.addStatus(primitive, lineSymbolEditing, "");

    }

}

package org.gvsig.vectorediting.lib.prov.editvertex.operation;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

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

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

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

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

public class EllipseEditVertexOperation implements EditVertexOperation {

    public EllipseEditVertexOperation() {

        // TODO Auto-generated constructor stub

    }

    @Override

    public Geometry insertVertex(Primitive geom, int index)

        throws CreateGeometryException {

        return null;

    }

    @Override

    public Geometry removeVertex(Primitive geom, int index)

        throws CreateGeometryException {

        return null;

    }

    @Override

    public Geometry moveVertex(Primitive geom, int index, Point point) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException {

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        PeriEllipse original = (PeriEllipse)geom;

        PeriEllipse result = (PeriEllipse) original.cloneGeometry();

        switch (index) {

            case 0:

                result.setPoints(point, original.getAxis1End(), original.getAxis2Dist());

                break;

            case 1:

                result.setPoints(original.getAxis1Start(), point, original.getAxis2Dist());

                break;

            case 2:

                Point axis1Start = original.getAxis1Start();

                Point axis1End = original.getAxis1End();

                Point center = geometryManager.createPoint(

                        (axis1Start.getX()+axis1End.getX())/2,

                        (axis1Start.getY()+axis1End.getY())/2,

                        geom.getGeometryType().getSubType());

                result.setPoints(original.getAxis1Start(), original.getAxis1End(), center.distance(point));

                break;

            default:

                break;

        }

        return result;

    }

    @Override

    public List<Point> getVertexesList(Primitive geom) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException {

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        ArrayList<Point> vertexList = new ArrayList<>();

        PeriEllipse ellipse = (PeriEllipse) geom;

        Point axis1Start = ellipse.getAxis1Start();

        vertexList.add(axis1Start);

        Point axis1End = ellipse.getAxis1End();

        vertexList.add(axis1End);

        Point center = geometryManager.createPoint(

            (axis1Start.getX()+axis1End.getX())/2,

            (axis1Start.getY()+axis1End.getY())/2,

            geom.getGeometryType().getSubType());

        double angle = getAngle(axis1Start, axis1End);

        vertexList.add(geometryManager.createPoint(

            center.getX() + ellipse.getAxis2Dist()*Math.cos(angle+Math.PI/2),

            center.getY() + ellipse.getAxis2Dist()*Math.sin(angle+Math.PI/2),

            geom.getGeometryType().getSubType()));

        return vertexList;

    }

    @Override

    public int getNumVertex(Primitive geom) {

        return 3;

    }

    @Override

    public boolean canInsertVertex(Primitive geom, int index) {

        return false;

    }

    @Override

    public boolean canRemoveVertex(Primitive geom, int index) {

        return false;

    }

    @Override

    public boolean canMoveVertex(int index, Point point) {

        return true;

    }

    public double getAngle(Point start, Point end)

        throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        double angle =

            Math.acos((end.getX() - start.getX()) / start.distance(end));

        if (start.getY() > end.getY()) {

            angle = -angle;

        }

        if (angle < 0) {

            angle += (2 * Math.PI);

        }

        return angle;

    }

    @Override

    public void addToDrawingStatus(DefaultDrawingStatus drawingStatus,

        Primitive primitive) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException {

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        EditingProviderManager editingProviderManager =

            EditingProviderLocator.getProviderManager();

        ISymbol auxiliaryLineSymbolEditing =

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

        ISymbol lineSymbolEditing =

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

        PeriEllipse ellipse = (PeriEllipse)primitive;

        Point axis1Start = ellipse.getAxis1Start();

        Point axis1End = ellipse.getAxis1End();

        Line axis1Line = geometryManager.createLine(primitive.getGeometryType().getSubType());

        axis1Line.setPoints(axis1Start,axis1End);

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

        Line axis2Line = geometryManager.createLine(primitive.getGeometryType().getSubType());

        Point center = geometryManager.createPoint(

            (axis1Start.getX()+axis1End.getX())/2,

            (axis1Start.getY()+axis1End.getY())/2,

            primitive.getGeometryType().getSubType());

        double angle = getAngle(axis1Start, axis1End);

        Point axis2Point1 = geometryManager.createPoint(

        center.getX() + ellipse.getAxis2Dist()*Math.cos(angle+Math.PI/2),

        center.getY() + ellipse.getAxis2Dist()*Math.sin(angle+Math.PI/2),

        primitive.getGeometryType().getSubType());

        Point axis2Point2 = geometryManager.createPoint(

        center.getX() - ellipse.getAxis2Dist()*Math.cos(angle+Math.PI/2),

        center.getY() - ellipse.getAxis2Dist()*Math.sin(angle+Math.PI/2),

        primitive.getGeometryType().getSubType());

        axis2Line.setPoints(axis2Point1,

            axis2Point2);

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

        drawingStatus.addStatus(primitive, drawingStatus.getPreviewSymbol(), "");

        drawingStatus.addStatus(primitive, lineSymbolEditing, "");

    }

}

package org.gvsig.vectorediting.lib.prov.editvertex.operation;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

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

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

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

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

public class FilledEllipseEditVertexOperation implements EditVertexOperation {

    public FilledEllipseEditVertexOperation() {

        // TODO Auto-generated constructor stub

    }

    @Override

    public Geometry insertVertex(Primitive geom, int index)

        throws CreateGeometryException {

        return null;

    }

    @Override

    public Geometry removeVertex(Primitive geom, int index)

        throws CreateGeometryException {

        return null;

    }

    @Override

    public Geometry moveVertex(Primitive geom, int index, Point point) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException {

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        Ellipse result = (Ellipse) geom.cloneGeometry();

        switch (index) {

            case 0:

                result.setPoints(point, ((Ellipse)geom).getAxis1End(), ((Ellipse)geom).getAxis2Dist());

                break;

            case 1:

                result.setPoints(((Ellipse)geom).getAxis1Start(), point, ((Ellipse)geom).getAxis2Dist());

                break;

            case 2:

                Point axis1Start = ((Ellipse)geom).getAxis1Start();

                Point axis1End = ((Ellipse)geom).getAxis1End();

                Point center = geometryManager.createPoint(

                        (axis1Start.getX()+axis1End.getX())/2,

                        (axis1Start.getY()+axis1End.getY())/2,

                        geom.getGeometryType().getSubType());

                result.setPoints(((Ellipse)geom).getAxis1Start(), ((Ellipse)geom).getAxis1End(), center.distance(point));

                break;

            default:

                break;

        }

        return result;

    }

    @Override

    public List<Point> getVertexesList(Primitive geom) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException {

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        ArrayList<Point> vertexList = new ArrayList<>();

        Ellipse ellipse = (Ellipse) geom;

        Point axis1Start = ellipse.getAxis1Start();

        vertexList.add(axis1Start);

        Point axis1End = ellipse.getAxis1End();

        vertexList.add(axis1End);

        Point center = geometryManager.createPoint(

            (axis1Start.getX()+axis1End.getX())/2,

            (axis1Start.getY()+axis1End.getY())/2,

            geom.getGeometryType().getSubType());

        double angle = getAngle(axis1Start, axis1End);

        vertexList.add(geometryManager.createPoint(

            center.getX() + ellipse.getAxis2Dist()*Math.cos(angle+Math.PI/2),

            center.getY() + ellipse.getAxis2Dist()*Math.sin(angle+Math.PI/2),

            geom.getGeometryType().getSubType()));

        return vertexList;

    }

    @Override

    public int getNumVertex(Primitive geom) {

        return 3;

    }

    @Override

    public boolean canInsertVertex(Primitive geom, int index) {

        return false;

    }

    @Override

    public boolean canRemoveVertex(Primitive geom, int index) {

        return false;

    }

    @Override

    public boolean canMoveVertex(int index, Point point) {

        return true;

    }

    public double getAngle(Point start, Point end)

        throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        double angle =

            Math.acos((end.getX() - start.getX()) / start.distance(end));

        if (start.getY() > end.getY()) {

            angle = -angle;

        }

        if (angle < 0) {

            angle += (2 * Math.PI);

        }

        return angle;

    }

    @Override

    public void addToDrawingStatus(DefaultDrawingStatus drawingStatus,

        Primitive primitive) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException {

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        EditingProviderManager editingProviderManager =

            EditingProviderLocator.getProviderManager();

        ISymbol auxiliaryLineSymbolEditing =

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

        ISymbol polygonSymbolEditing =

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

        Ellipse ellipse = (Ellipse)primitive;

        Point axis1Start = ellipse.getAxis1Start();

        Point axis1End = ellipse.getAxis1End();

        Line axis1Line = geometryManager.createLine(primitive.getGeometryType().getSubType());

        axis1Line.setPoints(axis1Start,axis1End);

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

        Line axis2Line = geometryManager.createLine(primitive.getGeometryType().getSubType());

        Point center = geometryManager.createPoint(

            (axis1Start.getX()+axis1End.getX())/2,

            (axis1Start.getY()+axis1End.getY())/2,

            primitive.getGeometryType().getSubType());

        double angle = getAngle(axis1Start, axis1End);

        Point axis2Point1 = geometryManager.createPoint(

        center.getX() + ellipse.getAxis2Dist()*Math.cos(angle+Math.PI/2),

        center.getY() + ellipse.getAxis2Dist()*Math.sin(angle+Math.PI/2),

        primitive.getGeometryType().getSubType());

        Point axis2Point2 = geometryManager.createPoint(

        center.getX() - ellipse.getAxis2Dist()*Math.cos(angle+Math.PI/2),

        center.getY() - ellipse.getAxis2Dist()*Math.sin(angle+Math.PI/2),

        primitive.getGeometryType().getSubType());

        axis2Line.setPoints(axis2Point1,

            axis2Point2);

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

        drawingStatus.addStatus(primitive, drawingStatus.getPreviewSymbol(), "");

        drawingStatus.addStatus(primitive, polygonSymbolEditing, "");

    }

}

package org.gvsig.vectorediting.lib.prov.editvertex.operation;

import java.util.List;

import org.gvsig.fmap.geom.Geometry;

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

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

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

/**

 * @author fdiaz

 *

 */

public interface EditVertexOperation {

    /**

     * @param geom

     * @param index

     * @return The geometry with the inserted vertex

     * @throws CreateGeometryException

     */

    public Geometry insertVertex(Primitive geom, int index) throws CreateGeometryException;

    /**

     * @param geom

     * @param index

     * @return true if can insert vertex

     */

    public boolean canInsertVertex(Primitive geom, int index);

    /**

     * @param geom

     * @param index

     * @return The geometry without the removed vertex

     * @throws CreateGeometryException

     */

    public Geometry removeVertex(Primitive geom, int index) throws CreateGeometryException;

    /**

     * @param geom

     * @param index

     * @return true if can remove vertex

     */

    public boolean canRemoveVertex(Primitive geom, int index);

    /**

     * @param geom

     * @param index

     * @param point

     * @return the geometry with the moved vertex

     * @throws CreateGeometryException

     * @throws GeometryOperationNotSupportedException

     * @throws GeometryOperationException

     */

    public Geometry moveVertex(Primitive geom, int index, Point point) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException;

    /**

     * @param index

     * @param point

     * @return true if can move vertex

     */

    public boolean canMoveVertex(int index, Point point);

    /**

     * @param geom

     * @return a list of vertices

     * @throws CreateGeometryException

     * @throws GeometryOperationNotSupportedException

     * @throws GeometryOperationException

     */

    public List<Point> getVertexesList(Primitive geom) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException;

    /**

     * @param geom

     * @return the number of vertices

     */

    public int getNumVertex(Primitive geom);

    /**

     * @param drawingStatus

     * @param primitive

     * @throws CreateGeometryException

     * @throws GeometryOperationNotSupportedException

     * @throws GeometryOperationException

     */

    public void addToDrawingStatus(DefaultDrawingStatus drawingStatus,

        Primitive primitive) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException;

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2016 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.editvertex.operation;

/**

 * @author fdiaz

 *

 */

public class SplineCalculator {

    private final double y[];

    private final double y2[];

    /**

     * The constructor calculates the second derivatives of the interpolating function

     * at the tabulated points xi, with xi = (i, y[i]).

     * Based on numerical recipes in C, http://www.library.cornell.edu/nr/bookcpdf/c3-3.pdf .

     * @param y Array of y coordinates for cubic-spline interpolation.

     */

    public SplineCalculator(double y[]) {

        this.y = y;

        int n = y.length;

        y2 = new double[n];

        double u[] = new double[n];

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

            y2[i] = -1.0 / (4.0 + y2[i - 1]);

            u[i] = (6.0 * (y[i + 1] - 2.0 * y[i] + y[i - 1]) - u[i - 1]) / (4.0 + y2[i - 1]);

        }

        for (int i = n - 2; i >= 0; i--) {

            y2[i] = y2[i] * y2[i + 1] + u[i];

        }

    }

    /**

     * Returns a cubic-spline interpolated value y for the point between

     * point (n, y[n]) and (n+1, y[n+1), with t ranging from 0 for (n, y[n])

     * to 1 for (n+1, y[n+1]).

     * @param n The start point.

     * @param t The distance to the next point (0..1).

     * @return A cubic-spline interpolated value.

     */

    public double fn(int n, double t) {

        return t * y[n + 1] - ((t - 1.0) * t * ((t - 2.0) * y2[n] - (t + 1.0) * y2[n + 1])) / 6.0 + y[n] - t * y[n];

    }

}

package org.gvsig.vectorediting.lib.prov.editvertex.operation;

import java.util.HashMap;

import java.util.Map;

import org.gvsig.fmap.geom.Geometry;

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

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

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