Application: gvSIG desktop » gvSIG Linear Reference System

/*

 * Copyright 2015 DiSiD Technologies S.L.L. All rights reserved.

 *

 * Project  : DiSiD org.gvsig.lrs.lib.impl

 * SVN Id   : $Id$

 */

package org.gvsig.lrs.lib.impl;

import java.io.File;

import java.util.ArrayList;

import java.util.List;

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.feature.EditableFeatureAttributeDescriptor;

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

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

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

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

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

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.exceptions.LrsCreateRouteException;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.locator.LocatorException;

/**

 * @author fdiaz

 *

 */

public class LrsAlgorithmUtils {

    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 {

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

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

        }

    }

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

        }

        return result;

    }

    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 currentVertex = line.getVertex(i);

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

                Point point = getPointWithMBetweenTwoMPoints(m, currentVertex, nextVertex);

                if (point != null && !points.contains(point)) {

                    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.contains(point)) {

                        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;

    }

    /**

     * Returns geometry length without gaps

     * @param geometry

     * @return

     * @throws GeometryOperationNotSupportedException

     * @throws GeometryOperationException

     */

    static protected Double getGeometryLength(Geometry geometry) throws GeometryOperationNotSupportedException, GeometryOperationException{

        return getGeometryLength(geometry, true);

    }

    /**

     * Returns geometry length without gaps with the option to not ignore spatial gaps.

     * @param geometry

     * @param ignoreSpatialGaps

     * @return

     * @throws GeometryOperationNotSupportedException

     * @throws GeometryOperationException

     */

    static protected Double getGeometryLength(Geometry geometry,

        boolean ignoreSpatialGaps)

            throws GeometryOperationNotSupportedException,

            GeometryOperationException {

        if (geometry instanceof Line) {

            Line line = (Line) geometry;

            return getLineLength(line);

        }

        if (geometry instanceof MultiLine) {

            MultiLine multiLine = (MultiLine) geometry;

            return getMultiLineLength(multiLine, ignoreSpatialGaps);

        }

        return Double.NaN;

    }

    /**

     * @param line

     * @return lenght

     * @throws GeometryOperationException

     * @throws GeometryOperationNotSupportedException

     */

    static protected double getLineLength(Line line)

        throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        double lenght = 0;

        Point previousVertex = null;

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

            Point vertex = line.getVertex(i);

            if (previousVertex != null) {

                lenght += previousVertex.distance(vertex);

            }

            previousVertex = vertex;

        }

        return lenght;

    }

    /**

     * @param multiLine

     * @return lenght

     * @throws GeometryOperationException

     * @throws GeometryOperationNotSupportedException

     */

    static protected double getMultiLineLength(MultiLine multiLine,

        boolean ignoreSpatialGaps)

            throws GeometryOperationNotSupportedException,

            GeometryOperationException {

        double length = 0;

        Point previousVertex = null;

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

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

            if (ignoreSpatialGaps) {

                previousVertex = null;

            }

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

                Point vertex = line.getVertex(i);

                if (previousVertex != null) {

                    length += previousVertex.distance(vertex);

                }

                previousVertex = vertex;

            }

        }

        return length;

    }

    /**

     * Extracts the lines in a Line or Multiline

     * @param geometry

     * @return

     */

    static protected List<Line> extractLines(Geometry geometry){

        List<Line> lines=new ArrayList<Line>();

        if (geometry instanceof  Line){

            lines.add((Line) geometry);

        }

        if (geometry instanceof MultiLine){

            MultiLine multiline=(MultiLine)geometry;

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

                lines.add((Line) multiline.getPrimitiveAt(i));

            }

        }

        return lines;

    }

    static protected List<Point> extractPoints(Geometry geometry){

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

        List<Line> lines=LrsAlgorithmUtils.extractLines(geometry);

        for (Line line: lines){

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

                points.add(line.getVertex(i));

            }

        }

        return points;

    }

    static protected Point extractFirstPoint(Geometry geometry){

        Point firstPoint=null;

        List<Line> lines= LrsAlgorithmUtils.extractLines(geometry);

        if (lines!=null && !lines.isEmpty()){

            firstPoint=lines.get(0).getVertex(0);

        }

        return firstPoint;

    }

    static protected boolean equalPoints(Point point1, Point point2){

        if ( point1.getX()==point2.getX() && point1.getY()==point2.getY()){

            return true;

        }

        return false;

    }

    static protected Geometry insertVertex(Geometry geometry, Point vertex, int index){

        if (geometry instanceof Line){

            Line line=(Line)geometry;

            line.insertVertex(index, vertex);

        }

        if (geometry instanceof MultiLine){

            List<Line> lines=extractLines(geometry);

            for(Line line:lines){

                if (index<=line.getNumVertices()){

                    line.insertVertex(index, vertex);

                    return geometry;

                }else{

                    index-=line.getNumVertices();

                }

            }

        }

        return geometry;

    }

    /**

     * Reduced versi?n of straight line through two points equation to calculate M's

     *

     * @param totalLength

     * @param minValue

     * @param maxValue

     * @param relativeDistance

     * @return

     */

    static protected double calculateM(Double totalLength, Double minValue, Double maxValue, Double relativeDistance) {

        return LrsAlgorithmUtils.straightLineThroughTwoPointsEquation(0, totalLength, minValue, maxValue, relativeDistance);

    }

    /**

     * Straight line through two points equation.

     *

     * @param x1

     * @param x2

     * @param y1

     * @param y2

     * @param x

     * @return

     */

    static protected double straightLineThroughTwoPointsEquation(double x1, double x2, double y1, double y2, double x) {

        if (x2 - x1 == 0.0) {

            return Double.POSITIVE_INFINITY;

        }

        return ((y2 - y1) * (x - x1) / (x2 - x1)) + y1;

    }

}