Rename Development -> UrbanDensity (graphhopper#2637)

easbar · easbar · commit c9d85e6a5d9e · 2022-08-31T20:59:20.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -13,7 +13,7 @@
 - don't allow cars or motorcycles to use ways tagged with service=emergency_access (#2484)
 - faster flexible routing, especially in conjunction with turn costs (#2571)
 - negative OSM Ids are not supported any longer (#2652)
-- new development encoded value based on road density (#2637)
+- new urban_density encoded value based on road density calculation (#2637)
 
 ### 5.0 [23 Mar 2022]
 
diff --git a/config-example.yml b/config-example.yml
@@ -109,19 +109,19 @@ graphhopper:
   #   elevation and will remove the extra points that long edge sampling added
   # graph.elevation.way_point_max_distance: 10
 
-  #### Development (built-up areas) ####
+  #### Urban density (built-up areas) ####
 
 
-  # This feature allows classifying roads into 'rural', 'residential' and 'city' areas (encoded value 'development')
+  # This feature allows classifying roads into 'rural', 'residential' and 'city' areas (encoded value 'urban_density')
   # Use 1 or more threads to enable the feature
-  # graph.development.threads: 8
+  # graph.urban_density.threads: 8
   # Use higher/lower sensitivities if too little/many roads fall into the according categories.
   # Using smaller radii will speed up the classification, but only change these values if you know what you are doing.
   # If you do not need the (rather slow) city classification set city_radius to zero.
-  # graph.development.residential_radius: 300
-  # graph.development.residential_sensitivity: 60
-  # graph.development.city_radius: 2000
-  # graph.development.city_sensitivity: 30
+  # graph.urban_density.residential_radius: 300
+  # graph.urban_density.residential_sensitivity: 60
+  # graph.urban_density.city_radius: 2000
+  # graph.urban_density.city_sensitivity: 30
 
 
   #### Speed, hybrid and flexible mode ####
diff --git a/core/src/main/java/com/graphhopper/GraphHopper.java b/core/src/main/java/com/graphhopper/GraphHopper.java
@@ -112,7 +112,7 @@ public class GraphHopper {
     private double residentialAreaSensitivity = 60;
     private double cityAreaRadius = 2000;
     private double cityAreaSensitivity = 30;
-    private int developmentCalculationThreads = 0;
+    private int urbanDensityCalculationThreads = 0;
 
     // preparation handlers
     private final LMPreparationHandler lmPreparationHandler = new LMPreparationHandler();
@@ -195,7 +195,7 @@ public GraphHopper setMinNetworkSize(int minNetworkSize) {
     }
 
     /**
-     * Configures the development classification. Each edge will be classified as 'rural','residential' or 'city', {@link Development}
+     * Configures the urban density classification. Each edge will be classified as 'rural','residential' or 'city', {@link UrbanDensity}
      *
      * @param residentialAreaRadius      in meters. The higher this value the longer the calculation will take and the bigger the area for
      *                                   which the road density used to identify residential areas is calculated.
@@ -206,17 +206,17 @@ public GraphHopper setMinNetworkSize(int minNetworkSize) {
      *                                   to skip the city classification.
      * @param cityAreaSensitivity        Use this to find a trade-off between too many roads being classified as city (too high values)
      *                                   and not enough roads being classified as city (too small values)
-     * @param threads                    the number of threads used for the calculation. If this is zero the development
-     *                                   classification is skipped entirely
+     * @param threads                    the number of threads used for the calculation. If this is zero the urban density
+     *                                   calculation is skipped entirely
      */
-    public GraphHopper setDevelopmentClassification(double residentialAreaRadius, double residentialAreaSensitivity,
-                                                    double cityAreaRadius, double cityAreaSensitivity, int threads) {
+    public GraphHopper setUrbanDensityCalculation(double residentialAreaRadius, double residentialAreaSensitivity,
+                                                  double cityAreaRadius, double cityAreaSensitivity, int threads) {
         ensureNotLoaded();
         this.residentialAreaRadius = residentialAreaRadius;
         this.residentialAreaSensitivity = residentialAreaSensitivity;
         this.cityAreaRadius = cityAreaRadius;
         this.cityAreaSensitivity = cityAreaSensitivity;
-        this.developmentCalculationThreads = threads;
+        this.urbanDensityCalculationThreads = threads;
         return this;
     }
 
@@ -571,12 +571,12 @@ public GraphHopper init(GraphHopperConfig ghConfig) {
         preciseIndexResolution = ghConfig.getInt("index.high_resolution", preciseIndexResolution);
         maxRegionSearch = ghConfig.getInt("index.max_region_search", maxRegionSearch);
 
-        // development calculation
-        residentialAreaRadius = ghConfig.getDouble("graph.development.residential_radius", residentialAreaRadius);
-        residentialAreaSensitivity = ghConfig.getDouble("graph.development.residential_sensitivity", residentialAreaSensitivity);
-        cityAreaRadius = ghConfig.getDouble("graph.development.city_radius", cityAreaRadius);
-        cityAreaSensitivity = ghConfig.getDouble("graph.development.city_sensitivity", cityAreaSensitivity);
-        developmentCalculationThreads = ghConfig.getInt("graph.development.threads", developmentCalculationThreads);
+        // urban density calculation
+        residentialAreaRadius = ghConfig.getDouble("graph.urban_density.residential_radius", residentialAreaRadius);
+        residentialAreaSensitivity = ghConfig.getDouble("graph.urban_density.residential_sensitivity", residentialAreaSensitivity);
+        cityAreaRadius = ghConfig.getDouble("graph.urban_density.city_radius", cityAreaRadius);
+        cityAreaSensitivity = ghConfig.getDouble("graph.urban_density.city_sensitivity", cityAreaSensitivity);
+        urbanDensityCalculationThreads = ghConfig.getInt("graph.urban_density.threads", urbanDensityCalculationThreads);
 
         // routing
         routerConfig.setMaxVisitedNodes(ghConfig.getInt(Routing.INIT_MAX_VISITED_NODES, routerConfig.getMaxVisitedNodes()));
@@ -592,7 +592,7 @@ public GraphHopper init(GraphHopperConfig ghConfig) {
         return this;
     }
 
-    private void buildEncodingManagerAndOSMParsers(String flagEncodersStr, String encodedValuesStr, String dateRangeParserString, boolean withDevelopment, Collection<Profile> profiles) {
+    private void buildEncodingManagerAndOSMParsers(String flagEncodersStr, String encodedValuesStr, String dateRangeParserString, boolean withUrbanDensity, Collection<Profile> profiles) {
         Map<String, String> flagEncodersMap = new LinkedHashMap<>();
         for (String encoderStr : flagEncodersStr.split(",")) {
             String name = encoderStr.split("\\|")[0].trim();
@@ -620,8 +620,8 @@ private void buildEncodingManagerAndOSMParsers(String flagEncodersStr, String en
         EncodingManager.Builder emBuilder = new EncodingManager.Builder();
         flagEncodersMap.forEach((name, encoderStr) -> emBuilder.add(vehicleEncodedValuesFactory.createVehicleEncodedValues(name, new PMap(encoderStr))));
         profiles.forEach(profile -> emBuilder.add(Subnetwork.create(profile.getName())));
-        if (withDevelopment)
-            emBuilder.add(Development.create());
+        if (withUrbanDensity)
+            emBuilder.add(UrbanDensity.create());
         encodedValueStrings.forEach(s -> emBuilder.add(encodedValueFactory.create(s)));
         encodingManager = emBuilder.build();
 
@@ -780,8 +780,8 @@ public void importAndClose() {
     private void process(boolean closeEarly) {
         GHDirectory directory = new GHDirectory(ghLocation, dataAccessDefaultType);
         directory.configure(dataAccessConfig);
-        boolean withDevelopment = developmentCalculationThreads > 0;
-        buildEncodingManagerAndOSMParsers(flagEncodersString, encodedValuesString, dateRangeParserString, withDevelopment, profilesByName.values());
+        boolean withUrbanDensity = urbanDensityCalculationThreads > 0;
+        buildEncodingManagerAndOSMParsers(flagEncodersString, encodedValuesString, dateRangeParserString, withUrbanDensity, profilesByName.values());
         baseGraph = new BaseGraph.Builder(getEncodingManager())
                 .setDir(directory)
                 .set3D(hasElevation())
@@ -822,15 +822,15 @@ protected void postImport() {
         if (hasElevation())
             interpolateBridgesTunnelsAndFerries();
 
-        if (encodingManager.hasEncodedValue(Development.KEY)) {
-            EnumEncodedValue<Development> developmentEnc = encodingManager.getEnumEncodedValue(Development.KEY, Development.class);
+        if (encodingManager.hasEncodedValue(UrbanDensity.KEY)) {
+            EnumEncodedValue<UrbanDensity> urbanDensityEnc = encodingManager.getEnumEncodedValue(UrbanDensity.KEY, UrbanDensity.class);
             if (!encodingManager.hasEncodedValue(RoadClass.KEY))
-                throw new IllegalArgumentException("Development calculation requires " + RoadClass.KEY);
+                throw new IllegalArgumentException("Urban density calculation requires " + RoadClass.KEY);
             if (!encodingManager.hasEncodedValue(RoadClassLink.KEY))
-                throw new IllegalArgumentException("Development calculation requires " + RoadClassLink.KEY);
+                throw new IllegalArgumentException("Urban density calculation requires " + RoadClassLink.KEY);
             EnumEncodedValue<RoadClass> roadClassEnc = encodingManager.getEnumEncodedValue(RoadClass.KEY, RoadClass.class);
             BooleanEncodedValue roadClassLinkEnc = encodingManager.getBooleanEncodedValue(RoadClassLink.KEY);
-            DevelopmentCalculator.calcDevelopment(baseGraph, developmentEnc, roadClassEnc, roadClassLinkEnc, residentialAreaRadius, residentialAreaSensitivity, cityAreaRadius, cityAreaSensitivity, developmentCalculationThreads);
+            UrbanDensityCalculator.calcUrbanDensity(baseGraph, urbanDensityEnc, roadClassEnc, roadClassLinkEnc, residentialAreaRadius, residentialAreaSensitivity, cityAreaRadius, cityAreaSensitivity, urbanDensityCalculationThreads);
         }
     }
 
diff --git a/core/src/main/java/com/graphhopper/routing/ev/UrbanDensity.java b/core/src/main/java/com/graphhopper/routing/ev/UrbanDensity.java
@@ -18,18 +18,18 @@
 
 package com.graphhopper.routing.ev;
 
-public enum Development {
+public enum UrbanDensity {
     RURAL("rural"), RESIDENTIAL("residential"), CITY("city");
 
-    public static EnumEncodedValue<Development> create() {
-        return new EnumEncodedValue<>(KEY, Development.class);
+    public static EnumEncodedValue<UrbanDensity> create() {
+        return new EnumEncodedValue<>(KEY, UrbanDensity.class);
     }
 
-    public static final String KEY = "development";
+    public static final String KEY = "urban_density";
 
     private final String name;
 
-    Development(String name) {
+    UrbanDensity(String name) {
         this.name = name;
     }
 
diff --git a/core/src/main/java/com/graphhopper/routing/util/UrbanDensityCalculator.java b/core/src/main/java/com/graphhopper/routing/util/UrbanDensityCalculator.java
@@ -19,9 +19,9 @@
 package com.graphhopper.routing.util;
 
 import com.graphhopper.routing.ev.BooleanEncodedValue;
-import com.graphhopper.routing.ev.Development;
 import com.graphhopper.routing.ev.EnumEncodedValue;
 import com.graphhopper.routing.ev.RoadClass;
+import com.graphhopper.routing.ev.UrbanDensity;
 import com.graphhopper.storage.Graph;
 import com.graphhopper.util.EdgeIteratorState;
 import com.graphhopper.util.StopWatch;
@@ -30,11 +30,11 @@
 
 import java.util.function.ToDoubleFunction;
 
-public class DevelopmentCalculator {
-    private static final Logger logger = LoggerFactory.getLogger(RoadDensityCalculator.class);
+public class UrbanDensityCalculator {
+    private static final Logger logger = LoggerFactory.getLogger(UrbanDensityCalculator.class);
 
     /**
-     * Calculates the development (rural/residential/city) for all edges of the graph.
+     * Calculates the urban density (rural/residential/city) for all edges of the graph.
      * First a weighted road density is calculated for every edge to determine whether it belongs to a residential area.
      * In a second step very dense residential areas are classified as 'city'.
      *
@@ -45,24 +45,24 @@ public class DevelopmentCalculator {
      * @param cityAreaSensitivity        similar to residentialAreaSensitivity, but for the city classification
      * @param threads                    number of threads used to calculate the road densities
      */
-    public static void calcDevelopment(Graph graph, EnumEncodedValue<Development> developmentEnc,
-                                       EnumEncodedValue<RoadClass> roadClassEnc, BooleanEncodedValue roadClassLinkEnc,
-                                       double residentialAreaRadius, double residentialAreaSensitivity,
-                                       double cityAreaRadius, double cityAreaSensitivity,
-                                       int threads) {
+    public static void calcUrbanDensity(Graph graph, EnumEncodedValue<UrbanDensity> urbanDensityEnc,
+                                        EnumEncodedValue<RoadClass> roadClassEnc, BooleanEncodedValue roadClassLinkEnc,
+                                        double residentialAreaRadius, double residentialAreaSensitivity,
+                                        double cityAreaRadius, double cityAreaSensitivity,
+                                        int threads) {
         logger.info("Calculating residential areas ..., radius={}, sensitivity={}, threads={}", residentialAreaRadius, residentialAreaSensitivity, threads);
         StopWatch sw = StopWatch.started();
-        calcResidential(graph, developmentEnc, roadClassEnc, roadClassLinkEnc, residentialAreaRadius, residentialAreaSensitivity, threads);
+        calcResidential(graph, urbanDensityEnc, roadClassEnc, roadClassLinkEnc, residentialAreaRadius, residentialAreaSensitivity, threads);
         logger.info("Finished calculating residential areas, took: " + sw.stop().getSeconds() + "s");
         if (cityAreaRadius > 1) {
             logger.info("Calculating city areas ..., radius={}, sensitivity={}, threads={}", cityAreaRadius, cityAreaSensitivity, threads);
             sw = StopWatch.started();
-            calcCity(graph, developmentEnc, cityAreaRadius, cityAreaSensitivity, threads);
+            calcCity(graph, urbanDensityEnc, cityAreaRadius, cityAreaSensitivity, threads);
             logger.info("Finished calculating city areas, took: " + sw.stop().getSeconds() + "s");
         }
     }
 
-    private static void calcResidential(Graph graph, EnumEncodedValue<Development> developmentEnc,
+    private static void calcResidential(Graph graph, EnumEncodedValue<UrbanDensity> urbanDensityEnc,
                                         EnumEncodedValue<RoadClass> roadClassEnc, BooleanEncodedValue roadClassLinkEnc,
                                         double radius, double sensitivity, int threads) {
         final ToDoubleFunction<EdgeIteratorState> calcRoadFactor = edge -> {
@@ -103,24 +103,24 @@ private static void calcResidential(Graph graph, EnumEncodedValue<Development> d
             isResidential[edge.getEdge()] = roadDensity * sensitivity >= 1.0;
         }, threads);
         for (int edge = 0; edge < isResidential.length; edge++)
-            graph.getEdgeIteratorState(edge, Integer.MIN_VALUE).set(developmentEnc, isResidential[edge] ? Development.RESIDENTIAL : Development.RURAL);
+            graph.getEdgeIteratorState(edge, Integer.MIN_VALUE).set(urbanDensityEnc, isResidential[edge] ? UrbanDensity.RESIDENTIAL : UrbanDensity.RURAL);
     }
 
-    private static void calcCity(Graph graph, EnumEncodedValue<Development> developmentEnc,
+    private static void calcCity(Graph graph, EnumEncodedValue<UrbanDensity> urbanDensityEnc,
                                  double radius, double sensitivity, int threads) {
-        // do not modify the development values as long as we are still reading them -> store city flags in this array first
+        // do not modify the urban density values as long as we are still reading them -> store city flags in this array first
         boolean[] isCity = new boolean[graph.getEdges()];
-        final ToDoubleFunction<EdgeIteratorState> calcRoadFactor = edge -> edge.get(developmentEnc) == Development.RESIDENTIAL ? 1 : 0;
+        final ToDoubleFunction<EdgeIteratorState> calcRoadFactor = edge -> edge.get(urbanDensityEnc) == UrbanDensity.RESIDENTIAL ? 1 : 0;
         RoadDensityCalculator.calcRoadDensities(graph, (calculator, edge) -> {
-            Development development = edge.get(developmentEnc);
-            if (development == Development.RURAL)
+            UrbanDensity urbanDensity = edge.get(urbanDensityEnc);
+            if (urbanDensity == UrbanDensity.RURAL)
                 return;
             double roadDensity = calculator.calcRoadDensity(edge, radius, calcRoadFactor);
             if (roadDensity * sensitivity >= 1.0)
                 isCity[edge.getEdge()] = true;
         }, threads);
         for (int edge = 0; edge < isCity.length; edge++)
             if (isCity[edge])
-                graph.getEdgeIteratorState(edge, Integer.MIN_VALUE).set(developmentEnc, Development.CITY);
+                graph.getEdgeIteratorState(edge, Integer.MIN_VALUE).set(urbanDensityEnc, UrbanDensity.CITY);
     }
 }
diff --git a/web-bundle/src/main/java/com/graphhopper/resources/MVTResource.java b/web-bundle/src/main/java/com/graphhopper/resources/MVTResource.java
@@ -94,7 +94,7 @@ public Response doGetXyz(
         locationIndex.query(bbox, edgeId -> {
             EdgeIteratorState edge = graphHopper.getBaseGraph().getEdgeIteratorStateForKey(edgeId * 2);
             LineString lineString;
-            if (pathDetails.contains(Development.KEY)) {
+            if (pathDetails.contains(UrbanDensity.KEY)) {
                 if (zInfo >= 9) {
                     PointList pl = edge.fetchWayGeometry(FetchMode.ALL);
                     lineString = pl.toLineString(false);
diff --git a/web-bundle/src/main/resources/com/graphhopper/maps/js/config/tileLayers.js b/web-bundle/src/main/resources/com/graphhopper/maps/js/config/tileLayers.js
@@ -136,15 +136,15 @@ module.exports.enableVectorTiles = function () {
         },
       },
     })
-    var developmentLayer = L.vectorGrid.protobuf("/mvt/{z}/{x}/{y}.mvt?details=max_speed&details=road_class&details=road_environment&details=development", {
+    var urbanDensityLayer = L.vectorGrid.protobuf("/mvt/{z}/{x}/{y}.mvt?details=max_speed&details=road_class&details=road_environment&details=urban_density", {
         rendererFactory: L.canvas.tile,
         maxZoom: 20,
         minZoom: 10,
         interactive: true,
         vectorTileLayerStyles: {
             'roads': function (properties, zoom) {
-                var rd = properties.development;
-                let c = getDevelopmentColor(rd);
+                var ud = properties.urban_density;
+                let c = getUrbanDensityColor(ud);
                 return {
                     weight: 1 + c.weight,
                     color: c.color,
@@ -153,7 +153,7 @@ module.exports.enableVectorTiles = function () {
             },
         },
     });
-    var vtLayers = [vtLayer, developmentLayer];
+    var vtLayers = [vtLayer, urbanDensityLayer];
     for (var i = 0; i < vtLayers.length; ++i) {
         vtLayers[i]
             .on('click', function (e) {
@@ -178,14 +178,14 @@ module.exports.enableVectorTiles = function () {
     }
     overlays = {
         "Local MVT": vtLayer,
-        "Show Development": developmentLayer
+        "Show Urban Density": urbanDensityLayer
     };
 }
 
-function getDevelopmentColor(development) {
+function getUrbanDensityColor(urbanDensity) {
     var color = '#0aaff1';
-    if (development === "residential") color = '#fd084a';
-    else if (development === "city") color = '#edf259';
+    if (urbanDensity === "residential") color = '#fd084a';
+    else if (urbanDensity === "city") color = '#edf259';
     return {
         weight: 1,
         color: color
