org.opentripplanner.routing.util.ElevationUtils Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of otp Show documentation
Show all versions of otp Show documentation
The OpenTripPlanner multimodal journey planning system
/* This program is free software: you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public License
as published by the Free Software Foundation, either version 3 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, see
* For a slope of 0 = 0 degree a cost is returned that approximates a speed of 1.333 m/sec = 4.8km/h
* TODO: Not sure if it makes sense to use maxSlope as input and instead better use
* a lower estimate / average value. However, the DEM is most likely generalized/smoothed
* and hence maxSlope may be smaller than in the real world.
* @param verticalDistance the vertical distance of the line segment
* @param maxSlope the slope of the segment
* @return walk costs dependent on slope (in seconds)
*/
public static double getWalkCostsForSlope(double verticalDistance, double maxSlope) {
/*
Naismith (1892):
"an hour for every three miles on the map, with an additional hour for
every 2,000 feet of ascent.'
-------
in S. Fritz and S. Carver (GISRUK 1998):
Naismith's Rule: 5 km/h plus 1 hour per 600m ascent; minus 10 minutes per 300 m
descent for slopes between 5 and 12 degrees; plus 10 minutes per 300m descent
for slopes greater than 12 degrees.
...
In the case of a 50m grid resolution DEM for every m climbed, 6 seconds are added.
2 seconds are added in case of a ascent of more than 12 degrees and 2 seconds are
subtracted if the ascent is between 5-12 degrees.
-------
Naismith's rule was overhauled by W.G. Rees (2004), who developed a quadratic
function for speed estimation:
1/v = a + b*m + c*m^2
with a= 0.75 sec/m, b=0.09 s/m, c=14.6 s/m
As for b=0 there are no big differences the derived cost function is:
k = a*d + c * (h*h) / d
with d= distance, and h = vertical separation
*/
if (verticalDistance == 0){
return 0;
}
double costs = 0;
double h = maxSlope * verticalDistance;
costs = (walkParA * verticalDistance) + ( walkParC * (h * h) / verticalDistance);
return costs;
}
public static PackedCoordinateSequence getPartialElevationProfile(
PackedCoordinateSequence elevationProfile, double start, double end) {
if (elevationProfile == null) {
return null;
}
List coordList = new LinkedList();
if (start < 0)
start = 0;
Coordinate[] coordinateArray = elevationProfile.toCoordinateArray();
double length = coordinateArray[coordinateArray.length - 1].x;
if (end > length)
end = length;
boolean started = false;
boolean finished = false;
Coordinate lastCoord = null;
for (Coordinate coord : coordinateArray) {
if (coord.x >= start && coord.x <= end) {
coordList.add(new Coordinate(coord.x - start, coord.y));
if (!started) {
started = true;
if (lastCoord == null) {
//no need to interpolate as this is the first coordinate
continue;
}
// interpolate start coordinate
double run = coord.x - lastCoord.x;
if (run < 1) {
//tiny runs are likely to lead to errors, so we'll skip them
continue;
}
double p = (coord.x - start) / run;
double rise = coord.y - lastCoord.y;
Coordinate interpolatedStartCoordinate = new Coordinate(0, lastCoord.y + p * rise);
coordList.add(0, interpolatedStartCoordinate);
}
} else if (coord.x > end && !finished && started && lastCoord != null) {
finished = true;
// interpolate end coordinate
double run = coord.x - lastCoord.x;
if (run < 1) {
//tiny runs are likely to lead to errors, so we'll skip them
continue;
}
double p = (end - lastCoord.x) / run;
double rise = coord.y - lastCoord.y;
Coordinate interpolatedEndCoordinate = new Coordinate(end, lastCoord.y + p * rise);
coordList.add(interpolatedEndCoordinate);
}
lastCoord = coord;
}
Coordinate coordArr[] = new Coordinate[coordList.size()];
return new PackedCoordinateSequence.Float(coordList.toArray(coordArr), 2);
}
/** checks for units (m/ft) in an OSM ele tag value, and returns the value in meters */
public static Double parseEleTag(String ele) {
ele = ele.toLowerCase();
double unit = 1;
if (ele.endsWith("m")) {
ele = ele.replaceFirst("\\s*m", "");
} else if (ele.endsWith("ft")) {
ele = ele.replaceFirst("\\s*ft", "");
unit = 0.3048;
}
try {
return Double.parseDouble(ele) * unit;
} catch (NumberFormatException e) {
return null;
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy