Application: gvSIG desktop » gvSIG Linear Reference System

        if(params instanceof LrsCalibrateRouteAlgorithmParams){

            return new LrsCalibrateRouteAlgorithm((LrsCalibrateRouteAlgorithmParams)params);

        }

        if(params instanceof LrsGenerateDynamicSegmentationAlgorithmParams){

            return new LrsGenerateDynamicSegmentationAlgorithm((LrsGenerateDynamicSegmentationAlgorithmParams)params);

        }

/* 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.lrs.lib.impl;

import java.awt.Dimension;

import java.awt.geom.Point2D;

import java.io.File;

import java.sql.Array;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Comparator;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import javax.xml.transform.Source;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.mutable.MutableDouble;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.store.shp.SHPNewStoreParameters;

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.fmap.geom.GeometryException;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

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

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

import org.gvsig.lrs.lib.api.LrsAlgorithm;

import org.gvsig.lrs.lib.api.LrsAlgorithmParams;

import org.gvsig.lrs.lib.api.LrsCoordinatesPriority;

import org.gvsig.lrs.lib.api.LrsCreateRouteAlgorithmParams;

import org.gvsig.lrs.lib.api.LrsGenerateDynamicSegmentationAlgorithmParams;

import org.gvsig.lrs.lib.api.LrsSourceOfMeasures;

import org.gvsig.lrs.lib.api.exceptions.LrsCreateRouteException;

import org.gvsig.lrs.lib.api.exceptions.LrsException;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.service.Manager;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * @author fdiaz

 *

 */

public class LrsGenerateDynamicSegmentationAlgorithm implements LrsAlgorithm {

    private static final Logger logger = LoggerFactory.getLogger(LrsGenerateDynamicSegmentationAlgorithm.class);

    private LrsGenerateDynamicSegmentationAlgorithmParams parameters;

    /**

     *

     */

    public LrsGenerateDynamicSegmentationAlgorithm(LrsGenerateDynamicSegmentationAlgorithmParams parameters) {

        this.parameters = parameters;

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.tools.service.Service#getManager()

     */

    public Manager getManager() {

        return null;

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.lrs.lib.api.LrsAlgorithm#getParams()

     */

    public  LrsAlgorithmParams getParams() {

        return this.parameters;

    }

    /*

     * (non-Javadoc)

     * @see org.gvsig.lrs.lib.api.LrsAlgorithm#execute(org.gvsig.tools.task.SimpleTaskStatus)

     */

    public void execute(final SimpleTaskStatus taskStatus) throws LrsException {

        NewFeatureStoreParameters newFeatureStoreParameters = parameters.getNewFeatureStoreParameters();

        final FeatureStore sourceFeatureStore = parameters.getSourceFeatureStore();

        final FeatureAttributeDescriptor idRouteField = parameters.getIdRouteField();

        final FeatureAttributeDescriptor idTableRouteField = parameters.getValueTableIdRouteField();

        FeatureStore tableFeatureStore = parameters.getValueTableFeatureStore();

        final FeatureAttributeDescriptor landmarkField = parameters.getLandmarkField();

        final FeatureAttributeDescriptor finalLandmarkField = parameters.getFinalLandmarkField();

        final FeatureAttributeDescriptor valueField = parameters.getValueField();

        logger.info(parameters.toString());

        taskStatus.setTitle(parameters.getName());

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        taskStatus.message(i18nManager.getTranslation("processing"));

        try {

            final String routeFieldName=idRouteField.getName();

            final String tableRouteFieldName=idTableRouteField.getName();

            final String fromFieldName;

            final DataType fromDataType;

            final String toFieldName;

            final DataType toDataType;

            final int geomType;

            if (landmarkField!=null){

                fromDataType=landmarkField.getDataType();

                if (finalLandmarkField!=null){

                    fromFieldName="PK INICIAL";

                    toFieldName="PK FINAL";

                    toDataType=finalLandmarkField.getDataType();

                    geomType = Geometry.TYPES.MULTILINE;

                }else{

                    fromFieldName="PK";

                    toFieldName=null;

                    toDataType=null;

                    geomType = Geometry.TYPES.POINT;

                }

            }else{

                //TODO: Si no hay fromFieldName ?salir por patas?

                fromFieldName=null;

                fromDataType=null;

                toFieldName=null;

                toDataType=null;

                geomType = Geometry.TYPES.POINT;

            }

            final FeatureStore newFeatureStore = createNewDataStore(

                newFeatureStoreParameters,

                idRouteField,

                fromFieldName,

                toFieldName,

                valueField,

                geomType

             );

            FeatureSet tableFeatures;

            tableFeatures=tableFeatureStore.getFeatureSet();

            GeometryManager geomManager = GeometryLocator.getGeometryManager();

            taskStatus.setRangeOfValues(0, tableFeatures.getSize()-1);

            newFeatureStore.edit(FeatureStore.MODE_FULLEDIT);

            tableFeatures.accept(new Visitor() {

                int taskCount=0;

                public void visit(Object obj) throws VisitCanceledException, BaseException {

                    Feature feature = (Feature) obj;

                    String routeName = (String) feature.get(tableRouteFieldName);

                    Object objFrom = null;

                    Object objTo = null;

                    if (fromFieldName != null) {

                        objFrom = feature.get(landmarkField.getName());

                        double fromValue = LrsAlgorithmUtils.getAsDouble(objFrom, fromDataType);

                        Object value = feature.get(valueField.getName());

                        if (toFieldName == null || toFieldName.isEmpty()) {

                            addSegmentatePointsFeatures(newFeatureStore, sourceFeatureStore, idRouteField, routeName, fromFieldName, fromValue, valueField, value);

                        } else {

                            objTo = feature.get(finalLandmarkField.getName());

                            double toValue = LrsAlgorithmUtils.getAsDouble(objTo, toDataType);

                            addSegmentateLinesFeatures(newFeatureStore, sourceFeatureStore, idRouteField, routeName,

                                fromFieldName, fromValue, toFieldName, toValue, valueField, value);

                        }

                    } else {

                        //TODO: ?Exception?

                    }

                    taskStatus.setCurValue(taskCount++);

                }

                private void addSegmentatePointsFeatures(final FeatureStore featureStore,

                    FeatureStore sourceFeatureStore, final FeatureAttributeDescriptor idRouteField,

                    final String routeName, final String fromFieldName, final double fromValue, final FeatureAttributeDescriptor valueField, final Object value)

                    throws LocatorException, BaseException {

                    DataManager dataManager = DALLocator.getDataManager();

                    FeatureQuery query = sourceFeatureStore.createFeatureQuery();

                    String expression = StringUtils.replace(StringUtils.replace("NOMBRE like 'a%'", "NOMBRE", idRouteField.getName()), "a%", routeName);

                    query.setFilter( dataManager.createExpresion(expression) );

                    FeatureSet features = sourceFeatureStore.getFeatureSet(query);

                    features.accept(new Visitor() {

                        public void visit(Object obj) throws VisitCanceledException, BaseException {

                            Feature feature = (Feature)obj;

                            Geometry geom = feature.getDefaultGeometry();

                            List<Point>points = LrsAlgorithmUtils.getPointsWithM(geom, fromValue);

                            for (Iterator<Point> iterator = points.iterator(); iterator.hasNext();) {

                                Point point = (Point) iterator.next();

                                EditableFeature newFeature = featureStore.createNewFeature(true);

                                newFeature.set(idRouteField.getName(), routeName);

                                newFeature.set(fromFieldName, fromValue);

                                newFeature.set(valueField.getName(), value);

                                newFeature.setDefaultGeometry(point);

                                featureStore.insert(newFeature);

                            }

                        }

                    });

                }

                private void addSegmentateLinesFeatures(final FeatureStore featureStore,

                    FeatureStore sourceFeatureStore, final FeatureAttributeDescriptor idRouteField,

                    final String routeName, final String fromFieldName, final double fromValue,

                    final String toFieldName, final double toValue, final FeatureAttributeDescriptor valueField, final Object value) throws LocatorException, BaseException {

                    DataManager dataManager = DALLocator.getDataManager();

                    FeatureQuery query = sourceFeatureStore.createFeatureQuery();

                    String expression = StringUtils.replace(StringUtils.replace("NOMBRE like 'a%'", "NOMBRE", idRouteField.getName()), "a%", routeName);

                    query.setFilter( dataManager.createExpresion(expression) );

                    FeatureSet features = sourceFeatureStore.getFeatureSet(query);

                    features.accept(new Visitor() {

                        public void visit(Object obj) throws VisitCanceledException, BaseException {

                            Feature feature = (Feature) obj;

                            Geometry geom = feature.getDefaultGeometry();

                            MultiLine lines = LrsAlgorithmUtils.getLinesBetweenTwoM(geom, fromValue, toValue);

                            if (lines != null && lines.getPrimitivesNumber()>0) {

                                EditableFeature newFeature = featureStore.createNewFeature(true);

                                newFeature.set(idRouteField.getName(), routeName);

                                newFeature.set(fromFieldName, fromValue);

                                newFeature.set(toFieldName, toValue);

                                newFeature.set(valueField.getName(), value);

                                newFeature.setDefaultGeometry(lines);

                                featureStore.insert(newFeature);

                            }

                        }

                    });

                }

            });

            newFeatureStore.finishEditing();

        } catch (Exception e1) {

            taskStatus.abort();

            throw new LrsCreateRouteException("Error creating routes", e1);

        }

        taskStatus.terminate();

    }

    /* (non-Javadoc)

     * @see org.gvsig.lrs.lib.api.LrsAlgorithm#setParams(org.gvsig.lrs.lib.api.LrsAlgorithmParams)

     */

    public void setParams(LrsAlgorithmParams params) throws IllegalArgumentException {

        if(!(params instanceof LrsCreateRouteAlgorithmParams)){

            throw new IllegalArgumentException("params should be LrsCreateRouteAlgorithmParams type.");

        }

        // TODO Auto-generated method stub

    }

    private FeatureStore createNewDataStore(

        NewFeatureStoreParameters newFeatureStoreParameters,

        FeatureAttributeDescriptor idRouteField,

        String fromFieldName,

        String toFieldName,

        FeatureAttributeDescriptor valueField,

        int type) throws Exception{

        try {

            SHPNewStoreParameters shapeStoreParams = (SHPNewStoreParameters)newFeatureStoreParameters;

            File file=shapeStoreParams.getFile();

            String filePath=file.getPath().substring(0, file.getPath().lastIndexOf(File.separator));

            DataManager dataManager = DALLocator.getDataManager();

            DataServerExplorerParameters serverParams =

                dataManager.createServerExplorerParameters("FilesystemExplorer");

            serverParams.setDynValue("initialpath", filePath);

            DataServerExplorer serverExplorer =

                dataManager.openServerExplorer(serverParams.getExplorerName(), serverParams);

            EditableFeatureType featureType = (EditableFeatureType)shapeStoreParams.getDefaultFeatureType();

            featureType.add(idRouteField.getName(), idRouteField.getType(), idRouteField.getSize());

            featureType.add(fromFieldName, DataTypes.DOUBLE);

            if(toFieldName!=null){

                featureType.add(toFieldName, DataTypes.DOUBLE);

            }

            featureType.add(valueField.getName(), valueField.getType(), valueField.getSize());

            EditableFeatureAttributeDescriptor geometryField = featureType.add("Geometry", DataTypes.GEOMETRY);

            GeometryType geometryType = GeometryLocator.getGeometryManager().getGeometryType(type, Geometry.SUBTYPES.GEOM2DM);

            geometryField.setGeometryType(geometryType);

            featureType.setDefaultGeometryAttributeName("Geometry");

            shapeStoreParams.setDefaultFeatureType(featureType);

            serverExplorer.add("Shape", shapeStoreParams, true);

            DataStore store = dataManager.createStore(shapeStoreParams);

            return (FeatureStore)store;

        } catch (Exception e) {

            throw new LrsCreateRouteException("Error creating new dataStore", e);

        }

    }

}

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import javax.swing.text.html.HTMLDocument.HTMLReader.IsindexAction;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

import org.gvsig.tools.locator.LocatorException;

    static protected FeatureStore createNewDataStore(NewFeatureStoreParameters newFeatureStoreParameters,

        FeatureAttributeDescriptor idRouteField) throws Exception {

        return createNewDataStore(newFeatureStoreParameters, idRouteField, Geometry.TYPES.MULTILINE);

    }

    static protected FeatureStore createNewDataStore(NewFeatureStoreParameters newFeatureStoreParameters,

        FeatureAttributeDescriptor idRouteField, int type) throws Exception {

            SHPNewStoreParameters shapeStoreParams = (SHPNewStoreParameters) newFeatureStoreParameters;

            File file = shapeStoreParams.getFile();

            String filePath = file.getPath().substring(0, file.getPath().lastIndexOf(File.separator));

            EditableFeatureType featureType = (EditableFeatureType) shapeStoreParams.getDefaultFeatureType();

            GeometryType geometryType =

                GeometryLocator.getGeometryManager().getGeometryType(type, Geometry.SUBTYPES.GEOM2DM);

            return (FeatureStore) store;

    static protected Double getAsDouble(Object obj, DataType dataType) {

        if (obj == null || dataType == null) {

            return null;

        Double result = Double.NaN;

        if (dataType.equals(DataTypes.DOUBLE)) {

            result = (Double) obj;

        } else if (dataType.isNumeric()) {

            result = Double.valueOf(String.valueOf(obj));

        }

    static List<Point> getPointsWithM(Geometry geom, double m) throws CreateGeometryException, LocatorException {

        List<Point> points = new ArrayList<Point>();

        if (geom instanceof Line) {

            Line line = (Line) geom;

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

                Point point = getPointWithMBetweenTwoMPoints(m, line.getVertex(i), line.getVertex(i + 1));

                if (point != null) {

                    points.add(point);

                }

            }

        } else if (geom instanceof MultiLine) {

            MultiLine multiLine = (MultiLine) geom;

            for (int p = 0; p < multiLine.getPrimitivesNumber(); p++) {

                Line line = (Line) multiLine.getPrimitiveAt(p);

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

                    Point point = getPointWithMBetweenTwoMPoints(m, line.getVertex(i), line.getVertex(i + 1));

                    if (point != null) {

                        points.add(point);

                    }

                }

            }

        }

        return points;

    }

    private static boolean isInRange(double v, double r1, double r2) {

        if (r1 < r2) {

            return v >= r1 && v <= r2;

        } else if (r1 > r2) {

            return v >= r2 && v <= r1;

        } else {

            return v == r1;

        }

    }

    static MultiLine getLinesBetweenTwoM(Geometry geom, double m1, double m2) throws CreateGeometryException,

        LocatorException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        MultiLine lines = null;

        if (geom instanceof Line) {

            lines = getLinesBetweenTwoM((Line) geom, m1, m2);

        } else if (geom instanceof MultiLine) {

            lines = (MultiLine) geomManager.create(Geometry.TYPES.MULTILINE, geom.getGeometryType().getSubType());

            MultiLine multiLine = (MultiLine) geom;

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

                MultiLine auxMultiLine = getLinesBetweenTwoM(multiLine.getPrimitiveAt(i), m1, m2);

                for (int j = 0; j < auxMultiLine.getPrimitivesNumber(); j++) {

                    lines.addPrimitive(auxMultiLine.getPrimitiveAt(j));

                }

            }

        }

        return lines;

    }

    static private MultiLine getLinesBetweenTwoM(Line line, double m1, double m2) throws CreateGeometryException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        MultiLine lines = (MultiLine) geomManager.create(Geometry.TYPES.MULTILINE, line.getGeometryType().getSubType());

        Line auxLine = (Line) geomManager.create(Geometry.TYPES.LINE, line.getGeometryType().getSubType());

        boolean inSegment = false;

        if (line.getNumVertices() > 0) {

            int ivertex = 0;

            Point previousVertex = null;

            while (ivertex < line.getNumVertices()) {

                if (!inSegment) { // NO ESTAMOS EN UN SEGMENTO VALIDO

                    Point vertex = line.getVertex(ivertex);

                    double m = vertex.getCoordinateAt(vertex.getDimension() - 1);

                    if (isInRange(m, m1, m2)) {

                        // Si la m del vertice actual entra en el rango:

                        if (previousVertex == null) {

                            // Si no hay previousVertex, este debe ser el primer

                            // vertice, entonces

                            // - a?adimos el v?rtice a la linea

                            // - marcamos que estamos en un segmento valido

                            // - nos guardamos el vertice como previousVertex

                            // - aumentamos el indice para coger el siguiente

                            // v?rtice en la pr?xima iteraci?n

                            auxLine.addVertex(vertex);

                            previousVertex = vertex;

                            inSegment = true;

                            ivertex++;

                        } else {

                            // - Calculamos qu? punto habr?a iniciado el

                            // segmento v?lido

                            double previousM = previousVertex.getCoordinateAt(previousVertex.getDimension() - 1);

                            // FIXME: Esta comprobaci?n se podr?a quitar

                            if (isInRange(m1, previousM, m) || isInRange(m2, previousM, m)) {

                                Point point = getPointWithMBetweenTwoMPoints(m1, previousVertex, vertex);

                                if (point == null) {

                                    point = getPointWithMBetweenTwoMPoints(m2, previousVertex, vertex);

                                }

                                if (point != null) {

                                    // - A?adimos el punto a la linea auxiliar

                                    // - Marcamos que estamos en un segmento v?lido

                                    // - nos guardamos el punto como previousVertex

                                    // - y NO aumentamos el indice

                                    auxLine.addVertex(point);

                                    inSegment = true;

                                    previousVertex = point;

                                } else {

                                    // Nunca deber?a pasar por aqu?

                                }

                            }

                        }

                    } else {

                        // Cabe la posibilidad de que entre un vertice y otro se

                        // entre y se salga del rango

                        if (previousVertex != null) {

                            double previousM = previousVertex.getCoordinateAt(previousVertex.getDimension() - 1);

                            if (isInRange(m1, previousM, m) && isInRange(m2, previousM, m)) {

                                Point point1 = getPointWithMBetweenTwoMPoints(m1, previousVertex, vertex);

                                Point point2 = getPointWithMBetweenTwoMPoints(m2, previousVertex, vertex);

                                auxLine.addVertex(point1);

                                auxLine.addVertex(point2);

                                lines.addPrimitive(auxLine);

                            }

                        }

                        // Si la m del v?rtice actual no entra en el rango:

                        // - nos guardamos el vertice como previousVertex

                        // - aumentamos el indice para coger el siguiente

                        // v?rtice en la pr?xima iteraci?n

                        previousVertex = vertex;

                        ivertex++;

                    }

                } else { // ESTAMOS EN UN SEGMENTO VALIDO

                    Point vertex = line.getVertex(ivertex);

                    double m = vertex.getCoordinateAt(previousVertex.getDimension() - 1);

                    if (isInRange(m, m1, m2)) {

                        // Si la m del vertice actual entra en el rango:

                        // - a?adimos el v?rtice a la linea

                        // - aumentamos el indice para coger el siguiente

                        // v?rtice en la pr?xima iteraci?n

                        auxLine.addVertex(vertex);

                        previousVertex = vertex;

                        ivertex++;

                    } else {

                        // Si la m del v?rtice actual no entra en el rango:

                        // - Calculamos el punto que habr?a finalizado el

                        // segmento v?lido entre el vertice anterior y el actual

                        Point point = getPointWithMBetweenTwoMPoints(m1, previousVertex, vertex);

                        if (point == null) {

                            point = getPointWithMBetweenTwoMPoints(m2, previousVertex, vertex);

                        }

                        if (point != null) {

                            // - A?adimos el punto a la linea auxiliar

                            // - a?adimos la linea y creamos una nueva

                            // - Marcamos que NO estamos en un segmento v?lido

                            // - nos guardamos el punto como previousVertex

                            // - y NO aumentamos el indice

                            auxLine.addVertex(point);

                            lines.addPrimitive(auxLine);

                            auxLine =

                                (Line) geomManager.create(Geometry.TYPES.LINE, line.getGeometryType().getSubType());

                            inSegment = false;

                            previousVertex = point;

                        } else {

                            // Nunca deber?a pasar por aqu?

                        }

                    }

                }

            }

        }

        if (inSegment && auxLine.getNumVertices() > 0) {

            lines.addPrimitive(auxLine);

        }

        return lines;

    }

    /*

     *

     */

    private static Point getPointWithMBetweenTwoMPoints(double m, Point p1, Point p2) throws CreateGeometryException,

        LocatorException {

        double x;

        double y;

        double m1 = p1.getCoordinateAt(p1.getDimension() - 1);

        double m2 = p2.getCoordinateAt(p2.getDimension() - 1);

        if (m1 <= m2) {

            if (m < m1 || m > m2) {

                return null;

            }

        } else {

            if (m < m2 || m > m1) {

                return null;

            }

        }

        double x1 = p1.getX();

        double x2 = p2.getX();

        double y1 = p1.getY();

        double y2 = p2.getY();

        if (x1 == x2) {

            x = x1;

        } else {

            x = ((x2 - x1) * (m - m1) / (m2 - m1)) + x1;

        }

        if (y1 == y2) {

            y = y1;

        } else {

            y = ((y2 - y1) * (m - m1) / (m2 - m1)) + y1;

        }

        Point point = (Point) GeometryLocator.getGeometryManager().create(p1.getGeometryType());

        point.setX(x);

        point.setY(y);

        point.setCoordinateAt(point.getDimension() - 1, m);

        return point;

    }

        if (value == null) {

            renderer.setText("");

        }

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

    /**

     *

     */

    private static final long serialVersionUID = -5764089056918981236L;

        // listener del combo de capas para que actualice el resto de componentes

                    clearTableFields();

        FLyrVect fLyrVect = (FLyrVect) this.cmbInputLayer.getSelectedItem();

        if (this.cmbFinalLandmarkField.getSelectedItem()!=null && !(this.cmbFinalLandmarkField.getSelectedItem() instanceof FeatureAttributeDescriptor)){

        if (this.cmbIdRouteField.getItemCount() > 0) {

            this.cmbIdRouteField.setSelectedIndex(0);

        }

        clearTableFields();

    /**

     *

     */

    private void clearTableFields() {

        logger.info(String.valueOf(this.cmbTableIdRouteField.getItemCount()));

        if (this.cmbTableIdRouteField.getItemCount() > 0) {

            this.cmbTableIdRouteField.setSelectedIndex(0);

        }

        logger.info(String.valueOf(this.cmbLandmarkField.getItemCount()));

        if (this.cmbLandmarkField.getItemCount() > 0) {

            this.cmbLandmarkField.setSelectedIndex(0);

        }

        logger.info(String.valueOf(this.cmbFinalLandmarkField.getItemCount()));

        this.cmbFinalLandmarkField.setSelectedIndex(-1);

        logger.info(String.valueOf(this.cmbValueField.getItemCount()));

        if (this.cmbValueField.getItemCount() > 0) {

            this.cmbValueField.setSelectedIndex(0);

        }

        this.cmbTableIdRouteField.repaint();

        this.cmbLandmarkField.repaint();

        this.cmbFinalLandmarkField.repaint();

        this.cmbValueField.repaint();

    }

            // Renderer para los combos de attributeDescriptors

            ListCellRenderer featureAttributeDescriptorCellRenderer =

                new FLayersAttributeDescriptorCellRenderer();

            // asignaci?n de renderers

            cmbTableIdRouteField

                .setRenderer(featureAttributeDescriptorCellRenderer);

            cmbLandmarkField.setRenderer(featureAttributeDescriptorCellRenderer);

            cmbFinalLandmarkField

                .setRenderer(featureAttributeDescriptorCellRenderer);

            cmbValueField.setRenderer(featureAttributeDescriptorCellRenderer);

            this.cmbFinalLandmarkField.insertItemAt(null,0);

            FeatureAttributeDescriptor[] attributeDescriptors = type.getAttributeDescriptors();

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

                if (featureAttributeDescriptor.getDataType().getType() != DataTypes.GEOMETRY) {

                    logger.info(new StringBuilder().append("0 - Adding field ")

                    JLrsGenerateDynamicSegmentationParamsController.this.cmbTableIdRouteField.addItem(featureAttributeDescriptor);

                    JLrsGenerateDynamicSegmentationParamsController.this.cmbValueField.addItem(featureAttributeDescriptor);

                        JLrsGenerateDynamicSegmentationParamsController.this.cmbLandmarkField.addItem(featureAttributeDescriptor);

                        JLrsGenerateDynamicSegmentationParamsController.this.cmbFinalLandmarkField.addItem(featureAttributeDescriptor);

                    logger.info(new StringBuilder().append("1 - Adding field ")

                        .append(featureAttributeDescriptor.getName())

                        .toString());