/ - Diff - gvSIG Linear Reference System - gvSIG

Revision 48

+            }
+        }
         static protected 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;
         /**
          * 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);
+        }
         static protected double calculateNewM(double oldMax, double oldMin, double newMax, double newMin, double mCoordinate){
             double result;
             if (oldMax==oldMin){
         /**
          * Same as straightLineThroughTwoPointsEquation but with more human readable arguments
+         *
          * @param oldMin
          * @param oldMax
          * @param newMin
          * @param newMax
          * @param m
          * @return double
+         *
          * @deprecated Use {@link #straightLineThroughTwoPointsEquation()} instead.
          */
         @Deprecated
         static protected double calculateNewM(double oldMin, double oldMax, double newMin, double newMax, double m){
             //TO REMOVE
             return straightLineThroughTwoPointsEquation(oldMin, oldMax, newMin, newMax, m);
+        }
         /**
          * 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;
+            }
             result=((newMax-newMin)*(mCoordinate-oldMin)/(oldMax-oldMin))+newMin;
             return result;
             return ((y2 - y1) * (x - x1) / (x2 - x1)) + y1;
+        }
+    }

                                 Point fork = getPossibleFork(auxMultiLine, vertex);
                                 if(fork!=null){
                                     previousPoint = fork;
                                     // OJO, aqu? previousPoint pasa a ser 2DM
+                                }
                                 // OJO, aqu? previousPoint pasa a ser 2DM
                             } else {
                                 // En caso de salto, calculamos el previousPoint
                                 // buscando el v?rtice m?s cercano
-...
                                 if(areInSame2DLocation(previousPoint,previousVertex)){
                                     Point nextVertex = getNextVertexToPoint(auxMultiLine, previousPoint);
                                     double distanceToNextPoint = nextVertex.distance(previousPoint);
                                     previousM = strightLineThroughTwoPointsEquation(0, distanceToNextPoint,
                                     previousM = LrsAlgorithmUtils.straightLineThroughTwoPointsEquation(0, distanceToNextPoint,
                                         previousM, nextVertex.getCoordinateAt(previousVertex.getDimension() - 1),
                                             previousPoint.distance(point));
                                 } else {
                                     double distanceToPreviousPoint = previousVertex.distance(previousPoint);
                                     previousM = strightLineThroughTwoPointsEquation(0, distanceToPreviousPoint,
                                     previousM = LrsAlgorithmUtils.straightLineThroughTwoPointsEquation(0, distanceToPreviousPoint,
                                             previousVertex.getCoordinateAt(previousVertex.getDimension() - 1), previousM,
                                             distanceToPreviousPoint + previousPoint.distance(point));
+                                }
-...
                             distance += previousPoint.distance(vertex);
+                        }
                         double m =
                             strightLineThroughTwoPointsEquation(0, geometryLength, firstM, firstM + mSegment.fromValue,
                             LrsAlgorithmUtils.straightLineThroughTwoPointsEquation(0, geometryLength, firstM, firstM + mSegment.fromValue,
                                 distance);
                         point.setCoordinateAt(point.getDimension() - 1, m);
                         auxLine.addVertex(point);
-...
                                     // OJO, aqu? previousPoint pasa a ser 2DM
                                 } else {
                                     // En caso de salto, calculamos el previousPoint
                                     // buscando el v?rtice m?s cercano
                                     previousPoint = getClosestVertex(auxMultiLine, vertex);
                                     // OJO, aqu? previousPoint pasa a ser 2DM
                                     gap = true;
-...
                                     Point previousVertex = getPreviousVertexToPoint(auxMultiLine, previousPoint);
                                     previousVertex.getCoordinateAt(previousVertex.getDimension() - 1);
                                     previousM =
                                         strightLineThroughTwoPointsEquation(0, previousVertex.distance(previousPoint),
                                         LrsAlgorithmUtils.straightLineThroughTwoPointsEquation(0, previousVertex.distance(previousPoint),
                                             previousVertex.getCoordinateAt(previousVertex.getDimension() - 1), previousM,
                                             previousVertex.distance(previousPoint) + previousPoint.distance(point));
                                     firstM = previousM;
-...
                                 distance += previousPoint.distance(vertex);
+                            }
                             double m =
                                 strightLineThroughTwoPointsEquation(0, geometryLength, firstM, firstM + mSegment.fromValue,
                                 LrsAlgorithmUtils.straightLineThroughTwoPointsEquation(0, geometryLength, firstM, firstM + mSegment.fromValue,
                                     distance);
                             point.setCoordinateAt(point.getDimension() - 1, m);
                             auxLine.addVertex(point);
-...
                 Double distance = Double.valueOf(0);
                 for (Line line : geometryLines) {
                     Double lineLength = getLineLength(line);
                     Double mFirstPoint = calculateM(geometryMLastPoint, geometryMFirstPoint, distance, geometryLength);
                     Double mFirstPoint = LrsAlgorithmUtils.calculateM(geometryLength, geometryMFirstPoint, geometryMLastPoint, distance);
                     distance += lineLength;
                     Double mLastPoint = calculateM(geometryMLastPoint, geometryMFirstPoint, distance, geometryLength);
                     Double mLastPoint = LrsAlgorithmUtils.calculateM(geometryLength, geometryMFirstPoint, geometryMLastPoint, distance);
                     Line mLine = lineToMLine(line, mFirstPoint, mLastPoint);
                     mGeometry.addPrimitive(mLine);
+                }
-...
                 else {
                     Point previousVertex = line.getVertex(i - 1);
                     inLineDistance += vertex.distance(previousVertex);
                     mValue = calculateM(maxMValue, minMValue, inLineDistance, lineLength);
                     mValue = LrsAlgorithmUtils.calculateM(lineLength, minMValue, maxMValue, inLineDistance);
+                }
                 mVertex.setCoordinateAt(mVertex.getDimension() - 1, mValue);
-...
             return lineM;
+        }
         /**
          * Reduced versi?n of stright line through two points equation to calculate M's
+         *
          * @param maxValue
          * @param minValue
          * @param relativeDistance
          * @param totalLength
          * @return
          */
         private Double calculateM(Double maxValue, Double minValue, Double relativeDistance, Double totalLength) {
             if (totalLength.equals(Double.valueOf(0)))
                 return Double.POSITIVE_INFINITY;
             return ((maxValue - minValue) * (relativeDistance) / (totalLength)) + minValue;
+        }
         /**
          * Stright line through two points equation.
+         *
          * @param x1
          * @param x2
          * @param y1
          * @param y2
          * @param x
          * @return
          */
         private double strightLineThroughTwoPointsEquation(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;
+        }
         /**
          * Simplify the multilines in mList calling simplifyMultiline method
+         *
          * @param mList

Also available in: Unified diff

Application: gvSIG desktop » gvSIG Linear Reference System

Revision 48