Application: gvSIG desktop » gvSIG Linear Reference System

import java.awt.Dimension;

import java.awt.geom.Point2D;

import java.sql.Array;

import java.util.Arrays;

import java.util.Comparator;

import javax.xml.transform.Source;

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

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

import org.gvsig.fmap.geom.GeometryException;

        //LrsCoordinatesPriority coordinatePriority = parameters.getCoordinatePriority();

        //LrsSourceOfMeasures sourceOfMeasures = parameters.getSourceOfMeasures();

        //double measureFactor = parameters.getMeasureFactor();

        //double measureOffset = parameters.getMeasureOffset();

        //boolean ignoreSpatialGaps = parameters.ignoreSpatialGaps();

            taskStatus.setRangeOfValues(0, featuresMap.size());

            //TODO Added to facilitate Tests. Remove afterwards

            StringBuffer resultDebug=new StringBuffer();

            LrsSourceOfMeasures sourceOfMeasures = parameters.getSourceOfMeasures();

            boolean ignoreSpatialGaps = parameters.ignoreSpatialGaps();

            LrsCoordinatesPriority coordinatePriority = parameters.getCoordinatePriority();

            resultDebug.append (sourceOfMeasures.getName());

            if (!sourceOfMeasures.equals(LrsSourceOfMeasures.TWO_FIELDS)){

                if (ignoreSpatialGaps)resultDebug.append (" WITHOUT GAPS ");

                else resultDebug.append (" WITH GAPS ");

                resultDebug.append(coordinatePriority.getName());

            }

            //END of Test addition

                //TODO Added to facilitate Tests. Remove afterwards

                String lineSeparator=System.getProperty("line.separator");

                resultDebug.append(lineSeparator);

                resultDebug.append("Route: "+routeName);

                resultDebug.append(lineSeparator);

                if (route instanceof MultiLine){

                    MultiLine multiLine=(MultiLine)route;

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

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

                        resultDebug.append("Line "+j+":[");

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

                            Point point=line.getVertex(i);

                            Double x=point.getX();

                            Double y=point.getY();

                            Double m=point.getCoordinateAt(point.getDimension()-1);

                            resultDebug.append("(x="+x.toString()+",y="+y.toString()+",m="+m.toString()+")");

                        }

                        resultDebug.append("]");

                        resultDebug.append(lineSeparator);

                    }

                }

                //END of Test addition

                taskCount++;

            logger.debug(resultDebug.toString());

    private Geometry createGeometryRoute(List<MStructure> mList) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException {

        LrsSourceOfMeasures sourceOfMeasures =parameters.getSourceOfMeasures();

        Geometry geometryResult=null;

        switch (sourceOfMeasures) {

        case ONE_FIELD:

            geometryResult= calculateGeometryByOneField(mList);

            break;

        case TWO_FIELDS:

            geometryResult= calculateGeometryByTwoField(mList);

            break;

        case LENGTH:

        default:

            geometryResult= calculateGeometryByLength(mList);

            break;

        }

        geometryResult=applyOffset(geometryResult);

        return geometryResult;

    }

    private Geometry calculateGeometryByLength(List<MStructure> mList) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException{

        return null;

    }

    private Geometry calculateGeometryByOneField(List<MStructure> mList) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException {

        boolean ignoreSpatialGaps = parameters.ignoreSpatialGaps();

        try {

            sortMList(mList);

        } catch (Exception e) {

            logger.warn("Geometries couldn't be ordered");

        }

        MultiLine mGeometry= (MultiLine)geomanager.create(Geometry.TYPES.MULTILINE, Geometry.SUBTYPES.GEOM2DM);

        MutableDouble lastMValue=new MutableDouble(0);

        Double gap=Double.valueOf(0);

        Point lastPoint=null;

            if(!ignoreSpatialGaps){

                gap=calculateGap(lastPoint, geometry);

                lastMValue.add(gap);

            }

            Double fromDistance=lastMValue.getValue();

            lastMValue.add(mStructure.fromField);

            Double toDistance=lastMValue.getValue();

                Line line=(Line) geometry;

                Line lineM=lineToMLine(line, fromDistance, toDistance);

                mGeometry.addPrimitive(lineM);

                lastPoint=lineM.getVertex(lineM.getNumVertices()-1);

                Line[] lines=multilineToMlines(multiLine, fromDistance, toDistance,ignoreSpatialGaps);

                for (Line lineM:lines){

                    mGeometry.addPrimitive(lineM);

                    lastPoint=lineM.getVertex(lineM.getNumVertices()-1);

        return mGeometry;

    private Double calculateGap(Point lastPoint, Geometry geometry) throws GeometryOperationNotSupportedException, GeometryOperationException{

        Double gap=new Double(0);

        if (geometry instanceof Line){

            Line line=(Line) geometry;

            if (lastPoint!=null){

                Point firstPoint=line.getVertex(0);

                gap=firstPoint.distance(lastPoint);

            }

        }

        if (geometry instanceof MultiLine){

            MultiLine multiLine =(MultiLine) geometry;

            if (lastPoint!=null){

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

                Point firstPoint=line.getVertex(0);

                gap=firstPoint.distance(lastPoint);

            }

        }

        return gap;

    }

    private void sortMList(List<MStructure> mList) throws CreateEnvelopeException, GeometryOperationNotSupportedException, GeometryOperationException {

        LrsCoordinatesPriority coordinatePriority = parameters.getCoordinatePriority();

        GeometryManager geomanager= GeometryLocator.getGeometryManager();

        Envelope envelope = geomanager.createEnvelope(Geometry.SUBTYPES.GEOM2D);

        for (MStructure mStructure:mList){

            envelope.add(mStructure.geometry.getEnvelope());

        }

        Point origin=envelope.getLowerCorner();

        switch (coordinatePriority) {

        case DOWN_LEFT:

            break;

        case DOWN_RIGHT:

            Double maxX =envelope.getMaximum(DIMENSIONS.X);

            origin.setX(maxX);

            break;

        case UP_LEFT:

            Double maxY =envelope.getMaximum(DIMENSIONS.Y);

            origin.setY(maxY);

            break;

        case UP_RIGHT:

            origin=envelope.getUpperCorner();

            break;

        default:

            break;

        }

        GeometryDistanceToPointComparator comaparatorMList=new GeometryDistanceToPointComparator(origin);

        MStructure[] orderedMStruct=(MStructure[])mList.toArray();

        Arrays.sort(orderedMStruct, comaparatorMList);

        mList=new ArrayList<MStructure>(Arrays.asList(orderedMStruct));

        for (MStructure mStructure:mList){

            Geometry geometry=mStructure.geometry;

            if (geometry instanceof Line){

                Line line=(Line)geometry;

                Double firstPointDistance=origin.distance(line.getVertex(0));

                Double lastPointDistance=origin.distance(line.getVertex(line.getNumVertices()-1));

                if (lastPointDistance<firstPointDistance){

                    geometry.flip();

                }

            }

            if (geometry instanceof MultiLine){

                MultiLine multiLine=(MultiLine)geometry;

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

                Line lastLine=(Line)multiLine.getPrimitiveAt(multiLine.getPrimitivesNumber()-1);

                Double firstPointDistance=origin.distance(firstLine.getVertex(0));

                Double lastPointDistance=origin.distance(lastLine.getVertex(lastLine.getNumVertices()-1));

                if (lastPointDistance<firstPointDistance){

                    geometry.flip();

                }

            }

            mStructure.geometry=geometry;

        }

    }

    private Geometry applyOffset(Geometry geometry){

        double measureFactor = parameters.getMeasureFactor();

        double measureOffset = parameters.getMeasureOffset();

        if (geometry instanceof Line){

            Line line=(Line) geometry;

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

                Point mVertex=line.getVertex(i);

                Double mValue=mVertex.getCoordinateAt(mVertex.getDimension()-1);

                Double newMValue=(mValue*measureFactor)+measureOffset;

                mVertex.setCoordinateAt(mVertex.getDimension()-1, newMValue);

                line.setVertex(i, mVertex);

            }

        }

        if (geometry instanceof MultiLine){

            MultiLine multiLine =(MultiLine) geometry;

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

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

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

                    Point mVertex=line.getVertex(j);

                    Double mValue=mVertex.getCoordinateAt(mVertex.getDimension()-1);

                    Double newMValue=(mValue*measureFactor)+measureOffset;

                    mVertex.setCoordinateAt(mVertex.getDimension()-1, newMValue);

                    line.setVertex(j, mVertex);

                }

            }

        }

        return geometry;

    }

    private Geometry calculateGeometryByTwoField(List<MStructure> mList) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException{

        GeometryManager geomanager= GeometryLocator.getGeometryManager();

        MultiLine mGeometry= (MultiLine)geomanager.create(Geometry.TYPES.MULTILINE, Geometry.SUBTYPES.GEOM2DM);

        for (MStructure mStructure:mList){

            Geometry geometry=mStructure.geometry;

            Double fromDistance=mStructure.fromField;

            Double toDistance=mStructure.toField;

            if (geometry instanceof Line){

                Line line=(Line) geometry;

                Line lineM=lineToMLine(line, fromDistance, toDistance);

                mGeometry.addPrimitive(lineM);

            }

            if (geometry instanceof MultiLine){

                MultiLine multiLine =(MultiLine) geometry;

                Line[] lines=multilineToMlines(multiLine, fromDistance, toDistance);

                for (Line lineM:lines){

                    mGeometry.addPrimitive(lineM);

                }

            }

        }

        return mGeometry;

    }

    private Line[] multilineToMlines(MultiLine multiLine,Double fromDistance, Double toDistance) throws GeometryOperationNotSupportedException, GeometryOperationException, CreateGeometryException{

        return multilineToMlines(multiLine,fromDistance, toDistance,true);

    }

    private Line[] multilineToMlines(MultiLine multiLine,Double fromDistance, Double toDistance,boolean ignoreSpatialGaps) throws GeometryOperationNotSupportedException, GeometryOperationException, CreateGeometryException{

        Line[] lines=new Line[multiLine.getPrimitivesNumber()];

        Double multiLineLength=getMultiLineLength(multiLine,ignoreSpatialGaps);

        Double mFirstPoint=fromDistance;

        Double mLastPoint=null;

        Double distance=Double.valueOf(0);

        Point lastPoint=null;

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

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

            Double lineLength=getLineLength(line);

            Double gap=Double.valueOf(0);

            if (!ignoreSpatialGaps&&lastPoint!=null){

                Point firstPoint=line.getVertex(0);

                gap=firstPoint.distance(lastPoint);

                distance+=gap;

            }

            mFirstPoint=calculateM(toDistance,fromDistance, distance, multiLineLength);

            distance+=lineLength;

            mLastPoint=calculateM(toDistance,fromDistance, distance, multiLineLength);

            lines[i]=lineToMLine(line, mFirstPoint, mLastPoint);

            lastPoint=lines[i].getVertex(line.getNumVertices()-1);

        }

        return lines;

    }

    private Line lineToMLine(Line line,Double minMValue, Double maxMValue) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException{

        GeometryManager geomanager= GeometryLocator.getGeometryManager();

        Double lineLength=getLineLength(line);

        Line lineM=(Line)geomanager.create(Geometry.TYPES.LINE, Geometry.SUBTYPES.GEOM2DM);

        Double inLineDistance=Double.valueOf(0);

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

            Point vertex=line.getVertex(i);

            Point mVertex=(Point)geomanager.create(Geometry.TYPES.POINT, Geometry.SUBTYPES.GEOM2DM);

            mVertex.setX(vertex.getX());

            mVertex.setY(vertex.getY());

            Double mValue;

            if (i==0)mValue=minMValue;

            else if (i==line.getNumVertices()-1) mValue=maxMValue;

            else{

                Point previousVertex=line.getVertex(i-1);

                inLineDistance+=vertex.distance(previousVertex);

                mValue=calculateM(maxMValue,minMValue, inLineDistance, lineLength);

            }

            mVertex.setCoordinateAt(mVertex.getDimension()-1, mValue);

            lineM.addVertex(mVertex);

        }

        return lineM;

    }

    private Double calculateM(Double maxValue, Double minValue, Double relativeDistance, Double totalLength){

        //mValue=((newMax-newMin)*(mCoordinate-oldMin)/(oldMax-oldMin))+newMin;

        if (totalLength.equals(Double.valueOf(0) )) return Double.POSITIVE_INFINITY;

        return ((maxValue-minValue)*(relativeDistance)/(totalLength))+minValue;

    }

//    private Line lineToMLine(Line line,Point previousVertex, MutableDouble distance) throws CreateGeometryException{

//        GeometryManager geomanager= GeometryLocator.getGeometryManager();

//        Line lineM=(Line)geomanager.create(Geometry.TYPES.LINE, Geometry.SUBTYPES.GEOM2DM);

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

//            Point vertex=line.getVertex(i);

//            Point mVertex=(Point)geomanager.create(Geometry.TYPES.POINT, Geometry.SUBTYPES.GEOM2DM);

//            mVertex.setX(vertex.getX());

//            mVertex.setY(vertex.getY());

//

//            if (previousVertex==null){

//                previousVertex=vertex;

//            }else{

//                try {

//                    distance.setValue(distance.getValue()+vertex.distance(previousVertex));

//                    previousVertex=vertex;

//                } catch (Exception e) {

//                    previousVertex=vertex;

//                    distance.setValue(Double.NaN);

//                }

//            }

//            mVertex.setCoordinateAt(mVertex.getDimension()-1, distance.getValue());

//            lineM.addVertex(mVertex);

//        }

//        return lineM;

//    }

//    private MultiLine createRoute(List<FeatureReference> references, LrsCoordinatesPriority coordinatePriority, LrsSourceOfMeasures sourceOfMeasures, FeatureAttributeDescriptor fromMeasureField,FeatureAttributeDescriptor toMeasureField, double measureFactor, double measureOffset, boolean ignoreSpatialGaps) throws CreateGeometryException, DataException, CreateEnvelopeException, GeometryOperationNotSupportedException, GeometryOperationException{

//

//        Envelope envelope = getEnvelope(references);

//        Point p = getOriginPointAccordingPriorityCoordinates(envelope, coordinatePriority);

//        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

//

//        //FIXME: cuando est? esto tendr? que ser GEOM2DM o incluso GEOM3DM

//        MultiLine route = geometryManager.createMultiLine(Geometry.SUBTYPES.GEOM2D);

//        double m = 0;

//        Point previousVertex = null;

//        List<FeatureReference> orderedReferences = getOrderedReferences(references, (Point)p.cloneGeometry());

//        for (Iterator iterator = orderedReferences.iterator(); iterator.hasNext();) {

//            FeatureReference featureReference = (FeatureReference) iterator.next();

//            Feature feature = featureReference.getFeature();

//            Geometry geometry = feature.getDefaultGeometry();

//            if (geometry instanceof Line) {

//                Line line = (Line) geometry;

//                Point firstVertex = line.getVertex(0);

//                Point lastVertex = line.getVertex(line.getNumVertices() - 1);

//                boolean ascendantOrder = isAscendantOrder(p, firstVertex, lastVertex);

//                //FIXME: cuando est? disponible esto deber? ser GEOM2DM (?o incluso GEOM3DM?)

//                Line tramo = geometryManager.createLine(Geometry.SUBTYPES.GEOM3D);

//                double lineLength = getLineLength(line);

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

//                    Point vertex = getNextVertex(line, ascendantOrder, i);

//

//                    switch (sourceOfMeasures) {

//                    case ONE_FIELD:

//                        m = calculateMByOneField(m, previousVertex, i, vertex, feature.getDouble(fromMeasureField.getName()), lineLength, measureFactor, measureOffset, ignoreSpatialGaps);

//                        break;

//                    case TWO_FIELDS:

//                        m = calculateMByTwoField(m, previousVertex, i, vertex, feature.getDouble(fromMeasureField.getName()), feature.getDouble(toMeasureField.getName()), lineLength, measureFactor, measureOffset);

//                        break;

//                    case LENGTH:

//                    default:

//                        m = calculateMByLength(m, previousVertex, i, vertex, ignoreSpatialGaps, measureFactor, measureOffset);

//                        break;

//                    }

//                    // FIXME: cuando est? disponible esto deber? ser GEOM2DM (?o incluso GEOM3DM?)

//                    Point mvertex = geometryManager.createPoint(vertex.getX(), vertex.getY(), Geometry.SUBTYPES.GEOM3D);

//                    mvertex.setCoordinateAt(2, m);

//                    tramo.addVertex(mvertex);

//                    previousVertex = vertex;

//                    p = vertex;

//                }

//                route.addPrimitive(tramo);

//            } else if (geometry instanceof MultiLine) {

//                MultiLine multiLine = (MultiLine)geometry;

//                double multiLineLength = getMultiLineLength(multiLine);

//                MultiLine orderedMultiLine = getOrderedMultiLine(multiLine, previousVertex, coordinatePriority);

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

//                    Line line = (Line) orderedMultiLine.getPrimitiveAt(j);

//                    Point firstVertex = line.getVertex(0);

//                    Point lastVertex = line.getVertex(line.getNumVertices() - 1);

//                    boolean ascendantOrder = isAscendantOrder(p, firstVertex, lastVertex);

//                    //FIXME: cuando est? disponible esto deber? ser GEOM2DM (?o incluso GEOM3DM?)

//                    Line tramo = geometryManager.createLine(Geometry.SUBTYPES.GEOM3D);

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

//                        Point vertex = getNextVertex(line, ascendantOrder, i);

//                        switch (sourceOfMeasures) {

//                        case ONE_FIELD:

//                            m = calculateMByOneField(m, previousVertex, i, vertex, feature.getDouble(toMeasureField.getName()), multiLineLength, multiLineLength, multiLineLength, ascendantOrder);

//                            break;

//                        case TWO_FIELDS:

//                            //Este caso tal vez no se d? nunca, pero por si acaso

//                            m = calculateMByTwoField(m, previousVertex, i, vertex, feature.getDouble(fromMeasureField.getName()), feature.getDouble(toMeasureField.getName()), multiLineLength, measureFactor, measureOffset);

//                            break;

//                        case LENGTH:

//                        default:

//                            m = calculateMByLength(m, previousVertex, i, vertex, ignoreSpatialGaps, measureFactor, measureOffset);

//                            break;

//                        }

//

//                        // FIXME: cuando est? disponible esto deber? ser GEOM2DM (?o incluso GEOM3DM?)

//                        Point mvertex = geometryManager.createPoint(vertex.getX(), vertex.getY(), Geometry.SUBTYPES.GEOM3D);

//                        mvertex.setCoordinateAt(2, m);

//                        tramo.addVertex(mvertex);

//                        previousVertex = vertex;

//                        p = vertex;

//                    }

//                    route.addPrimitive(tramo);

//                }

//            }

//        }

//

//        return route;

//    }

    private double getMultiLineLength(MultiLine multiLine,boolean ignoreSpatialGaps) throws GeometryOperationNotSupportedException, GeometryOperationException{

        Point previousVertex = null;

            if (ignoreSpatialGaps){

                previousVertex = null;

            }

    class MStructure implements Comparable<MStructure>{

        public int compareTo(MStructure o) {

            // TODO Auto-generated method stub

            return 0;

        }

    class GeometryDistanceToPointComparator implements Comparator<MStructure> {

        private Point referencePoint;

        public GeometryDistanceToPointComparator(Point referencePoint) {

            this.referencePoint = referencePoint;

        }

        public int compare(MStructure mStruct1, MStructure mStruct2) {

            Double distance1=nearestPointDistance(mStruct1.geometry);

            Double distance2=nearestPointDistance(mStruct2.geometry);

            return distance1.compareTo(distance2);

        }

        private Double nearestPointDistance(Geometry geometry){

            if (geometry instanceof Line){

                return nearestPointDistanceToLine((Line)geometry);

            }

            if (geometry instanceof MultiLine){

                MultiLine multiLine=(MultiLine)geometry;

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

                Line lastLine=(Line)multiLine.getPrimitiveAt(multiLine.getPrimitivesNumber()-1);

                Double distanceFirstPoint;

                Double distanceLastPoint;

                try {

                    distanceFirstPoint = referencePoint.distance(firstLine.getVertex(0));

                } catch (Exception e) {

                    distanceFirstPoint=Double.MAX_VALUE;

                }

                try {

                    distanceLastPoint=referencePoint.distance(lastLine.getVertex(lastLine.getNumVertices()-1));

                } catch (Exception e) {

                    distanceLastPoint=Double.MAX_VALUE;

                }

                if (distanceFirstPoint<distanceLastPoint) return distanceFirstPoint;

                else return distanceLastPoint;

            }

            return Double.MAX_VALUE;

        }

        private Double nearestPointDistanceToLine(Line line){

            Double distanceFirstPoint;

            Double distanceLastPoint;

            try {

                distanceFirstPoint = referencePoint.distance(line.getVertex(0));

            } catch (Exception e) {

                distanceFirstPoint=Double.MAX_VALUE;

            }

            try {

                distanceLastPoint=referencePoint.distance(line.getVertex(line.getNumVertices()-1));

            } catch (Exception e) {

                distanceLastPoint=Double.MAX_VALUE;

            }

            if (distanceFirstPoint<distanceLastPoint) return distanceFirstPoint;

            else return distanceLastPoint;

        }

    }