Application: gvSIG desktop » gvSIG tools: Vector editing

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

/**

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

    }

}

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 java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.cresques.cts.IProjection;

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

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

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

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.Geometry.TYPES;

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

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

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

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

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

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.exception.BaseException;

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

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;

public class AutopolygonEditingProvider extends AbstractEditingProvider

    implements EditingProvider {

    private EditingServiceParameter geometryParameter;

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

    }

    public EditingServiceParameter next() {

        if (geometryValue == null) {

            return geometryParameter;

        }

        return null;

    }

    public DrawingStatus getDrawingStatus(Point mousePosition)

        throws DrawServiceException {

        return null;

    }

    public void stop() throws StopServiceException {

        geometryValue = null;

    }

    public List<EditingServiceParameter> getParameters() {

        List<EditingServiceParameter> list =

            new ArrayList<EditingServiceParameter>();

        list.add(geometryParameter);

        return list;

    }

    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 && value != null) {

                geometryValue = (Geometry)value;

                return;

            }

        }

        throw new InvalidEntryException(null);

    }

    public void finishAndStore() throws FinishServiceException {

        EditingProviderServices editingProviderServices =

            (EditingProviderServices) getProviderServices();

        Geometry geometry = finish();

        editingProviderServices.insertGeometryIntoFeatureStore(geometry,

            featureStore);

    }

    public Geometry finish() throws FinishServiceException {

        EditingProviderServices editingProviderServices =

            (EditingProviderServices) getProviderServices();

        Geometry geometry = geometryValue.cloneGeometry();

        FeatureQuery query = null;

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

            new FinishServiceException(e);

        }

        return geometry;

    }

    public void start() throws StartServiceException, InvalidEntryException {

        geometryValue = null;

    }

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

        IntersectsGeometryEvaluator iee =

            new IntersectsGeometryEvaluator(geometry, query_proj,

                featureType, geomName);

        featureQuery.setFilter(iee);

        featureQuery.setAttributeNames(null);

        return featureQuery;

    }

}

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

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectManager;

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

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

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

public class AutopolygonEditingProviderFactory extends

AbstractProviderFactory implements EditingProviderFactory {

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

    public final static String PROVIDER_DESCRIPTION =

        "Creates autopolygons";

    public void initialize() {

    }

    public EditingServiceInfo getServiceInfo() {

        EditingServiceInfo serviceInfo =

            new DefaultEditingServiceinfo(

                PROVIDER_NAME,

                "",

                false,

                null,

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

        return serviceInfo;

    }

    @Override

    protected Provider doCreate(DynObject parameters, ProviderServices services) {

        return new AutopolygonEditingProvider(services, parameters);

    }

    @Override

    protected DynClass createParametersDynClass() {

        DynObjectManager dynObjectManager = ToolsLocator.getDynObjectManager();

        DynClass dynclass =

            dynObjectManager

            .createDynClass(PROVIDER_NAME, PROVIDER_DESCRIPTION);

        dynclass.addDynFieldString(PROVIDER_NAME_FIELD);

        dynclass.addDynFieldObject(FEATURE_STORE_FIELD);

        dynclass.addDynFieldObject(MAPCONTEXT_FIELD);

        return dynclass;

    }

    @Override

    public DynObject createParameters() {

        DynObject parameters = super.createParameters();

        parameters.setDynValue(PROVIDER_NAME_FIELD, PROVIDER_NAME);

        return parameters;

    }

}

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

  </parent>

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

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

</project>

org.gvsig.vectorediting.lib.prov.smoothline.SmoothLineEditingLibrary

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

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

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

public abstract class ControlCurve {

    protected double[] m_X;

    protected double[] m_Y;

    protected Line line;

    public ControlCurve(final Line line) {

       m_X = new double[line.getNumVertices()];

       m_Y = new double[line.getNumVertices()];

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

          m_X[i] = line.getVertex(i).getX();

          m_Y[i] = line.getVertex(i).getY();

       }

       this.line = line;

    }

    public abstract Line getSmoothedLine(int iSteps, int subtype) throws CreateGeometryException;

 }

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

public class Cubic {

    double a, b, c, d; /* a + b*u + c*u^2 +d*u^3 */

    public Cubic(final double a,

                 final double b,

                 final double c,

                 final double d) {

       this.a = a;

       this.b = b;

       this.c = c;

       this.d = d;

    }

    /** evaluate cubic */

    public double eval(final double u) {

       return (((d * u) + c) * u + b) * u + a;

    }

 }

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

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

public class NatCubic extends ControlCurve {

    /*

     * calculates the natural cubic spline that interpolates

     * y[0], y[1], ... y[n]

     * The first segment is returned as

     * C[0].a + C[0].b*u + C[0].c*u^2 + C[0].d*u^3 0<=u <1

     * the other segments are in C[1], C[2], ... C[n-1]

     */

    public NatCubic(final Line line) {

        super(line);

    }

    Cubic[] calcNaturalCubic(final int n, final double[] x) {

        final double[] gamma = new double[n + 1];

        final double[] delta = new double[n + 1];

        final double[] D = new double[n + 1];

        int i;

        /*

         * We solve the equation

         * [2 1 ] [D[0]] [3(x[1] - x[0]) ]

         * |1 4 1 | |D[1]| |3(x[2] - x[0]) |

         * | 1 4 1 | | . | = | . |

         * | ..... | | . | | . |

         * | 1 4 1| | . | |3(x[n] - x[n-2])|

         * [ 1 2] [D[n]] [3(x[n] - x[n-1])]

         *

         * by using row operations to convert the matrix to upper triangular

         * and then back sustitution. The D[i] are the derivatives at the knots.

         */

        gamma[0] = 1.0f / 2.0f;

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

            gamma[i] = 1 / (4 - gamma[i - 1]);

        }

        gamma[n] = 1 / (2 - gamma[n - 1]);

        delta[0] = 3 * (x[1] - x[0]) * gamma[0];

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

            delta[i] = (3 * (x[i + 1] - x[i - 1]) - delta[i - 1]) * gamma[i];

        }

        delta[n] = (3 * (x[n] - x[n - 1]) - delta[n - 1]) * gamma[n];

        D[n] = delta[n];

        for (i = n - 1; i >= 0; i--) {

            D[i] = delta[i] - gamma[i] * D[i + 1];

        }

        /* now compute the coefficients of the cubics */

        final Cubic[] C = new Cubic[n];

        for (i = 0; i < n; i++) {

            C[i] =

                new Cubic(x[i], D[i], 3 * (x[i + 1] - x[i]) - 2 * D[i]

                    - D[i + 1], 2 * (x[i] - x[i + 1]) + D[i] + D[i + 1]);

        }

        return C;

    }

    @Override

    public Line getSmoothedLine(final int iSteps, int subtype) throws CreateGeometryException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        if (m_X.length >= 2) {

            final Cubic[] X = calcNaturalCubic(m_X.length - 1, m_X);

            final Cubic[] Y = calcNaturalCubic(m_Y.length - 1, m_Y);

            Line line = geomManager.createLine(subtype);

            /*

             * very crude technique - just break each segment up into steps

             * lines

             */

            line.addVertex((int) Math.round(X[0].eval(0)),

                (int) Math.round(Y[0].eval(0)));

            for (int i = 0; i < X.length; i++) {

                for (int j = 1; j <= iSteps; j++) {

                    final float u = j / (float) iSteps;

                    line.addVertex(X[i].eval(u), Y[i].eval(u));

                }

            }

            return line;

        } else {

            return this.line;

        }

    }

}

/**

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

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

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

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

/**

 * @author fdiaz

 *

 */

public class SmoothLineEditingProviderFactory extends AbstractProviderFactory

    implements EditingProviderFactory {

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

    private final static String PROVIDER_DESCRIPTION =

        "Smooth lines";

    public void initialize() {

    }

    public EditingServiceInfo getServiceInfo() {

        EditingServiceInfo serviceInfo =

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

                new int[] { Geometry.TYPES.CURVE,

                    Geometry.TYPES.MULTICURVE });

        return serviceInfo;

    }

    @Override

    protected Provider doCreate(DynObject parameters, ProviderServices services) {

        return new SmoothLineEditingProvider(parameters, services);

    }

    @Override

    public DynObject createParameters() {

        DynObject dynobject = super.createParameters();

        dynobject.setDynValue(PROVIDER_NAME_FIELD, PROVIDER_NAME);

        return dynobject;

    }

    @Override

    protected DynClass createParametersDynClass() {

        DynClass dynclass =

            ToolsLocator.getDynObjectManager().createDynClass(PROVIDER_NAME,

                PROVIDER_DESCRIPTION);

        dynclass.addDynFieldString(PROVIDER_NAME_FIELD);

        dynclass.addDynFieldObject(FEATURE_STORE_FIELD);

        dynclass.addDynFieldObject(MAPCONTEXT_FIELD);

        return dynclass;

    }

}

/**

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

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 fdiaz

 *

 */

public class SmoothLineEditingLibrary 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 SmoothLineEditingProviderFactory());

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

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

        registerTranslations();

    }

    private void registerTranslations() {

        I18nManager manager = ToolsLocator.getI18nManager();

        manager.addResourceFamily("i18n.text",

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

    }

}

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

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

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

public class BSpline extends ControlCurve {

    public BSpline(final Line line) {

        super(line);

    }

    // the basis function for a cubic B spline

    float b(final int i, float t) {

        switch (i) {

        case -2:

            return (((-t + 3) * t - 3) * t + 1) / 6;

        case -1:

            return (((3 * t - 6) * t) * t + 4) / 6;

        case 0:

            return (((-3 * t + 3) * t + 3) * t + 1) / 6;

        case 1:

            return (t * t * t) / 6;

        }

        return 0; // we only get here if an invalid i is specified

    }

    // evaluate a point on the B spline

    private Point p(final int i, final float t, int subtype) throws CreateGeometryException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        float px = 0;

        float py = 0;

        for (int j = -2; j <= 1; j++) {

            px += b(j, t) * m_X[i + j];

            py += b(j, t) * m_Y[i + j];

        }

        return geomManager.createPoint((int) Math.round(px), (int) Math.round(py), subtype);

    }

    @Override

    public Line getSmoothedLine(final int iSteps, int subtype) throws CreateGeometryException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        Line line = geomManager.createLine(subtype);

        Point q = p(2, 0, subtype);

        line.addVertex(q.getX(), q.getY());

        for (int i = 2; i < m_X.length - 1; i++) {

            for (int j = 1; j <= iSteps; j++) {

                q = p(i, j / (float) iSteps, subtype);

                line.addVertex(q);

            }

        }

        return line;

    }

}

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

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

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

public class Bezier extends ControlCurve {

    public Bezier(final Line line) {

        super(line);

    }

    // the basis function for a Bezier spline

    static float b(final int i, final float t) {

        switch (i) {

        case 0:

            return (1 - t) * (1 - t) * (1 - t);

        case 1:

            return 3 * t * (1 - t) * (1 - t);

        case 2:

            return 3 * t * t * (1 - t);

        case 3:

            return t * t * t;

        }

        return 0; // we only get here if an invalid i is specified

    }

    // evaluate a point on the B spline

    Point p(final int i, final float t, int subtype) throws CreateGeometryException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        float px = 0;

        float py = 0;

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

            px += b(j, t) * m_X[i + j];

            py += b(j, t) * m_Y[i + j];

        }

        return geomManager.createPoint((int) Math.round(px), (int) Math.round(py),subtype);

    }

    @Override

    public Line getSmoothedLine(final int iSteps, int subtype) throws CreateGeometryException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        Line line = geomManager.createLine(subtype);

        Point q = p(0, 0, subtype);

        line.addVertex(q);

        for (int i = 0; i < m_X.length - 3; i += 3) {

            for (int j = 1; j <= iSteps; j++) {

                q = p(i, j / (float) iSteps, subtype);

                line.addVertex(q);

            }

        }

        return line;

    }

}

/**

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

import java.util.ArrayList;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryException;

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

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

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

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

import org.gvsig.tools.ToolsLocator;

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

 *

 */

public class SmoothLineEditingProvider extends AbstractEditingProvider implements

    EditingProvider {

    private EditingServiceParameter selection;

    private EditingServiceParameter steps;

    private EditingServiceParameter algorithm;

    private FeatureStore featureStore;

    private Map<EditingServiceParameter, Object> values;

    protected Map<String, String> options;

    public static final String    NATURAL_CUBIC_SPLINES = "natural_cubic_splines";

    public static final String    BEZIER_CURVES         = "bezier_curves";

    public static final String    BSPLINES              = "b_splines";

    /**

     * Default constructor.

     *

     * @param providerServices

     *            available services for this provider

     * @param parameters

     *            of this provider

     */

    public SmoothLineEditingProvider(DynObject parameters,

        ProviderServices services) {

        super(services);

        this.featureStore =

            (FeatureStore) parameters

                .getDynValue(EditingProviderFactory.FEATURE_STORE_FIELD);

        this.selection =

            new DefaultEditingServiceParameter("selection", "selection",

                TYPE.SELECTION);

        this.steps =

            new DefaultEditingServiceParameter("steps", "intermediate_steps_1_9",

                TYPE.VALUE);

        I18nManager i18nManager = ToolsLocator.getI18nManager();

//        "Natural cubic splines","Bezier curves", "B splines"

        options = new LinkedHashMap<String, String>();

        options.put(i18nManager.getTranslation("key_natural_cubic_splines"), NATURAL_CUBIC_SPLINES);

        options.put(i18nManager.getTranslation("key_bezier_curves"),BEZIER_CURVES);

        options.put(i18nManager.getTranslation("key_b_splines"),BSPLINES);

        EditingProviderServices editingProviderServices =

            (EditingProviderServices) getProviderServices();

        String consoleMsg =

            editingProviderServices.makeConsoleMessage(null, options);

        this.algorithm =

            new DefaultEditingServiceParameter("algorithm", consoleMsg, options,

                EditingServiceParameter.TYPE.OPTION);

}

    public EditingServiceParameter next() {

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

            return selection;

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

            return steps;

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

            return algorithm;

        }

        return null;

    }

    public DrawingStatus getDrawingStatus(Point mousePosition)

        throws DrawServiceException {

        return null;

    }

    public void stop() throws StopServiceException {

        if (values != null) {

            values.clear();

        }

    }

    public List<EditingServiceParameter> getParameters() {

        List<EditingServiceParameter> parameters =

            new ArrayList<EditingServiceParameter>();

        parameters.add(selection);

        parameters.add(steps);

        parameters.add(algorithm);

        return parameters;

    }

    public void setValue(Object value) throws InvalidEntryException {

        EditingServiceParameter parameter = next();

        validateAndInsertValue(parameter, value);

    }

    private void validateAndInsertValue(EditingServiceParameter parameter,

        Object value) throws InvalidEntryException {

        if (parameter == selection) {

            FeatureSelection featureSelection = (FeatureSelection) value;

            if (featureSelection.getSelectedCount() > 0) {

                try {

                    featureSelection.accept(new Visitor() {

                        public void visit(Object obj)

                            throws VisitCanceledException, BaseException {

                            Feature feature = (Feature) obj;

                            Geometry geometry = feature.getDefaultGeometry();

                            GeometryType geometryType =

                                geometry.getGeometryType();

                            if (!geometryType.isTypeOf(Geometry.TYPES.CURVE)

                                && !geometryType.isTypeOf(Geometry.TYPES.MULTICURVE)) {

                                throw new InvalidEntryException(null);

                            }

                        }

                    });

                    values.put(selection, value);

                    return;

                } catch (BaseException e) {

                    throw new InvalidEntryException(e);

                }

            }

        } else if (parameter == steps) {

            if (value instanceof Double) {

                Integer stepsValue = ((Double) value).intValue();

                if (stepsValue > 0 && stepsValue < 10 ) {

                    values.put(steps, stepsValue);

                    return;

                }

            }

        }  else if (parameter == algorithm) {

            if (value instanceof String) {

                I18nManager i18nManager = ToolsLocator.getI18nManager();

                String option = (String) value;

                if (option.equalsIgnoreCase(i18nManager.getTranslation("key_natural_cubic_splines"))){

                    values.put(parameter, "key_natural_cubic_splines");

                    return;

                }

                if (option.equalsIgnoreCase(i18nManager.getTranslation("key_bezier_curves"))){

                    values.put(parameter, "key_bezier_curves");

                    return;

                }

                if (option.equalsIgnoreCase(i18nManager.getTranslation("key_b_splines"))){

                    values.put(parameter, "key_b_splines");

                    return;

                }

            }

            throw new InvalidEntryException(null);

        }

        throw new InvalidEntryException(null);

    }

    public Geometry finish() throws FinishServiceException {

        return null;

    }

    public void finishAndStore() throws FinishServiceException {

        if (values != null) {

            FeatureSelection featureSelection =

                (FeatureSelection) values.get(selection);

            final Integer stepsValue = (Integer) values.get(steps);

            final String algorithmValue = (String)values.get(algorithm);

            final EditingProviderServices editingProviderServices =

                (EditingProviderServices) getProviderServices();

            try {

                final int subtype =

                    editingProviderServices.getSubType(featureStore);

                featureSelection.accept(new Visitor() {

                    public void visit(Object obj)

                        throws VisitCanceledException, BaseException {

                        Feature feature = (Feature) obj;

                        Geometry geometry = feature.getDefaultGeometry();

                        GeometryType geoType = geometry.getGeometryType();

                        if (geoType.isTypeOf(AGGREGATE)) {

                            MultiCurve multiCurveToSmooth =

                                (MultiCurve) geometry;

                            MultiCurve multiCurveSmoothed =

                                GeometryLocator.getGeometryManager()

                                    .createMultiCurve(subtype);

                            for (int i = 0; i < multiCurveToSmooth

                                .getPrimitivesNumber(); i++) {

                                Curve curveToSmooth =

                                    (Curve) multiCurveToSmooth

                                        .getPrimitiveAt(i);

                                curveToSmooth =

                                    smoothLine(curveToSmooth, stepsValue, algorithmValue);

                                multiCurveSmoothed.addCurve(curveToSmooth);

                                geometry = multiCurveSmoothed;

                            }

                        } else {

                            Curve curveToSmooth = (Curve) geometry;

                            curveToSmooth =

                                smoothLine(curveToSmooth, stepsValue, algorithmValue);

                            geometry = curveToSmooth;

                        }

                        EditableFeature eFeature = feature.getEditable();

                        eFeature.setDefaultGeometry(geometry);

                        editingProviderServices.updateFeatureInFeatureStore(

                            eFeature, featureStore);

                    }

                });

                featureStore.getFeatureSelection().deselectAll();

                featureSelection.dispose();

            } catch (BaseException e) {

                throw new FinishServiceException(e);

            }

        }

    }

    private Line smoothLine(Curve curveToSmooth, Integer steps, String algorithm) throws DataException, CreateGeometryException{

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        EditingProviderServices editingProviderServices =

            (EditingProviderServices) getProviderServices();

        int subtype = editingProviderServices.getSubType(featureStore);

        Line lineToSmooth = null;

        if (curveToSmooth instanceof Arc || curveToSmooth instanceof Spline) {

            lineToSmooth = geometryManager.createLine(curveToSmooth.getGeometryType().getSubType());

            lineToSmooth.setGeneralPath(curveToSmooth.getGeneralPath());

        } else {

            lineToSmooth = (Line)curveToSmooth;

        }

        ControlCurve operation;

        if (algorithm.equalsIgnoreCase("key_natural_cubic_splines")){

            operation = new NatCubic(lineToSmooth);

        } else if (algorithm.equalsIgnoreCase("key_bezier_curves")){

            operation = new Bezier(lineToSmooth);

        } else if (algorithm.equalsIgnoreCase("key_b_splines")){

            operation = new BSpline(lineToSmooth);

        } else {

            return null;

        }

        return operation.getSmoothedLine(steps, subtype);

    }

    private Line simplifyLine(Curve curveToSimplify, Double toleranceValue)

        throws DataException, CreateGeometryException,

        GeometryOperationNotSupportedException, GeometryOperationException {

        EditingProviderServices editingProviderServices =

            (EditingProviderServices) getProviderServices();

        int subtype = editingProviderServices.getSubType(featureStore);

        Line simplifiedLine =

            (Line) GeometryLocator.getGeometryManager().createLine(subtype);

        // Add first vertex

        simplifiedLine.addVertex(curveToSimplify.getVertex(0));

        // Iterate over vertices

        for (int i = 0; i < curveToSimplify.getNumVertices() - 2; i++) {

            Point vertex = curveToSimplify.getVertex(i);

            Point nextVertex = curveToSimplify.getVertex(i + 1);

            Point nextNextVertex = curveToSimplify.getVertex(i + 2);

            // Creates line between i vertex and i+2 vertex

            Line tmpLine =

                editingProviderServices.createLine(vertex, nextNextVertex,

                    subtype);

            // If distance between line and i+1 vertex is bigger than tolerance

            // add point to simplifiedLine, else skip vertex

            if (tmpLine.distance(nextVertex) > toleranceValue) {

                simplifiedLine.addVertex(nextVertex);

            } else {

                i++;

            }

        }

        // Add last vertex

        simplifiedLine.addVertex(curveToSimplify.getVertex(curveToSimplify

            .getNumVertices() - 1));

        return simplifiedLine;

    }

    public void start() throws StartServiceException, InvalidEntryException {

        values = new HashMap<EditingServiceParameter, Object>();

        FeatureSelection selected = null;

        if (featureStore != null) {

            try {

                selected = featureStore.getFeatureSelection();

            } catch (DataException e) {

                throw new StartServiceException(e);

            }

            if (selected.getSelectedCount() > 0) {

                try {

                    setValue(selected);

                } catch (InvalidEntryException e) {

                    throw new InvalidEntryException(e);

                }

            }

        }

    }

    public String getName() {

        return SmoothLineEditingProviderFactory.PROVIDER_NAME;

    }

}

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

  </parent>

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

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

  <description>Editing provider to smooth lines</description>

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

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

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

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

/**

 * @author llmarques

 *

 */

public class TrimLineEditingProviderFactory extends AbstractProviderFactory

    implements EditingProviderFactory {

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

    private final static String PROVIDER_DESCRIPTION =

        "Trim lines by cutting edges";

    public void initialize() {

    }

    public EditingServiceInfo getServiceInfo() {

        EditingServiceInfo serviceInfo =

            new DefaultEditingServiceinfo(PROVIDER_NAME, PROVIDER_DESCRIPTION,

                false, null, new int[] { Geometry.TYPES.CURVE,

                    Geometry.TYPES.MULTICURVE });

        return serviceInfo;

    }

    @Override

    protected Provider doCreate(DynObject parameters, ProviderServices services) {

        return new TrimLineEditingProvider(services, parameters);

    }

    @Override

    public DynObject createParameters() {

        DynObject dynobject = super.createParameters();

        dynobject.setDynValue(PROVIDER_NAME_FIELD, PROVIDER_NAME);

        return dynobject;

    }

    @Override

    protected DynClass createParametersDynClass() {

        DynClass dynclass =

            ToolsLocator.getDynObjectManager().createDynClass(PROVIDER_NAME,

                PROVIDER_DESCRIPTION);

        dynclass.addDynFieldString(PROVIDER_NAME_FIELD);

        dynclass.addDynFieldObject(FEATURE_STORE_FIELD);

        dynclass.addDynFieldObject(MAPCONTEXT_FIELD);

        return dynclass;

    }

}

/**

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

import org.gvsig.fmap.geom.Geometry.TYPES;

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.prov.trimline.operation.ArcTrimLineOperation;

import org.gvsig.vectorediting.lib.prov.trimline.operation.CurveTrimLineOperation;

import org.gvsig.vectorediting.lib.prov.trimline.operation.TrimLineOperationUtils;

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

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

/**

 * @author llmarques

 *

 */

public class TrimLineEditingLibrary extends AbstractLibrary implements Library {

    @Override

    protected void doInitialize() throws LibraryException {

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        EditingProviderManager manager =

            EditingProviderLocator.getProviderManager();

        manager.addProviderFactory(new TrimLineEditingProviderFactory());

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

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

        TrimLineOperationUtils.register(new ArcTrimLineOperation(), TYPES.ARC);

        TrimLineOperationUtils.register(new CurveTrimLineOperation(), TYPES.SPLINE);

        TrimLineOperationUtils.register(new CurveTrimLineOperation(), TYPES.LINE);

        TrimLineOperationUtils.register(new CurveTrimLineOperation(), TYPES.CURVE);

        registerTranslations();

    }

    private void registerTranslations() {

        I18nManager manager = ToolsLocator.getI18nManager();

        manager.addResourceFamily("i18n/text",

            this.getClass().getClassLoader(), "modify-trim-line");

    }

}

/**

 * gvSIG. Desktop Geographic Information System.

 *