#369 explore route relations worldwide

server/src/main/scala/kpn/core/tools/monitor/support/MonitorCreateRelationsTool.scala

@@ -4,6 +4,7 @@ import kpn.core.data.Data
 import kpn.core.loadOld.Parser
 import kpn.core.overpass.OverpassQueryExecutorRemoteImpl
 import kpn.core.overpass.QueryRelationTopLevel
+import kpn.core.util.Log
 import kpn.database.base.Database
 import kpn.database.util.Mongo
 import kpn.server.analyzer.engine.context.ElementIds
@@ -41,21 +42,23 @@ object MonitorCreateRelationsTool {
 
 class MonitorCreateRelationsTool(config: MonitorCreateRelationsToolConfig) {
 
+  private val log = Log(classOf[MonitorCreateRelationsTool])
+
   def createMonitorRelations(): Unit = {
-    val relationIds = collectionRelationIds()
-    println(s"collected ${relationIds.size} relation ids")
+    val relationIds = collectRelationIds()
+    log.info(s"collected ${relationIds.size} relation ids")
     relationIds.zipWithIndex.foreach { case (relationId, index) =>
-      println(s"${index + 1}/${relationIds.size}")
+      log.info(s"${index + 1}/${relationIds.size}")
       val monitorRelation = createMonitorRelation(relationId)
       config.relationRepository.save(monitorRelation)
     }
   }
 
-  private def collectionRelationIds(): Seq[Long] = {
+  private def collectRelationIds(): Seq[Long] = {
     val ids = config.groupRepository.groups().sortBy(_.name).flatMap { group =>
-      println(s"group ${group.name}")
+      log.info(s"group ${group.name}")
       config.groupRepository.groupRoutes(group._id).sortBy(_.name).flatMap { route =>
-        println(s"  route ${route.name}")
+        log.info(s"  route ${route.name}")
         route.relation.toSeq.map(_.relationId) ++
           MonitorUtil.subRelationsIn(route).map(_.relationId)
       }

server/src/main/scala/kpn/core/tools/monitor/support/MonitorExploreRelationsTool.scala

@@ -0,0 +1,84 @@
+package kpn.core.tools.monitor.support
+
+import kpn.core.overpass.OverpassQueryExecutor
+import kpn.core.overpass.OverpassQueryExecutorRemoteImpl
+
+import scala.xml.XML
+
+object MonitorExploreRelationsTool {
+  def main(args: Array[String]): Unit = {
+    val overpassQueryExecutor = new OverpassQueryExecutorRemoteImpl()
+    val tool = new MonitorExploreRelationsTool(overpassQueryExecutor)
+    tool.explore()
+  }
+}
+
+case class RouteCount(
+  typeTagValue: String,
+  routeTagValue: String,
+  nodeNetworkCount: Int,
+  noneNodeNetworkCount: Int
+)
+
+class MonitorExploreRelationsTool(overpassQueryExecutor: OverpassQueryExecutor) {
+  def explore(): Unit = {
+    val counts = routeCounts()
+    println(s"|route|type|node_network|other|total|")
+    println("|--|--|--:|--:|--:|")
+    counts.foreach { count =>
+      val count1 = count.nodeNetworkCount
+      val count2 = count.noneNodeNetworkCount
+      val total = count1 + count2
+      println(s"|${count.routeTagValue}|${count.typeTagValue}|$count1|$count2|$total|")
+    }
+    val nodeNetworkCount = counts.map(_.nodeNetworkCount).sum
+    val noneNodeNetworkCount = counts.map(_.noneNodeNetworkCount).sum
+    val grandTotal = nodeNetworkCount + noneNodeNetworkCount
+    println(s"\nnode network routes: $nodeNetworkCount")
+    println(s"\nnon node network routes: $noneNodeNetworkCount")
+    println(s"\ntotal routes: $grandTotal")
+  }
+
+  private def routeCounts(): Seq[RouteCount] = {
+    Seq(
+      "bicycle",
+      "foot",
+      "walking",
+      "hiking",
+      "mtb",
+      "inline_skates",
+      "motorboat",
+      "canoe",
+    ).flatMap { routeTagValue =>
+      Seq(
+        routeCount("route", routeTagValue),
+        routeCount("superroute", routeTagValue),
+      )
+    }
+  }
+
+  private def routeCount(typeTagValue: String, routeTagValue: String): RouteCount = {
+    val routeTags = s"['type'='$typeTagValue']['route'='$routeTagValue']"
+    val nodeNetworkCount = {
+      val query = s"relation$routeTags['network:type'='node_network'];out ids;"
+      queryRouteCount(typeTagValue, routeTagValue, query)
+    }
+    val noneNodeNetworkCount = {
+      val query = s"relation$routeTags['network:type'!='node_network'];out ids;"
+      queryRouteCount(typeTagValue, routeTagValue, query)
+    }
+    RouteCount(
+      typeTagValue,
+      routeTagValue,
+      nodeNetworkCount,
+      noneNodeNetworkCount
+    )
+  }
+
+  private def queryRouteCount(typeTagValue: String, routeTagValue: String, query: String): Int = {
+    val xmlString = overpassQueryExecutor.execute(query)
+    val xml = XML.loadString(xmlString)
+    val ids = (xml.head \ "relation").map(r => (r \ "@id").text)
+    ids.size
+  }
+}