Application: gvSIG desktop » gvSIG tools: Vector editing

/**

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

import java.awt.Color;

import java.awt.geom.Point2D;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import org.apache.commons.lang3.tuple.ImmutablePair;

import org.apache.commons.lang3.tuple.Pair;

import org.gvsig.euclidean.EuclideanLine2D;

import org.gvsig.euclidean.EuclideanManager;

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

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

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

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

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

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

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

import org.gvsig.fmap.mapcontext.MapContext;

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

import org.gvsig.symbology.SymbologyLocator;

import org.gvsig.symbology.SymbologyManager;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.i18n.I18nManager;

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

import org.gvsig.tools.util.ToolsUtilLocator;

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 static org.gvsig.vectorediting.lib.prov.chamfer.SegmentData.SEGMENT_POSITION_FIRST;

import static org.gvsig.vectorediting.lib.prov.chamfer.SegmentData.SEGMENT_POSITION_LAST;

import static org.gvsig.vectorediting.lib.prov.chamfer.SegmentData.SEGMENT_POSITION_MIDDLE;

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

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

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

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

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

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

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * @author fdiaz

 *

 */

public class ChamferByLengthAndAngleEditingProvider extends AbstractEditingProvider {

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

    private static final int ERR_OK = 0;

    private static final int ERR_CHAMFER_TOO_LARGE = 1;

    private static final int ERR_SEGMENT_DATA_NOT_FILLED = 2;

    private static final int ERR_FIRST_SEGMENT_DATA_NULL = 3;

    private static final int ERR_SAME_SEGMENT = 4;

    private static final int ERR_CANT_CALCULATE_CHAMFER_POINT = 5;

    private static final int ERR_NON_ADJACENT_SEGMENTS = 6;

    private static final int ERR_DIFFERENT_GEOMETRY_TYPES = 7;

    private static final int ERR_CANT_CONNECT_SEGMENTS = 8;

    private static final int ERR_ONE_OF_THE_TWO_SEGMENTS_ISNT_EXTREME = 9;

    private static final int ERR_INVALID_VALUE = 10;

    private static final int ERR_INVALID_GEOMETRY_TYPE = 11;

    private static final int ERR_CANT_FIND_NEAREST_GEOMETRY = 12;

    private static final int ERR_CANT_CALCULATE_CHAMFER = 13;

    private static String[] stateMessages= {

        "_Valid",

        "_Chamfer_too_large",

        "_Cant_fill_segment_data",

        "_First_segment_data_is_null",

        "_Same_segment",

        "_Cant_calculate_chamfer_point",

        "_Non-adjacent_segments",

        "_Different_geometry_types",

        "_Cant_connect_segments",

        "_One_of_the_two_segments_isnt_extreme",

        "_Invalid_value",

        "_Invalid_geometry_type",

        "_Cant_find_nearest_geometry",

        "_Cant_calculate_chamfer"

    };

    private static final int INSIDE_THE_SEGMENT = 0;

    private static final int BEYOND_THE_SEGMENT = 1;

    private static final int INVALID_ZONE = -1;

    private static final String CHAMFER_LENGTH = "_Length";

//    private static final String CHAMFER_ANGLE = "_Angle";

//

//    private static final String SHORT_CHAMFER_LENGTH = "_Short_length";

//    private static final String SHORT_CHAMFER_ANGLE = "_Short_angle";

//    private static final String CHAMFER_METHOD = "_Method";

    private static final String DELETE_SECOND_SELECTED_GEOMETRY_QUESTION = "_Delete_second_selected_geometry_question";

    private static final String DELETE_SECOND_SELECTED_GEOMETRY = "_Delete_second_selected_geometry";

    private static final String YES = "_yes";

    private static final String NO = "_no";

    private static final String SHORT_YES = "_short_yes";

    private static final String SHORT_NO = "_short_no";

    //Variable est?tica para guardarnos el deleteSecondFeatureDefaultValue

    private static Boolean deleteSecondFeatureDefaultValue;

    private final EditingServiceParameter lengthParameter;

    private final EditingServiceParameter firstSegmentParameter;

    private final EditingServiceParameter secondSegmentParameter;

    private final EditingServiceParameter angleParameter;

    private final EditingServiceParameter deleteSecondSelectedGeometryParameter;

    private final Map<EditingServiceParameter, Object> values;

    private final FeatureStore featureStore;

    private final MapContext mapContext;

    private SegmentData firstSegmentData;

    private SegmentData secondSegmentData;

    private Point pointToChamfer;

    //Variable est?tica para guardarnos la distancia por defecto

    private static Double savedDistance;

    private ISymbol previewSymbol;

    /**

     * Default constructor.

     *

     * @param providerServices available services for this provider

     * @param parameters of this provider

     */

    public ChamferByLengthAndAngleEditingProvider(ProviderServices providerServices,

            DynObject parameters) {

        super(providerServices);

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        this.featureStore

                = (FeatureStore) parameters

                        .getDynValue(EditingProviderFactory.FEATURE_STORE_FIELD);

        this.mapContext

                = (MapContext) parameters

                        .getDynValue(EditingProviderFactory.MAPCONTEXT_FIELD);

        this.firstSegmentParameter

                = new DefaultEditingServiceParameter("_First_segment", "_First_segment", TYPE.POSITION);

        this.secondSegmentParameter

                = new DefaultEditingServiceParameter("_Second_segment", "_Second_segment", TYPE.POSITION);

//        DefaultEditingServiceParameterOptions methodOptions = new DefaultEditingServiceParameterOptions()

//                .add(i18nManager.getTranslation(CHAMFER_LENGTH), CHAMFER_LENGTH, i18nManager.getTranslation(SHORT_CHAMFER_LENGTH))

//                .add(i18nManager.getTranslation(CHAMFER_ANGLE), CHAMFER_ANGLE, i18nManager.getTranslation(SHORT_CHAMFER_ANGLE));

//        String methodConsoleMsg

//                = ((EditingProviderServices) providerServices).makeConsoleMessage(

//                        i18nManager.getTranslation(CHAMFER_METHOD), methodOptions);

        this.lengthParameter = new DefaultEditingServiceParameter(

                "_Length",

                "_Length",

                TYPE.VALUE,

//                TYPE.POSITION,

                TYPE.DISTANCE

        );

        this.angleParameter

                = new DefaultEditingServiceParameter("_Angle", "_Angle",

                        TYPE.POSITION,

                        TYPE.VALUE);

        DefaultEditingServiceParameterOptions deleteSecondSelectedGeometryParameterOptions = new DefaultEditingServiceParameterOptions()

                .add(YES, true, i18nManager.getTranslation(SHORT_YES))

                .add(NO, false, i18nManager.getTranslation(SHORT_NO));

        String consoleMsg

                = ((EditingProviderServices) providerServices).makeConsoleMessage(

                        DELETE_SECOND_SELECTED_GEOMETRY_QUESTION, deleteSecondSelectedGeometryParameterOptions);

        this.deleteSecondSelectedGeometryParameter

                = new DefaultEditingServiceParameter(

                        DELETE_SECOND_SELECTED_GEOMETRY,

                        consoleMsg,

                        deleteSecondSelectedGeometryParameterOptions,

                        null, //deleteSecondFeatureDefaultValue,

                        false,

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

        this.values = new HashMap<>();

        this.firstSegmentData = null;

        this.secondSegmentData = null;

    }

    @Override

    public String getName() {

        return ChamferByLengthAndAngleEditingProviderFactory.PROVIDER_NAME;

    }

    @Override

    public EditingServiceParameter next() {

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

            return this.lengthParameter;

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

            return this.firstSegmentParameter;

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

            return this.secondSegmentParameter;

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

            return this.angleParameter;

        } else if (values.get(deleteSecondSelectedGeometryParameter) == null && 

                !Objects.equals(firstSegmentData.getFeature().getReference(), secondSegmentData.getFeature().getReference())) {

            return this.deleteSecondSelectedGeometryParameter;

        }

        return null;

    }

    @Override

    public DrawingStatus getDrawingStatus(Point mousePosition)

            throws DrawServiceException {

        DefaultDrawingStatus geometries = new DefaultDrawingStatus();

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        EditingProviderManager editingProviderManager

                = EditingProviderLocator.getProviderManager();

        ISymbol lineSymbolEditing = editingProviderManager.getSymbol("line-symbol-editing");

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

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

        ISymbol polygonSymbolEditing = editingProviderManager.getSymbol("polygon-symbol-editing");

        ISymbol ruleAxisSymbol = editingProviderManager.getSymbol("rule-axis-symbol");

        auxiliaryPointSymbolEditing.setColor(Color.RED);

        ISimpleTextSymbol textSymbol = getTextSymbol();

        EditingProviderServices editingProviderServices

                = (EditingProviderServices) getProviderServices();

        ISymbol previewSymbol = null;

        try {

            int subtype = editingProviderServices.getSubType(featureStore);

            Double distance;

            if (values != null) {

                if (values.get(this.lengthParameter) == null) {

                    return geometries;

                } else if (this.firstSegmentData == null) {

                    Feature firstFeature = getFeatureNearestPoint(mousePosition);

                    if (firstFeature == null) {

                        return geometries;

                    }

                    Geometry firstGeometry = firstFeature.getDefaultGeometry();

                    if (firstGeometry == null || !validateGeometryType(firstGeometry)) {

                        return geometries;

                    }

                    SegmentData segmentData = new SegmentData(firstFeature, mousePosition);

                    geometries.addStatus(segmentData.getProjectedPoint(), auxiliaryPointSymbolEditing, "");

                    geometries.addStatus(GeometryUtils.createLine(mousePosition, segmentData.getProjectedPoint(), subtype), auxiliaryLineSymbolEditing, "");

                    geometries.addStatus(segmentData.getLine(), auxiliaryLineSymbolEditing, "");

                    return geometries;

                } else if (this.secondSegmentData == null) {

                    geometries.addStatus(firstSegmentData.getLine(), auxiliaryLineSymbolEditing, "");

                    geometries.addStatus(firstSegmentData.getProjectedPoint(), auxiliaryPointSymbolEditing, "");

                    Feature secondFeature = getFeatureNearestPoint(mousePosition);

                    if (secondFeature == null) {

                        return geometries;

                    }

                    Geometry secondGeometry = secondFeature.getDefaultGeometry();

                    if (secondGeometry == null || !validateGeometryType(secondGeometry)) {

                        return geometries;

                    }

                    SegmentData segmentData = new SegmentData(secondFeature, mousePosition);

                    Pair<Point, Point> oppositePoints = calculateOpositeToChamferVertices(firstSegmentData, segmentData);

                    if (validateAsSecondSegmentData(segmentData, oppositePoints.getRight()) == ERR_OK) {

                        geometries.addStatus(segmentData.getProjectedPoint(), auxiliaryPointSymbolEditing, "");

                        geometries.addStatus(GeometryUtils.createLine(mousePosition, segmentData.getProjectedPoint(), subtype), auxiliaryLineSymbolEditing, "");

                        geometries.addStatus(segmentData.getLine(), auxiliaryLineSymbolEditing, "");

                        Point tmpPointToChamfer = calculatePointToChamfer(firstSegmentData, segmentData);

                        geometries.addStatus(tmpPointToChamfer, auxiliaryPointSymbolEditing, "");

                    } else {

                        return geometries;

                    }

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

                    Point tmpPointToFillet = calculatePointToChamfer(firstSegmentData, secondSegmentData);

                    Pair<Point, Point> oppositePoints = calculateOpositeToChamferVertices(firstSegmentData, secondSegmentData);

                    geometries.addStatus(

                            GeometryUtils.createLine(oppositePoints.getLeft(), tmpPointToFillet, subtype), 

                            auxiliaryLineSymbolEditing, 

                            ""

                    );

                    geometries.addStatus(

                            GeometryUtils.createLine(oppositePoints.getRight(), tmpPointToFillet, subtype), 

                            auxiliaryLineSymbolEditing, 

                            ""

                    );

                    distance = (Double) getValue(lengthParameter);

                    double angle = GeometryUtils.calculateAngle(

                            pointToChamfer,

                            mousePosition);

                    geometries.addStatus(tmpPointToFillet, auxiliaryPointSymbolEditing, "");

                    //Draw scaffolding

                    ScaffoldingToChamfer scaffolding = calculateScaffolding(firstSegmentData, secondSegmentData, tmpPointToFillet, distance, angle, subtype);

                    if(scaffolding == null){

                        return geometries;

                    }

                    geometries.addStatus(

                            GeometryUtils.createLine(

                                    tmpPointToFillet, 

                                    scaffolding.getP1(),

                                    subtype), 

                            auxiliaryLineSymbolEditing,

                            ""

                    );

                    if(scaffolding.isReversed()){

                        geometries.addStatus(

                                GeometryUtils.createLine(

                                        scaffolding.getP1(), 

                                        GeometryUtils.createPoint(scaffolding.getChamferRight().getX(), scaffolding.getChamferRight().getY()),

                                        subtype), 

                                auxiliaryLineSymbolEditing, 

                                ""

                        );

                    } else {

                        geometries.addStatus(

                                GeometryUtils.createLine(

                                        scaffolding.getP1(), 

                                        GeometryUtils.createPoint(scaffolding.getChamferRight().getX(), scaffolding.getChamferRight().getY()),

                                        subtype), 

                                auxiliaryLineSymbolEditing, 

                                ""

                        );

                    }

                    geometries.addStatus(

                            GeometryUtils.createLine(

                                    GeometryUtils.createPoint(scaffolding.getChamferRight().getX(), scaffolding.getChamferRight().getY()),

                                    GeometryUtils.createPoint(scaffolding.getChamferLeft().getX(), scaffolding.getChamferLeft().getY()),

                                    subtype), 

                            auxiliaryLineSymbolEditing, 

                            ""

                    );

                    //Draw angle

                    Line ruleAxisBaseLine;

                    ruleAxisBaseLine = geometryManager.createLine(subtype);

                    ruleAxisBaseLine.addVertex(tmpPointToFillet);

                    Point p2 = geometryManager.createPoint(

                            tmpPointToFillet.getX() + tmpPointToFillet.distance(mousePosition),

                            tmpPointToFillet.getY(), subtype);

                    ruleAxisBaseLine.addVertex(p2);

                    geometries.addStatus(ruleAxisBaseLine, ruleAxisSymbol, "");

                    Line angleLine = geometryManager.createLine(subtype);

                    angleLine.addVertex(tmpPointToFillet);

                    angleLine.addVertex(mousePosition);

                    geometries.addStatus(angleLine, ruleAxisSymbol, "");

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

                    Arc arc = GeometryUtils.createArc(

                            tmpPointToFillet,

                            tmpPointToFillet.distance(mousePosition) / 2,

                            0,

                            angle,

                            Geometry.SUBTYPES.GEOM2D);

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

                    double textDistance = 3 * tmpPointToFillet.distance(mousePosition) / 4;

                    Point pointText = geometryManager.createPoint(tmpPointToFillet.getX() + textDistance * Math.cos(angle / 2), tmpPointToFillet.getY() + textDistance * Math.sin(angle / 2), subtype);

                    geometries.addStatus(pointText, textSymbol, GeometryUtils.formatAngle("%5.3D\u00B0", Math.toDegrees(angle)));

                    //Draw result

                    drawResult(geometries, firstSegmentData, secondSegmentData, distance, angle, subtype);

                    return geometries;

                } else {

                    drawResult(

                            geometries, 

                            firstSegmentData, 

                            secondSegmentData,

                            (Double) getValue(lengthParameter), 

                            Math.toRadians((Double) getValue(angleParameter)), 

                            subtype

                    );

                    return geometries;

                }

            }

        } catch (Exception e) {

            throw new DrawServiceException(e);

        }

        return geometries;

    }

    private void drawResult(DefaultDrawingStatus geometries, SegmentData firstSegmentData, SegmentData secondSegmentData, Double length, Double angle, int subtype) throws CreateGeometryException, GeometryOperationNotSupportedException, IllegalStateException, GeometryException, GeometryOperationException {

        if(previewSymbol == null){

            return;

        }

        //Draw result

        Line chamfer = calculateChamfer(firstSegmentData, secondSegmentData, length, angle, subtype);

        if (chamfer == null) {

            return;

        }

        if (Objects.equals(firstSegmentData.getPrimitive(), secondSegmentData.getPrimitive())) {

            geometries.addStatus(chamferPrimitive(firstSegmentData.getPrimitive(), chamfer), previewSymbol, null);

        } else {

            geometries.addStatus(chamferPrimitives(firstSegmentData.getPrimitive(), secondSegmentData.getPrimitive(), chamfer), previewSymbol, null);

        }

    }

    private ISimpleTextSymbol getTextSymbol() {

        SymbologyManager symbologyManager = SymbologyLocator.getSymbologyManager();

        ISimpleTextSymbol textSymbol = symbologyManager.createSimpleTextSymbol();

        textSymbol.setFontSize(10);

        return textSymbol;

    }

    @Override

    public List<EditingServiceParameter> getParameters() {

        List<EditingServiceParameter> parameters

                = new ArrayList<>();

        parameters.add(lengthParameter);

        parameters.add(firstSegmentParameter);

        parameters.add(secondSegmentParameter);

        parameters.add(angleParameter);

        parameters.add(deleteSecondSelectedGeometryParameter);

        return parameters;

    }

    @Override

    public boolean isEnabled(EditingServiceParameter parameter) {

        return true;

    }

    @Override

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

        validateAndInsertValue(parameter, value);

    }

    @Override

    public void setValue(Object value) throws InvalidEntryException {

        EditingServiceParameter param = next();

        validateAndInsertValue(param, value);

    }

    private void validateAndInsertValue(EditingServiceParameter param,

            Object value) throws InvalidEntryException {

        try {

            EditingProviderServices editingProviderServices

                    = (EditingProviderServices) getProviderServices();

            int subtype = editingProviderServices.getSubType(featureStore);

            I18nManager i18n = ToolsLocator.getI18nManager();

            if (param == lengthParameter) {

                Double distance = null;

                if (value instanceof Double) {

                    distance = (Double) value;

                } else if (value == null) {

                    distance = (Double) lengthParameter.getDefaultValue();

                    if(distance == null){

                        throw new InvalidEntryException(getName(), ERR_INVALID_VALUE, i18n.getTranslation(stateMessages[ERR_INVALID_VALUE]));

                    }

                }

                values.put(param, distance);

                savedDistance = distance;

            } else if (param == firstSegmentParameter) {

                if (value instanceof Point) {

                    Point point = (Point) value;

                    Feature firstFeature = getFeatureNearestPoint(point);

                    if (firstFeature == null) {

                        throw new InvalidEntryException(new IllegalArgumentException("Can't find nearest feature."));

                    }

                    Geometry firstGeometry = firstFeature.getDefaultGeometry();

                    if (!validateGeometryType(firstGeometry)) {

                        throw new InvalidEntryException(getName(), ERR_INVALID_GEOMETRY_TYPE, i18n.getTranslation(stateMessages[ERR_INVALID_GEOMETRY_TYPE]));

                    }

                    this.firstSegmentData = new SegmentData(firstFeature, point);

                    if (!this.firstSegmentData.isFilled()) {

                        this.firstSegmentData = null;

                        throw new InvalidEntryException(getName(), ERR_CANT_FIND_NEAREST_GEOMETRY, i18n.getTranslation(stateMessages[ERR_CANT_FIND_NEAREST_GEOMETRY]));

                    }

                    if (firstSegmentData == null) {

                        throw new InvalidEntryException(getName(), ERR_CANT_FIND_NEAREST_GEOMETRY, i18n.getTranslation(stateMessages[ERR_CANT_FIND_NEAREST_GEOMETRY]));

                    }

                    values.put(param, value);

                    previewSymbol = getPreviewSymbol(this.firstSegmentData.getFeature());

                }

            } else if (param == secondSegmentParameter) {

                if (value instanceof Point) {

                    Point point = (Point) value;

                    Feature secondFeature = getFeatureNearestPoint(point);

                    if (secondFeature == null) {

                        throw new InvalidEntryException(getName(), ERR_CANT_FIND_NEAREST_GEOMETRY, i18n.getTranslation(stateMessages[ERR_CANT_FIND_NEAREST_GEOMETRY]));

                    }

                    SegmentData segmentData = new SegmentData(secondFeature, point);

                    Pair<Point, Point> oppositeVertices = calculateOpositeToChamferVertices(this.firstSegmentData, segmentData);

                    int errno = validateAsSecondSegmentData(segmentData, oppositeVertices.getRight());

                    if (errno != ERR_OK) {

                        this.secondSegmentData = null;

                        this.pointToChamfer = null;

                        throw new InvalidEntryException(getName(), errno, i18n.getTranslation(stateMessages[errno]));

                    } else {

                        try {

                            this.secondSegmentData = segmentData;

                            this.pointToChamfer = calculatePointToChamfer(this.firstSegmentData, this.secondSegmentData);

                            angleParameter.setDefaultValue(calculateDefaultAngle(this.pointToChamfer, oppositeVertices));

                            values.put(param, value);

                        } catch (GeometryOperationNotSupportedException | GeometryOperationException ex) {

                            throw new InvalidEntryException(getName(), ERR_CANT_CALCULATE_CHAMFER_POINT, i18n.getTranslation(stateMessages[ERR_CANT_FIND_NEAREST_GEOMETRY]));

                        }

                    }

                }

            } else if (param == angleParameter) {

                Double angle = null;

                if (value instanceof Double) {

                    angle = Math.toRadians((Double)value);

                } else if (value instanceof Point) {

                    Point point = (Point) value;

                    angle = GeometryUtils.calculateAngle(

                            pointToChamfer,

                            point);

                } else if (value == null) {

                    angle = Math.toRadians((Double) param.getDefaultValue());

                } else {

                    throw new InvalidEntryException(getName(), ERR_INVALID_VALUE, i18n.getTranslation(stateMessages[ERR_INVALID_VALUE]));

                }

                Double distance = (Double) getValue(lengthParameter);

                Line chamfer = calculateChamfer(firstSegmentData, secondSegmentData, distance, angle, subtype);

                if(chamfer == null){

                    throw new InvalidEntryException(getName(), ERR_CANT_CALCULATE_CHAMFER, i18n.getTranslation(stateMessages[ERR_CANT_FIND_NEAREST_GEOMETRY]));

                } else {

                    values.put(param, Math.toDegrees(angle));

                }

            } else if (param == deleteSecondSelectedGeometryParameter) {

                Boolean v = (Boolean) param.getOptions2().getValue(value, param.getDefaultValue());

                values.put(param, v);

                deleteSecondFeatureDefaultValue = v;

            }

        } catch (InvalidEntryException ex) {

            throw ex;

        } catch (Exception ex) {

            throw new InvalidEntryException(ex);

        }

    }

    private boolean validateGeometryType(Geometry geometry) throws IllegalArgumentException {

        List<Integer> validGeometryTypes = new ArrayList(Arrays.asList(

                Geometry.TYPES.LINE,

                Geometry.TYPES.POLYGON,

                Geometry.TYPES.MULTILINE,

                Geometry.TYPES.MULTIPOLYGON

        ));

        return validGeometryTypes.contains(geometry.getType());

    }

    @Override

    public Geometry finish() throws FinishServiceException {

        return null;

    }

    @Override

    public void finishAndStore() throws FinishServiceException {

        Line chamfer; // = null;

        Double distance = (Double) getValue(lengthParameter);

        Double angle = (Double) getValue(angleParameter);

        try {

            EditingProviderServices editingProviderServices = (EditingProviderServices) getProviderServices();

            int subType = editingProviderServices.getSubType(featureStore);

            chamfer = calculateChamfer(

                    this.firstSegmentData, 

                    this.secondSegmentData,

                    (Double) getValue(lengthParameter),

                    Math.toRadians((Double) getValue(angleParameter)), 

                    subType

            );

            if(chamfer == null){

                throw new FinishServiceException("Can't calculate chamfer.", null);

            }

            Feature firstFeature = firstSegmentData.getFeature();

            Feature secondFeature = secondSegmentData.getFeature();

            Boolean doDeleteSecondSelectedGeometry = false;

            if (!Objects.equals(firstFeature.getReference(), secondFeature.getReference())) {

                doDeleteSecondSelectedGeometry = (Boolean) values.get(this.deleteSecondSelectedGeometryParameter);

            }

            EditableFeature editableFeature = firstFeature.getEditable();

            Geometry modifiedGeometry; //= null; //editableFeature.getDefaultGeometry().cloneGeometry();

            GeometryManager geomManager = GeometryLocator.getGeometryManager();

            Geometry firstGeometry = firstSegmentData.getGeometry();

            Primitive firstPrimitive = firstSegmentData.getPrimitive();

            Primitive secondPrimitive = secondSegmentData.getPrimitive();

            if (Objects.equals(firstFeature.getReference(), secondFeature.getReference())) {

                if (firstGeometry instanceof MultiPrimitive) {

                    modifiedGeometry = geomManager.create(firstGeometry.getGeometryType());

                    MultiPrimitive firstMultiPrimitive = (MultiPrimitive) firstGeometry;

                    if (Objects.equals(firstPrimitive, secondPrimitive)) {

                        for (Geometry geometry : firstMultiPrimitive) {

                            Primitive primitive = (Primitive) geometry;

                            if (Objects.equals(firstPrimitive, primitive)) {

                                Primitive modifiedPrimitive = chamferPrimitive(primitive, chamfer);

                                ((MultiPrimitive) modifiedGeometry).addPrimitive(modifiedPrimitive);

                            } else if (Objects.equals(secondPrimitive, primitive)) {

                                //Don't add second primitive

                            } else {

                                ((MultiPrimitive) modifiedGeometry).addPrimitive(primitive);

                            }

                        }

                    } else {

                        Primitive modifiedPrimitive = chamferPrimitives(firstPrimitive, secondPrimitive, chamfer);

                        for (Geometry geometry : firstMultiPrimitive) {

                            Primitive primitive = (Primitive) geometry;

                            if (Objects.equals(firstPrimitive, primitive)) {

                                ((MultiPrimitive) modifiedGeometry).addPrimitive(modifiedPrimitive);

                            } else if (Objects.equals(secondPrimitive, primitive)) {

                                //Don't add second primitive

                            } else {

                                ((MultiPrimitive) modifiedGeometry).addPrimitive(primitive);

                            }

                        }

                    }

                } else {

                    modifiedGeometry = chamferPrimitive((Primitive) editableFeature.getDefaultGeometry(), chamfer);

                }

            } else { // Different features

                doDeleteSecondSelectedGeometry = (Boolean) values.get(this.deleteSecondSelectedGeometryParameter);

                Primitive modifiedPrimitive = chamferPrimitives(firstPrimitive, secondPrimitive, chamfer);

                modifiedGeometry = geomManager.create(firstGeometry.getGeometryType());

                if (firstGeometry instanceof MultiPrimitive) {

                    MultiPrimitive firstMultiPrimitive = (MultiPrimitive) firstGeometry;

                    for (Geometry geometry : firstMultiPrimitive) {

                        Primitive primitive = (Primitive) geometry;

                        if (Objects.equals(firstPrimitive, primitive)) {

                            ((MultiPrimitive) modifiedGeometry).addPrimitive(modifiedPrimitive);

                        } else {

                            ((MultiPrimitive) modifiedGeometry).addPrimitive(primitive);

                        }

                    }

                } else {

                    modifiedGeometry = modifiedPrimitive;

                }

                if (doDeleteSecondSelectedGeometry) {

                    secondFeature.getStore().delete(secondFeature);

                }

            }

            editableFeature.setDefaultGeometry(modifiedGeometry);

            ((EditingProviderServices) getProviderServices())

                    .updateFeatureInFeatureStore(

                            editableFeature, featureStore);

        } catch (Exception e) {

            throw new FinishServiceException(e);

        }

    }

    private Primitive chamferPrimitive(Primitive primitive, Line chamfer) throws IllegalStateException, GeometryException, GeometryOperationException, GeometryOperationNotSupportedException {

        Primitive modifiedPrimitive = (Primitive) (primitive.cloneGeometry());

        if (primitive instanceof Line || primitive instanceof Polygon) {

            modifiedPrimitive = (Primitive) (primitive.cloneGeometry());

        } else if (primitive instanceof Curve) {

            modifiedPrimitive = (Line) primitive.toLines().getPrimitiveAt(0);

        } else if (primitive instanceof Surface) {

            modifiedPrimitive = (Line) primitive.toPolygons().getPrimitiveAt(0);

        }

        if (Objects.equals(firstSegmentData.getIdxVertex(), secondSegmentData.getIdxVertex() - 1)) {

            if (modifiedPrimitive instanceof Line) {

                ((Line) modifiedPrimitive).removeVertex(firstSegmentData.getIdxVertex() + 1);

                int i = 1;

                for (Point point : chamfer) {

                    ((Line) modifiedPrimitive).insertVertex(firstSegmentData.getIdxVertex() + i++, point);

                }

            } else if (modifiedPrimitive instanceof Polygon) {

                ((Polygon) modifiedPrimitive).removeVertex(firstSegmentData.getIdxVertex() + 1);

                int i = 1;

                for (Point point : chamfer) {

                    ((Polygon) modifiedPrimitive).insertVertex(firstSegmentData.getIdxVertex() + i++, point);

                }

            }

        } else if (Objects.equals(firstSegmentData.getIdxVertex(), secondSegmentData.getIdxVertex() + 1)) {

            if (modifiedPrimitive instanceof Line) {

                ((Line) modifiedPrimitive).removeVertex(secondSegmentData.getIdxVertex() + 1);

                Line flipedChamfer = (Line)chamfer.cloneGeometry();

                flipedChamfer.flip();

                int i = 1;

                for (Point point : flipedChamfer) {

                    ((Line) modifiedPrimitive).insertVertex(secondSegmentData.getIdxVertex() + i++, point);

                }

            } else if (modifiedPrimitive instanceof Polygon) {

                ((Polygon) modifiedPrimitive).removeVertex(secondSegmentData.getIdxVertex() + 1);

                Line flipedChamfer = (Line)chamfer.cloneGeometry();

                flipedChamfer.flip();

                int i = 1;

                for (Point point : flipedChamfer) {

                    ((Polygon) modifiedPrimitive).insertVertex(secondSegmentData.getIdxVertex() + i++, point);

                }

            }

        } else if (Objects.equals(this.firstSegmentData.getPosition(), SEGMENT_POSITION_LAST) && Objects.equals(this.secondSegmentData.getPosition(), SEGMENT_POSITION_FIRST)) {

            if (modifiedPrimitive instanceof Line) {

                ((Line) modifiedPrimitive).removeVertex(0);

                ((Line) modifiedPrimitive).removeVertex(((Line) modifiedPrimitive).getNumVertices() - 1);

                for (Point point : chamfer) {

                    ((Line) modifiedPrimitive).addVertex(point); //.insertVertex(secondSegmentData.getIdxVertex() + i++, point);

                }

            } else if (modifiedPrimitive instanceof Polygon) {

                ((Polygon) modifiedPrimitive).removeVertex(0);

                ((Polygon) modifiedPrimitive).removeVertex(((Polygon) modifiedPrimitive).getNumVertices() - 1);

                ((Polygon) modifiedPrimitive).insertVertex(0, chamfer.getVertex(chamfer.getNumVertices()-1));

                for (Point point : chamfer) {

                    ((Polygon) modifiedPrimitive).addVertex(point); //.insertVertex(secondSegmentData.getIdxVertex() + i++, point);

                }

            }

        } else if (Objects.equals(this.firstSegmentData.getPosition(), SEGMENT_POSITION_FIRST) && Objects.equals(this.secondSegmentData.getPosition(), SEGMENT_POSITION_LAST)) {

            Line flipedChamfer = (Line)chamfer.cloneGeometry();

            flipedChamfer.flip();

            if (modifiedPrimitive instanceof Line) {

                ((Line) modifiedPrimitive).removeVertex(0);

                ((Line) modifiedPrimitive).removeVertex(((Line) modifiedPrimitive).getNumVertices() - 1);

                int i = 1;

                for (Point point : flipedChamfer) {

                    ((Line) modifiedPrimitive).addVertex(point); //.insertVertex(firstSegmentData.getIdxVertex() + i++, point);

                }

            } else if (modifiedPrimitive instanceof Polygon) {

                ((Polygon) modifiedPrimitive).removeVertex(0);

                ((Polygon) modifiedPrimitive).removeVertex(((Polygon) modifiedPrimitive).getNumVertices() - 1);

                ((Polygon) modifiedPrimitive).insertVertex(0, flipedChamfer.getVertex(flipedChamfer.getNumVertices()-1));

                for (Point point : flipedChamfer) {

                    ((Polygon) modifiedPrimitive).addVertex(point);//.insertVertex(firstSegmentData.getIdxVertex() + i++, point);

                }

            }

        } else {

            throw new IllegalStateException("Invalid segments");

        }

        return modifiedPrimitive;

    }

    private Primitive chamferPrimitives(Primitive firstPrimitive, Primitive secondPrimitive, Line chamfer) throws IllegalStateException, GeometryException, GeometryOperationNotSupportedException, GeometryOperationException {

        //Cannot be polygons

        if(firstPrimitive == null){

            throw new IllegalArgumentException("firstPrimitive is null");

        }

        Line firstLine;

        if (firstPrimitive instanceof Line) {

            firstLine = (Line) firstPrimitive.cloneGeometry();

        } else {

            MultiLine lines = firstPrimitive.toLines();

            if(lines==null){

                throw new IllegalArgumentException("Can't find first primitive.");

            }

            firstLine = (Line) lines.getPrimitiveAt(0);

        }

        if(secondPrimitive == null){

            throw new IllegalArgumentException("secondPrimitive is null");

        }

        Line secondLine;

        if (secondPrimitive instanceof Line) {

            secondLine = (Line) secondPrimitive;

        } else {

            MultiLine lines = secondPrimitive.toLines();

            if(lines==null){

                throw new IllegalArgumentException("Can't find second primitive.");

            }

            secondLine = (Line) lines.getPrimitiveAt(0);

        }

        Line modifiedPrimitive = firstLine;

        if (Objects.equals(this.firstSegmentData.getPosition(), SEGMENT_POSITION_LAST)) {

            modifiedPrimitive.removeVertex(modifiedPrimitive.getNumVertices() - 1);

            for (Point point : chamfer) {

                modifiedPrimitive.addVertex(point);

            }

            if (Objects.equals(this.secondSegmentData.getPosition(), SEGMENT_POSITION_FIRST)) {

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

                    if (i != 0) {

                        ((Line) modifiedPrimitive).addVertex(secondLine.getVertex(i));

                    }

                }

            } else { //LAST

                for (int i = secondLine.getNumVertices() - 1; i >= 0; i--) {

                    if (i != secondLine.getNumVertices() - 1) {

                        ((Line) modifiedPrimitive).addVertex(secondLine.getVertex(i));

                    }

                }

            }

        } else {

            modifiedPrimitive.removeVertex(0);

            for (Point point : chamfer) {

                modifiedPrimitive.insertVertex(0, point);

            }

            if (Objects.equals(this.secondSegmentData.getPosition(), SEGMENT_POSITION_FIRST)) {

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

                    if (i != 0) {

                        ((Line) modifiedPrimitive).insertVertex(0, secondLine.getVertex(i));

                    }

                }

            } else { //LAST

                for (int i = secondLine.getNumVertices() - 1; i >= 0; i--) {

                    if (i != secondLine.getNumVertices() - 1) {

                        ((Line) modifiedPrimitive).insertVertex(0, secondLine.getVertex(i));

                    }

                }

            }

        }

        return modifiedPrimitive;

    }

    private Pair<Point, Point> calculateOpositeToChamferVertices(SegmentData firstSegmentData, SegmentData secondSegmentData) throws GeometryOperationNotSupportedException, GeometryOperationException {

        Point firstVertex;

        Point secondVertex;

        if (Objects.equals(firstSegmentData.getPrimitive(), secondSegmentData.getPrimitive())) {

            if (Objects.equals(firstSegmentData.getIdxVertex(), secondSegmentData.getIdxVertex() - 1)) {

                firstVertex = firstSegmentData.getLine().getVertex(0);

                secondVertex = secondSegmentData.getLine().getVertex(1);

            } else if (Objects.equals(firstSegmentData.getIdxVertex(), secondSegmentData.getIdxVertex() + 1)) {

                firstVertex = firstSegmentData.getLine().getVertex(1);

                secondVertex = secondSegmentData.getLine().getVertex(0);

            } else {

                if (Objects.equals(firstSegmentData.getPosition(), SEGMENT_POSITION_FIRST)) {

                    firstVertex = firstSegmentData.getLine().getVertex(1);

                } else { //SEGMENT_POSITION_LAST

                    firstVertex = firstSegmentData.getLine().getVertex(0);

                }

                if (Objects.equals(secondSegmentData.getPosition(), SEGMENT_POSITION_FIRST)) {

                    secondVertex = secondSegmentData.getLine().getVertex(1);

                } else { //SEGMENT_POSITION_LAST

                    secondVertex = secondSegmentData.getLine().getVertex(0);

                }

            }

        } else {

            if (Objects.equals(firstSegmentData.getPosition(), SEGMENT_POSITION_FIRST)) {

                firstVertex = firstSegmentData.getLine().getVertex(1);

            } else {

                firstVertex = firstSegmentData.getLine().getVertex(0);

            }

            if (Objects.equals(secondSegmentData.getPosition(), SEGMENT_POSITION_FIRST)) {

                secondVertex = secondSegmentData.getLine().getVertex(1);

            } else {

                secondVertex = secondSegmentData.getLine().getVertex(0);

            }

        }

        return new ImmutablePair<>(firstVertex, secondVertex);

    }

    @Override

    public void start() throws StartServiceException {

        this.values.clear();

        this.firstSegmentData = null;

        this.secondSegmentData = null;

        this.pointToChamfer = null;

        if (savedDistance != null) {

            this.lengthParameter.setDefaultValue(savedDistance);

        }

    }

    @Override

    public void restart() throws StartServiceException, InvalidEntryException, StopServiceException {

        this.values.clear();

        this.firstSegmentData = null;

        this.secondSegmentData = null;

        this.pointToChamfer = null;

        if (savedDistance != null) {

            this.lengthParameter.setDefaultValue(savedDistance);

        }

    }

    @Override

    public void initDefaultValues() {

        super.initDefaultValues();

        if (deleteSecondFeatureDefaultValue != null) {

            this.deleteSecondSelectedGeometryParameter.setDefaultValue(deleteSecondFeatureDefaultValue);

        }

    }

    @Override

    public void stop() throws StopServiceException {

        this.values.clear();

        this.firstSegmentData = null;

        this.secondSegmentData = null;

        this.pointToChamfer = null;

    }

    @Override

    public Object getValue(EditingServiceParameter parameter) {

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

    }

    private Feature getFeatureNearestPoint(Point point) {

        EditingProviderServices editingProviderServices = (EditingProviderServices) getProviderServices();

        Feature feature = editingProviderServices.getFeature(point, featureStore, mapContext);

        return feature;

    }

    private int validateAsSecondSegmentData(SegmentData segmentData, Point oppositeVertex) throws GeometryOperationNotSupportedException, GeometryOperationException {

        if (!segmentData.isFilled()) {

            return ERR_SEGMENT_DATA_NOT_FILLED;

        }

        if (this.firstSegmentData == null) {

            return ERR_FIRST_SEGMENT_DATA_NULL;

        }

        Primitive firstPrimitive = this.firstSegmentData.getPrimitive();

        Primitive secondPrimitive = segmentData.getPrimitive();

        if (Objects.equals(firstPrimitive, secondPrimitive)) {

            if (Objects.equals(this.firstSegmentData.getIdxVertex(), segmentData.getIdxVertex())) {

                return ERR_SAME_SEGMENT;

            }

            if (Math.abs(this.firstSegmentData.getIdxVertex() - segmentData.getIdxVertex()) <= 1) {

                return validateSegmentsAndLength(firstSegmentData, segmentData, calculatePointToChamfer(firstSegmentData, segmentData));

            }

            switch (firstPrimitive.getType()) {

                case Geometry.TYPES.LINE:

                    if (((Line) firstPrimitive).isClosed()) {

                        if ((this.firstSegmentData.getPosition().equals(SEGMENT_POSITION_FIRST) && segmentData.getPosition().equals(SEGMENT_POSITION_LAST)

                                || this.firstSegmentData.getPosition().equals(SEGMENT_POSITION_LAST) && segmentData.getPosition().equals(SEGMENT_POSITION_FIRST))) {

                            return validateSegmentsAndLength(firstSegmentData, segmentData, calculatePointToChamfer(firstSegmentData, segmentData));

                        }

                    } else {

                        if ((this.firstSegmentData.getPosition().equals(SEGMENT_POSITION_FIRST) || this.firstSegmentData.getPosition().equals(SEGMENT_POSITION_LAST))

                                && (segmentData.getPosition().equals(SEGMENT_POSITION_FIRST) || segmentData.getPosition().equals(SEGMENT_POSITION_LAST))) {

                            Point tmpPointToChamfer = calculatePointToChamfer(firstSegmentData, segmentData);

                            if (tmpPointToChamfer == null

                                    || calculateZoneInSegment(tmpPointToChamfer, segmentData) == INVALID_ZONE

                                    || calculateZoneInSegment(tmpPointToChamfer, firstSegmentData) == INVALID_ZONE) {

                                return ERR_CANT_CALCULATE_CHAMFER_POINT;

                            }

                            if (!isPointBetweenTwoPoints(segmentData.getProjectedPoint(), oppositeVertex, tmpPointToChamfer)) {

                                return ERR_CANT_CALCULATE_CHAMFER_POINT;

                            }

                            return validateSegmentsAndLength(firstSegmentData, segmentData, calculatePointToChamfer(firstSegmentData, segmentData));

                        }

                    }

                    return ERR_NON_ADJACENT_SEGMENTS;

                case Geometry.TYPES.POLYGON:

                    if (this.firstSegmentData.getPosition().equals(SEGMENT_POSITION_FIRST) && segmentData.getPosition().equals(SEGMENT_POSITION_LAST)

                            || this.firstSegmentData.getPosition().equals(SEGMENT_POSITION_LAST) && segmentData.getPosition().equals(SEGMENT_POSITION_FIRST)) {

                        return validateSegmentsAndLength(firstSegmentData, segmentData, calculatePointToChamfer(firstSegmentData, segmentData));

                    }

                    return ERR_NON_ADJACENT_SEGMENTS;

                default:

                    return ERR_NON_ADJACENT_SEGMENTS;

            }

        } else {

            if (firstPrimitive.getType() != Geometry.TYPES.LINE

                    || secondPrimitive.getType() != Geometry.TYPES.LINE) {

                return ERR_DIFFERENT_GEOMETRY_TYPES;

            }

            if (this.firstSegmentData.getPosition().equals(SEGMENT_POSITION_MIDDLE)

                    || segmentData.getPosition().equals(SEGMENT_POSITION_MIDDLE)) {

                return ERR_ONE_OF_THE_TWO_SEGMENTS_ISNT_EXTREME;

            }

            Point tmpPointToChamfer = calculatePointToChamfer(firstSegmentData, segmentData);

            if (tmpPointToChamfer == null || !isPointBetweenTwoPoints(segmentData.getProjectedPoint(), oppositeVertex, tmpPointToChamfer)) {

                return ERR_CANT_CALCULATE_CHAMFER_POINT;

            }

            return validateSegmentsAndLength(firstSegmentData, segmentData, tmpPointToChamfer);

        }

    }

    private int validateSegmentsAndLength(SegmentData firstSegmentData, SegmentData secondSegmentData, Point pointToChamfer) throws GeometryOperationNotSupportedException, GeometryOperationException {

        Pair<Point, Point> oppositeVertices = calculateOpositeToChamferVertices(firstSegmentData, secondSegmentData);

        Double length = (Double) getValue(lengthParameter);

        double maxLength = Math.max(

                oppositeVertices.getLeft().distance(pointToChamfer),

                Math.max(

                        oppositeVertices.getRight().distance(pointToChamfer),

                        oppositeVertices.getRight().distance(oppositeVertices.getLeft())

                )

        );

        if (length > maxLength) {

            return ERR_CHAMFER_TOO_LARGE;

        }

        return ERR_OK;

    }

    private Point calculatePointToChamfer(SegmentData firstSegmentData, SegmentData secondSegmentData) throws GeometryOperationNotSupportedException, GeometryOperationException {

        Primitive firstPrimitive = firstSegmentData.getPrimitive();

        Primitive secondPrimitive = secondSegmentData.getPrimitive();

        if (Objects.equals(firstPrimitive, secondPrimitive)) {

            if (Objects.equals(firstSegmentData.getIdxVertex(), secondSegmentData.getIdxVertex())) {

                return null;

            }

            switch (firstPrimitive.getType()) {

                case Geometry.TYPES.LINE:

                    if (((Line) firstPrimitive).isClosed()) {

                        if (Objects.equals(firstSegmentData.getIdxVertex(), secondSegmentData.getIdxVertex() - 1)) {

                            return firstSegmentData.getLine().getVertex(1);

                        } else if (Objects.equals(firstSegmentData.getIdxVertex(), secondSegmentData.getIdxVertex() + 1)) {

                            return firstSegmentData.getLine().getVertex(0);

                        } else if (firstSegmentData.getPosition().equals(SEGMENT_POSITION_FIRST) && secondSegmentData.getPosition().equals(SEGMENT_POSITION_LAST)) {

                            return firstSegmentData.getLine().getVertex(0);

                        } else if (firstSegmentData.getPosition().equals(SEGMENT_POSITION_LAST) && secondSegmentData.getPosition().equals(SEGMENT_POSITION_FIRST)) {

                            return firstSegmentData.getLine().getVertex(1);

                        } else {

                            return null;

                        }

                    } else {

                        if (Objects.equals(firstSegmentData.getIdxVertex(), secondSegmentData.getIdxVertex() - 1)) {

                            return firstSegmentData.getLine().getVertex(1);

                        } else if (Objects.equals(firstSegmentData.getIdxVertex(), secondSegmentData.getIdxVertex() + 1)) {

                            return firstSegmentData.getLine().getVertex(0);

                        } else if (firstSegmentData.getPosition().equals(SEGMENT_POSITION_FIRST) && secondSegmentData.getPosition().equals(SEGMENT_POSITION_LAST)

                                || firstSegmentData.getPosition().equals(SEGMENT_POSITION_LAST) && secondSegmentData.getPosition().equals(SEGMENT_POSITION_FIRST)) {

                            return calculatePointToChamferSeparateSegments(firstSegmentData, secondSegmentData);

                        } else {

                            return null;

                        }

                    }

                case Geometry.TYPES.POLYGON:

                    if (Objects.equals(firstSegmentData.getIdxVertex(), secondSegmentData.getIdxVertex() - 1)) {

                        return firstSegmentData.getLine().getVertex(1);

                    } else if (Objects.equals(firstSegmentData.getIdxVertex(), secondSegmentData.getIdxVertex() + 1)) {

                        return firstSegmentData.getLine().getVertex(0);

                    } else if (firstSegmentData.getPosition().equals(SEGMENT_POSITION_FIRST) && secondSegmentData.getPosition().equals(SEGMENT_POSITION_LAST)) {

                        return firstSegmentData.getLine().getVertex(0);

                    } else if (firstSegmentData.getPosition().equals(SEGMENT_POSITION_LAST) && secondSegmentData.getPosition().equals(SEGMENT_POSITION_FIRST)) {

                        return firstSegmentData.getLine().getVertex(1);

                    } else {

                        return null;

                    }

                default:

                    return null;

            }

        } else {

            if (firstPrimitive.getType() != Geometry.TYPES.LINE) {

                return null;

            }

            if (secondPrimitive.getType() != Geometry.TYPES.LINE) {

                return null;

            }

            if ((firstSegmentData.getPosition().equals(SEGMENT_POSITION_FIRST) || firstSegmentData.getPosition().equals(SEGMENT_POSITION_LAST))

                    && (secondSegmentData.getPosition().equals(SEGMENT_POSITION_FIRST) || secondSegmentData.getPosition().equals(SEGMENT_POSITION_LAST))) {

                return calculatePointToChamferSeparateSegments(firstSegmentData, secondSegmentData);

            } else {

                return null;

            }

        }

    }

    private Point calculatePointToChamferSeparateSegments(SegmentData firstSegmentData, SegmentData secondSegmentData) throws GeometryOperationNotSupportedException, GeometryOperationException {

        EuclideanManager euclideanManager = ToolsUtilLocator.getEuclideanManager();

        EuclideanLine2D firstLine = euclideanManager.createLine2D(

                firstSegmentData.getLine().getVertex(0).getX(),

                firstSegmentData.getLine().getVertex(0).getY(),

                firstSegmentData.getLine().getVertex(1).getX(),

                firstSegmentData.getLine().getVertex(1).getY());

        EuclideanLine2D secondLine = euclideanManager.createLine2D(

                secondSegmentData.getLine().getVertex(0).getX(),

                secondSegmentData.getLine().getVertex(0).getY(),

                secondSegmentData.getLine().getVertex(1).getX(),

                secondSegmentData.getLine().getVertex(1).getY());

        Point2D intersection = firstLine.getIntersection(secondLine);

        Point intersectionPoint = GeometryUtils.createPoint(intersection.getX(), intersection.getY());

        if (intersectionPoint == null) {

            return null; //throw new IllegalArgumentException("Not valid segments.");

        }

        if (firstSegmentData.getPosition().equals(SEGMENT_POSITION_LAST)

                && calculateZoneInSegment(intersectionPoint, firstSegmentData) == INVALID_ZONE) {

            return null;

        }

        if (firstSegmentData.getPosition().equals(SEGMENT_POSITION_FIRST)

                && calculateZoneInSegment(intersectionPoint, firstSegmentData) == INVALID_ZONE) {

            return null;

        }

        if (secondSegmentData.getPosition().equals(SEGMENT_POSITION_LAST)

                && calculateZoneInSegment(intersectionPoint, firstSegmentData) == INVALID_ZONE) {

            return null;

        }

        if (secondSegmentData.getPosition().equals(SEGMENT_POSITION_FIRST)

                && calculateZoneInSegment(intersectionPoint, firstSegmentData) == INVALID_ZONE) {

            return null;

        }

        return intersectionPoint;

    }

    private int calculateZoneInSegment(Point point, SegmentData segmentData) throws GeometryOperationNotSupportedException, GeometryOperationException {

        //We assume that the point is on the line to which the segment belongs.

        Line line = segmentData.getLine();

        if (line.getNumVertices() > 2) {

            throw new IllegalArgumentException("Segment has more than two vertex.");

        }

        Point firstVertex;

        Point secondVertex;

        if (Objects.equals(segmentData.getPosition(), SEGMENT_POSITION_LAST)) {

            firstVertex = line.getVertex(0);

            secondVertex = line.getVertex(1);

        } else { // SEGMENT_POSITION_FIRST,  SEGMENT_POSITION_MIDDLE doesn't matter

            firstVertex = line.getVertex(1);

            secondVertex = line.getVertex(0);

        }

        double segmentLenght = firstVertex.distance(secondVertex);

        if (segmentLenght >= firstVertex.distance(point) && segmentLenght >= secondVertex.distance(point)) {

            return INSIDE_THE_SEGMENT; //0

        } else if (firstVertex.distance(point) > secondVertex.distance(point)) {

            return BEYOND_THE_SEGMENT; //1

        } else {

            return INVALID_ZONE; //-1

        }

    }

    private boolean isPointBetweenTwoPoints(Point point, Point vertex1, Point vertex2) {

        //The three points must be aligned

        if (point.getX() < vertex1.getX() && point.getX() < vertex2.getX()) {

            return false;

        }

        if (point.getX() > vertex1.getX() && point.getX() > vertex2.getX()) {

            return false;

        }

        if (point.getY() < vertex1.getY() && point.getY() < vertex2.getY()) {

            return false;

        }

        if (point.getY() > vertex1.getY() && point.getY() > vertex2.getY()) {

            return false;

        }

        return true;

    }

    private double calculateDefaultAngle(Point pointToChamfer, Pair<Point, Point> oppositeVertices) throws GeometryOperationNotSupportedException, GeometryOperationException, CreateGeometryException {

        EuclideanManager euclideanManager = ToolsUtilLocator.getEuclideanManager();

        Point2D p = euclideanManager.getPointAtDistance(

                pointToChamfer.getX(),

                pointToChamfer.getY(),

                pointToChamfer.distance(oppositeVertices.getLeft()),

                GeometryUtils.calculateAngle(pointToChamfer, oppositeVertices.getRight()), 

                null

        );

        Point midPoint = GeometryUtils.getMidPoint(

                oppositeVertices.getLeft(),

                GeometryUtils.createPoint(p.getX(), p.getY()), 

                pointToChamfer.getGeometryType().getSubType()

        );

        double angle = GeometryUtils.calculateAngle(

                pointToChamfer,

                midPoint

        );

        angle = angle + Math.PI/2;

        if(angle > 2*Math.PI){

            angle = angle - 2*Math.PI;

        }

        return Math.toDegrees(angle);

    }

    private Line calculateChamfer(SegmentData firstSegmentData, SegmentData secondSegmentData, Double length, Double angle, int subType) throws GeometryOperationNotSupportedException, GeometryOperationException, CreateGeometryException {

        ScaffoldingToChamfer scaffolding = calculateScaffolding(firstSegmentData, secondSegmentData, pointToChamfer, length, angle, subType);

        if(scaffolding == null){

            return null;

        }

        Line chamfer;

        if(scaffolding.isReversed()) {

            chamfer = GeometryUtils.createLine(

                    scaffolding.chamferRight.getX(),

                    scaffolding.chamferRight.getY(),

                    scaffolding.chamferLeft.getX(),

                    scaffolding.chamferLeft.getY(),

                    subType

            );

        } else {

            chamfer = GeometryUtils.createLine(

                    scaffolding.chamferLeft.getX(),

                    scaffolding.chamferLeft.getY(),

                    scaffolding.chamferRight.getX(),

                    scaffolding.chamferRight.getY(), 

                    subType

            );

        }

        return chamfer;

    }

    /**

     * 

     * @param firstSegmentData

     * @param secondSegmentData

     * @param pointToChamfer

     * @param distance

     * @param angle must be in radians