Application: gvSIG desktop » gvSIG tools: Vector 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 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);

            ToolsLocator.getDisposableManager().bind(featureSelection);

            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;

    }

}

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.LINE, Geometry.TYPES.MULTILINE, 

                    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;

    }

}

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

<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.92</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>

org.gvsig.vectorediting.lib.prov.trimline.TrimLineEditingLibrary

/**

 * 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.LINE, Geometry.TYPES.MULTILINE, 

                    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.

 *

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

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

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

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

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

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

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

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

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

import org.gvsig.tools.locator.LocatorException;

/**

 * Represents an operation to trim curve.

 * 

 * @author llmarques

 *

 */

public interface TrimLineOperation {

    /**

     * Trim line, taking as cutting edges the boundary objects received as

     * parameters.

     * 

     * Inserted point is the point inserted by user. It is used to determinate

     * what segment of curve it must trimmed.

     * 

     * If curveToBeExtended does not intersect with any geometry, the geometry

     * will not be modified.

     * 

     * @param curveToTrim

     *            Curve to trim

     * @param insertedPoint

     *            Point inserted by user to determinate what side of curve must

     *            be extended.

     * @param boundaryObjects

     *            If curveToBeExtended intersects with some boundary object, it

     *            will

     *            be extend to it. If there are several boundary objects that

     *            intersects with curveToBeExtended, it will be extended to

     *            nearest

     *            point.

     * @return Trimmed line

     */

    public MultiCurve trimLine(Curve curveToTrim, Point insertedPoint,

        FeatureSelection boundaryObjects)

        throws GeometryOperationNotSupportedException,

        GeometryOperationException, DataException, CreateGeometryException,

        LocatorException;

}

/**

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

import java.util.HashMap;

import java.util.Map;

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

import org.gvsig.fmap.geom.GeometryLocator;

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

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

import org.gvsig.tools.locator.LocatorException;

/**

 * @author llmarques

 *

 */

public class TrimLineOperationUtils {

    /**

     * Use it to indicate start side should be trimmed

     */

    public static final String START_SIDE = "start";

    /**

     * Use it to indicate end side should be trimmed

     */

    public static final String END_SIDE = "end";

    private static Map<Integer, TrimLineOperation> operations =

        new HashMap<Integer, TrimLineOperation>();

    public TrimLineOperationUtils() {

    }

    public static void register(TrimLineOperation operation, int geometryType) {

        operations.put(geometryType, operation);

    }

    public static TrimLineOperation getOperation(Primitive geom) {

        Integer type = geom.getGeometryType().getType();

        TrimLineOperation operation = operations.get(type);

        return operation;

    }

    // FIXME: remove this method when geometry library has this utility method

    public static 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;

    }

    public static Arc createArc(Point center, double radius, Point initPoint,

        Point endPoint, int subtype) throws CreateGeometryException,

        LocatorException, GeometryOperationNotSupportedException,

        GeometryOperationException {

        Arc arc =

            (Arc) GeometryLocator.getGeometryManager().create(TYPES.ARC,

                subtype);

        double startAngle = TrimLineOperationUtils.getAngle(center, initPoint);

        double endAngle = TrimLineOperationUtils.getAngle(center, endPoint);

        arc.setPointsStartEnd(center, radius, startAngle, endAngle);

        return arc;

    }

    public static boolean intersects(Curve curve, Point projectedPoint)

        throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        double tolerance = 1;

        return curve.buffer(tolerance).intersects(projectedPoint);

    }

}

/**

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

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

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

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

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.locator.LocatorException;

/**

 * Operation to trim curves.

 * 

 * @author llmarques

 */

public class CurveTrimLineOperation implements TrimLineOperation {

    /*

     * Strategy:

     * 

     * 1. Get arc segments between curve and boundary objects.

     * 2. Determinate what segment of curve must be deleted

     * 3. Rebuild curve taking into account the segment that must be deleted

     */

    public MultiCurve trimLine(Curve curveToTrim, Point insertedPoint,

        FeatureSelection boundaryObjects)

        throws GeometryOperationNotSupportedException,

        GeometryOperationException, DataException, CreateGeometryException,

        LocatorException {

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        int subType = curveToTrim.getGeometryType().getSubType();

        DisposableIterator it = boundaryObjects.fastIterator();

        MultiCurve segmentedLine = geometryManager.createMultiCurve(subType);

        segmentedLine.addCurve(curveToTrim);

        while (it.hasNext()) {

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

            Geometry geometry = feature.getDefaultGeometry();

            Geometry tmpDifference = segmentedLine.difference(geometry);

            if (tmpDifference instanceof MultiCurve) {

                segmentedLine = (MultiCurve) tmpDifference;

            } else if(tmpDifference instanceof Curve) {

                // Sometimes line to split and splitter are so close ( distance

                // between geometries < 0.00000000001 ). In this cases, we try

                // to do an enhance difference.

                // If the result is instance of Curve, it is considered that

                // lines don't intersect.

                // If the result is instance of Multicurve, lines are so close

                // and it is considered that lines intersect.

                Geometry enchancedGeometry = enhancedDifference(geometry, (Curve) tmpDifference);

                if(enchancedGeometry instanceof MultiCurve){

                    segmentedLine = (MultiCurve) enchancedGeometry;

                } 

            }

        }

        if (segmentedLine.getPrimitivesNumber() == 1) {

            return segmentedLine;

        }

        int index = 0;

        Curve curve;

        double minDistance = Double.POSITIVE_INFINITY;

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

            curve = segmentedLine.getCurveAt(i);

            double distance = curve.distance(insertedPoint);

            if (distance < minDistance) {

                index = i;

                minDistance = distance;

            }

        }

        MultiCurve trimmedCurve = geometryManager.createMultiCurve(subType);

        Curve tmpCurve = null;

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

            if (i == index) {

                if (tmpCurve != null) {

                    trimmedCurve.addCurve(tmpCurve);

                    tmpCurve = null;

                }

                continue;

            }

            if (tmpCurve != null) {

                tmpCurve = union(tmpCurve, segmentedLine.getCurveAt(i));

            } else {

                tmpCurve = segmentedLine.getCurveAt(i);

            }

        }

        if (tmpCurve != null) {

            trimmedCurve.addCurve(tmpCurve);

        }

        return trimmedCurve;

    }

    private Curve union(Curve firstCurve, Curve secondCurve)

        throws CreateGeometryException, LocatorException,

        GeometryOperationNotSupportedException, GeometryOperationException {

        int subtype1 = firstCurve.getGeometryType().getSubType();

        int subtype2 = secondCurve.getGeometryType().getSubType();

        if (subtype1 == subtype2) {

            Curve union =

                GeometryLocator.getGeometryManager().createLine(subtype1);

            for (int i = 0; i < firstCurve.getNumVertices() - 1; i++) {

                union.addVertex(firstCurve.getVertex(i));

            }

            Point lastVertex =

                firstCurve.getVertex(firstCurve.getNumVertices() - 2);

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

                if (i == 0) {

                    Line tmpLine =

                        GeometryLocator.getGeometryManager().createLine(

                            subtype1);

                    tmpLine.setPoints(lastVertex, secondCurve.getVertex(1));

                    if (TrimLineOperationUtils.intersects(tmpLine,

                        secondCurve.getVertex(0))) {

                        continue;

                    }

                }

                union.addVertex(secondCurve.getVertex(i));

            }

            return union;

        }

        return null;

    }

    private Geometry enhancedDifference(Geometry splitter, Curve curve)

        throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        Geometry snapTo = curve.snapTo(splitter, 0.1);

        return snapTo.difference(splitter);

    }

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 gvSIG Association