#278 monitor route analysis - wip

server/src/main/scala/kpn/server/analyzer/engine/monitor/MonitorRouteConnectionAnalyzer.scala

@@ -3,9 +3,7 @@ package kpn.server.analyzer.engine.monitor
 import kpn.api.common.data.WayMember
 import kpn.server.analyzer.engine.analysis.route.RouteWay
 
-case class Connection(nodeId1: Long, nodeId2: Long)
-
-class MonitorRouteConnecctionAnalyzer {
+class MonitorRouteConnectionAnalyzer {
 
   def analyze(wayMember1: WayMember, wayMember2: WayMember): Seq[RouteWay] = {
 

server/src/main/scala/kpn/server/analyzer/engine/monitor/MonitorRouteNextRouteAnalyzer.scala

@@ -0,0 +1,38 @@
+package kpn.server.analyzer.engine.monitor
+
+import kpn.api.common.data.WayMember
+import kpn.server.analyzer.engine.analysis.route.RouteWay
+
+class MonitorRouteNextRouteAnalyzer {
+
+  def analyze(nodeId: Long, wayMember: WayMember): Option[RouteWay] = {
+
+    val connectingNodeIds = if (wayMember.role.contains("forward")) {
+      Seq(wayMember.way.nodes.head.id)
+    }
+    else if (wayMember.role.contains("backward")) {
+      Seq(wayMember.way.nodes.last.id)
+    }
+    else {
+      Seq(
+        wayMember.way.nodes.head.id,
+        wayMember.way.nodes.last.id
+      )
+    }
+
+    if (connectingNodeIds.contains(nodeId)) {
+      if (nodeId == wayMember.way.nodes.head.id) {
+        Some(RouteWay(wayMember.way))
+      }
+      else if (nodeId == wayMember.way.nodes.last.id) {
+        Some(RouteWay(wayMember.way, reversed = true))
+      }
+      else {
+        None
+      }
+    }
+    else {
+      None
+    }
+  }
+}

server/src/main/scala/kpn/server/analyzer/engine/monitor/MonitorRouteStructureAnalyzer.scala

@@ -9,7 +9,8 @@ import scala.collection.mutable
 
 class MonitorRouteStructureAnalyzer {
 
-  private val connectionAnalyzer = new MonitorRouteConnecctionAnalyzer
+  private val connectionAnalyzer = new MonitorRouteConnectionAnalyzer
+  private val nextRouteAnalyzer = new MonitorRouteNextRouteAnalyzer
 
   private var startWayMember: Option[WayMember] = None
   private var processedStartWayMember = false
@@ -79,21 +80,18 @@ class MonitorRouteStructureAnalyzer {
   }
 
   private def processNextWayMember(wayMember: WayMember): Unit = {
-    if (endNodeId == wayMember.way.nodes.head.id) {
-      currentSegment.addOne(RouteWay(wayMember.way))
-      endNodeId = wayMember.way.nodes.last.id
-    }
-    else if (endNodeId == wayMember.way.nodes.last.id) {
-      currentSegment.addOne(RouteWay(wayMember.way, reversed = true))
-      endNodeId = wayMember.way.nodes.head.id
-    }
-    else {
-      if (currentSegment.nonEmpty) {
-        segments.addOne(currentSegment.toSeq)
-        currentSegment.clear()
-      }
-      startWayMember = Some(wayMember)
-      processedStartWayMember = false
+    nextRouteAnalyzer.analyze(endNodeId, wayMember) match {
+      case Some(routeWay) =>
+        currentSegment.addOne(routeWay)
+        endNodeId = routeWay.endNode.id
+      case None =>
+        // TODO check self intersection here
+        if (currentSegment.nonEmpty) {
+          segments.addOne(currentSegment.toSeq)
+          currentSegment.clear()
+        }
+        startWayMember = Some(wayMember)
+        processedStartWayMember = false
     }
   }
 

server/src/test/scala/kpn/server/analyzer/engine/monitor/MonitorRouteConnectionAnalyzerTest.scala

@@ -1,11 +1,10 @@
 package kpn.server.analyzer.engine.monitor
 
-import kpn.api.common.SharedTestObjects
 import kpn.api.common.data.WayMember
 import kpn.api.custom.Relation
 import kpn.core.util.UnitTest
 
-class MonitorRouteConnectionAnalyzerTest extends UnitTest with SharedTestObjects {
+class MonitorRouteConnectionAnalyzerTest extends UnitTest {
 
   test("ways sorted") {
     analyze(
@@ -173,7 +172,7 @@ class MonitorRouteConnectionAnalyzerTest extends UnitTest with SharedTestObjects
     val relation = data.relation
     val wayMember1 = relationWayMember(relation, 0)
     val wayMember2 = relationWayMember(relation, 1)
-    val routeWays = new MonitorRouteConnecctionAnalyzer().analyze(wayMember1, wayMember2)
+    val routeWays = new MonitorRouteConnectionAnalyzer().analyze(wayMember1, wayMember2)
     routeWays.zipWithIndex.flatMap { case (routeWay, index) =>
       if (index == 0) routeWay.nodeIds else routeWay.nodeIds.tail
     }

server/src/test/scala/kpn/server/analyzer/engine/monitor/MonitorRouteNextRouteAnalyzerTest.scala

@@ -0,0 +1,65 @@
+package kpn.server.analyzer.engine.monitor
+
+import kpn.api.common.data.WayMember
+import kpn.core.util.UnitTest
+
+class MonitorRouteNextRouteAnalyzerTest extends UnitTest {
+
+  test("connection") {
+    analyze(
+      new MonitorRouteTestData() {
+        memberWay(10, "", 1, 2)
+      }
+    ).shouldMatchTo(Some(false))
+  }
+
+  test("connection to way with forward role") {
+    analyze(
+      new MonitorRouteTestData() {
+        memberWay(10, "forward", 1, 2)
+      }
+    ).shouldMatchTo(Some(false))
+  }
+
+  test("connection to way with backward role") {
+    analyze(
+      new MonitorRouteTestData() {
+        memberWay(10, "backward", 2, 1)
+      }
+    ).shouldMatchTo(Some(true))
+  }
+
+  test("gap") {
+    analyze(
+      new MonitorRouteTestData() {
+        memberWay(10, "", 2, 3)
+      }
+    ).shouldMatchTo(None)
+  }
+
+  test("gap - way with role forward") {
+    analyze(
+      new MonitorRouteTestData() {
+        memberWay(10, "forward", 2, 1)
+      }
+    ).shouldMatchTo(None)
+  }
+
+  test("gap - way with role backward") {
+    analyze(
+      new MonitorRouteTestData() {
+        memberWay(10, "backward", 1, 2)
+      }
+    ).shouldMatchTo(None)
+  }
+
+  private def analyze(data: MonitorRouteTestData): Option[Boolean] = {
+    val relation = data.relation
+    val wayMember = relation.members.head match {
+      case m: WayMember => m
+      case _ => throw new IllegalStateException()
+    }
+    val routeWayOption = new MonitorRouteNextRouteAnalyzer().analyze(1, wayMember)
+    routeWayOption.map(_.reversed)
+  }
+}