#368 improve route tag analysis

server/src/main/scala/kpn/core/tools/next/support/RouteAnalysisTool.scala

@@ -19,7 +19,10 @@ class RouteAnalysisTool(config: AnalysisStartConfiguration) {
 
   def analyze(): Unit = {
     log.info("Start")
-    analyzeRoutes(Seq(13844575L))
+    // analyzeRoutes(Seq(13844575)) // ok route
+    // analyzeRoutes(Seq(8831649)) // LAW-9 deel 1 - 01
+    analyzeRoutes(Seq(3952592)) // broken route
+    // analyzeRoutes(Seq(7973533)) // LAW-9 super route containing other super routes
     buildTiles()
     log.info(s"Done")
   }

server/src/main/scala/kpn/server/analyzer/engine/analysis/route/RouteSegmentAnalysis.scala

@@ -1,8 +1,11 @@
 package kpn.server.analyzer.engine.analysis.route
 
+import kpn.server.analyzer.engine.monitor.structure.Structure
+
 case class RouteSegmentAnalysis(
   osmDistance: Long,
-  routeSegments: Seq[RouteSegmentData]
+  routeSegments: Seq[RouteSegmentData],
+  structure: Structure
 ) {
   def startNodeId: Option[Long] = routeSegments.headOption.map(_.segment.startNodeId)
 

server/src/main/scala/kpn/server/analyzer/engine/analysis/route/analyzers/ExpectedNameRouteAnalyzer.scala

@@ -6,7 +6,12 @@ import kpn.server.analyzer.engine.context.PreconditionMissingException
 
 object ExpectedNameRouteAnalyzer extends RouteAnalyzer {
   def analyze(context: RouteAnalysisContext): RouteAnalysisContext = {
-    new ExpectedNameRouteAnalyzer(context).analyze
+    if (context.nodeNetwork) {
+      new ExpectedNameRouteAnalyzer(context).analyze
+    }
+    else {
+      context
+    }
   }
 }
 

server/src/main/scala/kpn/server/analyzer/engine/analysis/route/analyzers/RouteAnalysisBuilder.scala

@@ -43,7 +43,7 @@ class RouteAnalysisBuilder(context: RouteAnalysisContext) {
       context.routeMap.get,
       context.unexpectedNodeIds.get,
       context.unexpectedRelationIds.get,
-      context.expectedName.get,
+      context.expectedName.getOrElse(""),
       context.structure.get,
       context.routeNodeAnalysis.get
     )

server/src/main/scala/kpn/server/analyzer/engine/analysis/route/analyzers/RouteNameFromNodesAnalyzer.scala

@@ -2,13 +2,18 @@ package kpn.server.analyzer.engine.analysis.route.analyzers
 
 import kpn.api.custom.Fact
 import kpn.core.util.Util.isDigits
+import kpn.server.analyzer.engine.analysis.route.RouteNameAnalysis
 import kpn.server.analyzer.engine.analysis.route.domain.RouteAnalysisContext
-import kpn.server.analyzer.engine.analysis.route.{RouteNameAnalysis, RouteNodeAnalysis}
 import kpn.server.analyzer.engine.context.PreconditionMissingException
 
 object RouteNameFromNodesAnalyzer extends RouteAnalyzer {
   def analyze(context: RouteAnalysisContext): RouteAnalysisContext = {
-    new RouteNameFromNodesAnalyzer(context).analyze
+    if (context.nodeNetwork) {
+      new RouteNameFromNodesAnalyzer(context).analyze
+    }
+    else {
+      context
+    }
   }
 }
 

server/src/main/scala/kpn/server/analyzer/engine/analysis/route/analyzers/RouteNodeAnalyzer.scala

@@ -21,7 +21,12 @@ import scala.collection.mutable.ListBuffer
  */
 object RouteNodeAnalyzer extends RouteAnalyzer {
   def analyze(context: RouteAnalysisContext): RouteAnalysisContext = {
-    new RouteNodeAnalyzer(context).analyze
+    if (context.nodeNetwork) {
+      new RouteNodeAnalyzer(context).analyze
+    }
+    else {
+      context.copy(routeNodeAnalysis = Some(RouteNodeAnalysis()))
+    }
   }
 }
 

server/src/main/scala/kpn/server/analyzer/engine/analysis/route/analyzers/RouteSegmentAnalyzer.scala

@@ -9,6 +9,7 @@ import kpn.server.analyzer.engine.analysis.route.RouteSegmentData
 import kpn.server.analyzer.engine.analysis.route.domain.RouteAnalysisContext
 import kpn.server.analyzer.engine.monitor.MonitorRouteAnalysisSupport
 import kpn.server.analyzer.engine.monitor.structure.ElementDirection
+import kpn.server.analyzer.engine.monitor.structure.StructureAnalyzer
 import kpn.server.analyzer.engine.monitor.structure.StructureElementAnalyzer
 import org.locationtech.jts.geom.Coordinate
 import org.locationtech.jts.geom.GeometryFactory
@@ -46,6 +47,8 @@ class RouteSegmentAnalyzer {
         Seq.empty
     }
 
+    val structure = new StructureAnalyzer().analyze(elementGroups)
+
     val routeSegments = elementGroups.zipWithIndex.flatMap { case (elementGroup, index) =>
       val lineStrings = elementGroup.elements.map { element =>
         val coordinates = element.nodeIds.flatMap(nodeMap.get)
@@ -98,7 +101,8 @@ class RouteSegmentAnalyzer {
 
     RouteSegmentAnalysis(
       osmDistance,
-      routeSegments
+      routeSegments,
+      structure
     )
   }
 }

server/src/main/scala/kpn/server/analyzer/engine/analysis/route/analyzers/RouteStructureAnalyzer.scala

@@ -48,9 +48,11 @@ class RouteStructureAnalyzer(context: RouteAnalysisContext) {
 
   private def analyzeStructure(routeNodeAnalysis: RouteNodeAnalysis): RouteStructure = {
 
+    val networkType = context.networkType.getOrElse(throw new PreconditionMissingException)
+
     if (isAnalysisImpossible(routeNodeAnalysis)) {
       RouteStructure(
-        unusedSegments = new SegmentBuilder(context.networkType, fragmentMap).segments(fragmentMap.ids)
+        unusedSegments = new SegmentBuilder(networkType, fragmentMap).segments(fragmentMap.ids)
       )
     }
     else {

server/src/main/scala/kpn/server/analyzer/engine/analysis/route/analyzers/RouteTagAnalyzer.scala

@@ -4,6 +4,7 @@ import kpn.api.custom.Fact
 import kpn.api.custom.Fact.RouteTagInvalid
 import kpn.api.custom.Fact.RouteTagMissing
 import kpn.api.custom.Fact.RouteUnsupportedNetworkType
+import kpn.api.custom.NetworkType
 import kpn.api.custom.ScopedNetworkType
 import kpn.server.analyzer.engine.analysis.route.domain.RouteAnalysisContext
 
@@ -18,32 +19,39 @@ object RouteTagAnalyzer extends RouteAnalyzer {
 class RouteTagAnalyzer(context: RouteAnalysisContext) {
 
   def analyze: RouteAnalysisContext = {
-
-    val facts = ListBuffer[Fact]()
-
-    val scopedNetworkTypeOption = context.relation.tagValue("network") match {
-      case None => None
-      case Some(key) =>
-        ScopedNetworkType.withKey(key) match {
-          case None =>
-            facts += RouteUnsupportedNetworkType
-            None
-
-          case Some(scopedNetworkType) =>
-            context.relation.tagValue("route") match {
-              case None => facts += RouteTagMissing
-              case Some(routeTagValue) =>
-                if (!context.relation.hasTag("route", scopedNetworkType.networkType.routeTagValues *)) {
-                  facts += RouteTagInvalid
-                }
-            }
-            Some(scopedNetworkType)
-        }
+    if (!context.relation.hasTag("type", "route", "superroute")) {
+      context.copy(abort = true).withFacts(RouteTagMissing)
+    }
+    else {
+      context.relation.tagValue("route") match {
+        case None => context.copy(abort = true).withFacts(RouteTagMissing)
+        case Some(routeTagValue) =>
+          NetworkType.all.find(_.routeTagValues.contains(routeTagValue)) match {
+            case None => context.copy(abort = true).withFacts(RouteUnsupportedNetworkType)
+            case Some(networkType) =>
+              val superRoute = context.relation.hasTag("type", "superroute")
+              val nodeNetwork = context.relation.hasTag("network:type", "node_network")
+              val facts = ListBuffer[Fact]()
+              val scopedNetworkTypeOption = context.relation.tagValue("network") match {
+                case None => None
+                case Some(key) =>
+                  ScopedNetworkType.withKey(key) match {
+                    case None => None
+                    case Some(scopedNetworkType) =>
+                      if (!context.relation.hasTag("route", scopedNetworkType.networkType.routeTagValues *)) {
+                        facts += RouteTagInvalid
+                      }
+                      Some(scopedNetworkType)
+                  }
+              }
+              context.copy(
+                superRoute = superRoute,
+                nodeNetwork = nodeNetwork,
+                networkType = Some(networkType),
+                scopedNetworkTypeOption = scopedNetworkTypeOption
+              ).withFacts(facts.toSeq *)
+          }
+      }
     }
-
-    context.copy(
-      abort = scopedNetworkTypeOption.isEmpty,
-      scopedNetworkTypeOption = scopedNetworkTypeOption
-    ).withFacts(facts.toSeq *)
   }
 }

server/src/main/scala/kpn/server/analyzer/engine/analysis/route/domain/RouteAnalysisContext.scala

@@ -25,12 +25,15 @@ case class RouteAnalysisContext(
   analysisContext: AnalysisContext,
   relation: Relation,
   // analysis results start here...
-  segmentAnalysis: Option[RouteSegmentAnalysis] = None,
-  routeNodeInfos: Map[Long, RouteNodeInfo] = Map.empty,
-  scopedNetworkTypeOption: Option[ScopedNetworkType] = None,
-  country: Option[Country] = None,
   active: Boolean = true,
+  superRoute: Boolean = false,
+  nodeNetwork: Boolean = false,
   proposed: Boolean = false,
+  networkType: Option[NetworkType] = None,
+  scopedNetworkTypeOption: Option[ScopedNetworkType] = None,
+  country: Option[Country] = None,
+  segmentAnalysis: Option[RouteSegmentAnalysis] = None,
+  routeNodeInfos: Map[Long, RouteNodeInfo] = Map.empty,
   facts: Seq[Fact] = Seq.empty,
   unexpectedNodeIds: Option[Seq[Long]] = None,
   unexpectedRelationIds: Option[Seq[Long]] = None,
@@ -62,10 +65,6 @@ case class RouteAnalysisContext(
     }
   }
 
-  def networkType: NetworkType = {
-    scopedNetworkType.networkType
-  }
-
   def withFact(fact: Fact): RouteAnalysisContext = {
     copy(facts = facts :+ fact)
   }

server/src/main/scala/kpn/server/analyzer/engine/monitor/structure/StructureAnalyzer.scala

@@ -6,6 +6,10 @@ class StructureAnalyzer(traceEnabled: Boolean = false) {
 
   def analyze(relation: Relation): Structure = {
     val elementGroups = StructureElementAnalyzer.analyze(relation.members, traceEnabled)
+    analyze(elementGroups)
+  }
+
+  def analyze(elementGroups: Seq[StructureElementGroup]): Structure = {
     if (elementGroups.size != 1) {
       Structure(
         None,