#369 monitor vector tiles poc - preserve existing tile code

server/src/main/scala/kpn/core/poi/PoiLocation.scala

@@ -3,18 +3,18 @@ package kpn.core.poi
 import java.text.DecimalFormat
 
 import kpn.server.analyzer.engine.tiles.domain.Rectangle
-import kpn.server.analyzer.engine.tiles.domain.Tile
+import kpn.server.analyzer.engine.tiles.domain.OldTile
 
 object PoiLocation {
 
-  val belgiumAndNetherlands: Rectangle = boundsFrom(new Tile(10, 519, 331), new Tile(10, 532, 349))
-  private val germany = boundsFrom(new Tile(10, 535, 355), new Tile(10, 536, 356))
-  private val germanyNorth = boundsFrom(new Tile(10, 531, 330), new Tile(10, 536, 338))
-  private val germanySouth = boundsFrom(new Tile(10, 528, 338), new Tile(10, 537, 344))
-  private val germanyEast = boundsFrom(new Tile(10, 544, 331), new Tile(10, 553, 341))
-  private val austria = boundsFrom(new Tile(10, 552, 358), new Tile(10, 555, 360))
-  private val france = boundsFrom(new Tile(10, 518, 343), new Tile(10, 520, 344))
-  private val spain = boundsFrom(new Tile(10, 508, 380), new Tile(10, 509, 381))
+  val belgiumAndNetherlands: Rectangle = boundsFrom(new OldTile(10, 519, 331), new OldTile(10, 532, 349))
+  private val germany = boundsFrom(new OldTile(10, 535, 355), new OldTile(10, 536, 356))
+  private val germanyNorth = boundsFrom(new OldTile(10, 531, 330), new OldTile(10, 536, 338))
+  private val germanySouth = boundsFrom(new OldTile(10, 528, 338), new OldTile(10, 537, 344))
+  private val germanyEast = boundsFrom(new OldTile(10, 544, 331), new OldTile(10, 553, 341))
+  private val austria = boundsFrom(new OldTile(10, 552, 358), new OldTile(10, 555, 360))
+  private val france = boundsFrom(new OldTile(10, 518, 343), new OldTile(10, 520, 344))
+  private val spain = boundsFrom(new OldTile(10, 508, 380), new OldTile(10, 509, 381))
 
   val allBoundingBoxes: Seq[Rectangle] = Seq(
     belgiumAndNetherlands,
@@ -48,7 +48,7 @@ object PoiLocation {
     }
   }
 
-  private def boundsFrom(topLeftTile: Tile, bottomRightTile: Tile): Rectangle = {
+  private def boundsFrom(topLeftTile: OldTile, bottomRightTile: OldTile): Rectangle = {
     Rectangle(
       xMin = topLeftTile.bounds.xMin,
       xMax = bottomRightTile.bounds.xMax,

server/src/main/scala/kpn/core/tools/analysis/AnalysisStartConfiguration.scala

@@ -36,10 +36,10 @@ import kpn.server.analyzer.engine.analysis.route.analyzers.RouteTileAnalyzer
 import kpn.server.analyzer.engine.changes.ChangeSetContext
 import kpn.server.analyzer.engine.context.AnalysisContext
 import kpn.server.analyzer.engine.context.ElementIds
-import kpn.server.analyzer.engine.tile.LinesTileCalculatorImpl
-import kpn.server.analyzer.engine.tile.NodeTileCalculatorImpl
+import kpn.server.analyzer.engine.tile.OldLinesTileCalculatorImpl
+import kpn.server.analyzer.engine.tile.OldNodeTileCalculatorImpl
 import kpn.server.analyzer.engine.tile.RouteTileCalculatorImpl
-import kpn.server.analyzer.engine.tile.TileCalculatorImpl
+import kpn.server.analyzer.engine.tile.OldTileCalculatorImpl
 import kpn.server.overpass.OverpassRepository
 import kpn.server.overpass.OverpassRepositoryImpl
 import kpn.server.repository.AnalysisRepository
@@ -69,11 +69,11 @@ class AnalysisStartConfiguration(options: AnalysisStartToolOptions) {
 
   private val locationAnalyzer = new LocationAnalyzerImpl(true)
 
-  private val tileCalculator = new TileCalculatorImpl()
+  private val tileCalculator = new OldTileCalculatorImpl()
 
   private val nodeAnalyzer: NodeAnalyzer = {
     val nodeCountryAnalyzer = new NodeCountryAnalyzerImpl(locationAnalyzer)
-    val nodeTileCalculator = new NodeTileCalculatorImpl(tileCalculator)
+    val nodeTileCalculator = new OldNodeTileCalculatorImpl(tileCalculator)
     val nodeTileAnalyzer = new NodeTileAnalyzerImpl(nodeTileCalculator)
     val nodeLocationsAnalyzer = new NodeLocationsAnalyzerImpl(locationAnalyzer)
     val nodeRouteReferencesAnalyzer = new NodeRouteReferencesAnalyzerImpl(nodeRepository)
@@ -86,7 +86,7 @@ class AnalysisStartConfiguration(options: AnalysisStartToolOptions) {
   }
 
   private val routeTileAnalyzer = {
-    val linesTileCalculator = new LinesTileCalculatorImpl(tileCalculator)
+    val linesTileCalculator = new OldLinesTileCalculatorImpl(tileCalculator)
     val routeTileCalculator = new RouteTileCalculatorImpl(linesTileCalculator)
     new RouteTileAnalyzer(routeTileCalculator)
   }

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

@@ -6,9 +6,9 @@ import kpn.core.overpass.OverpassQueryExecutorRemoteImpl
 import kpn.core.overpass.QueryRelationTopLevel
 import kpn.database.util.Mongo
 import kpn.server.analyzer.engine.context.ElementIds
-import kpn.server.analyzer.engine.tile.LinesTileCalculator
-import kpn.server.analyzer.engine.tile.LinesTileCalculatorImpl
-import kpn.server.analyzer.engine.tile.TileCalculatorImpl
+import kpn.server.analyzer.engine.tile.OldLinesTileCalculator
+import kpn.server.analyzer.engine.tile.OldLinesTileCalculatorImpl
+import kpn.server.analyzer.engine.tile.OldTileCalculatorImpl
 import kpn.server.analyzer.engine.tiles.domain.Line
 import kpn.server.analyzer.engine.tiles.domain.Point
 import kpn.server.monitor.repository.MonitorGroupRepository
@@ -30,7 +30,7 @@ object MonitorCreateRelationsTool {
       val routeRepository = new MonitorRouteRepositoryImpl(database)
       val relationRepository = new MonitorRelationRepositoryImpl(database)
       val overpassQueryExecutor = new OverpassQueryExecutorRemoteImpl()
-      val linesTileCalculator = new LinesTileCalculatorImpl(new TileCalculatorImpl())
+      val linesTileCalculator = new OldLinesTileCalculatorImpl(new OldTileCalculatorImpl())
       val tool = new MonitorCreateRelationsTool(
         groupRepository,
         routeRepository,
@@ -48,7 +48,7 @@ class MonitorCreateRelationsTool(
   routeRepository: MonitorRouteRepository,
   relationRepository: MonitorRelationRepository,
   overpassQueryExecutor: OverpassQueryExecutor,
-  linesTileCalculator: LinesTileCalculator
+  linesTileCalculator: OldLinesTileCalculator
 ) {
 
   def createMonitorRelations(): Unit = {

server/src/main/scala/kpn/core/tools/poi/PoiAnalyzerTool.scala

@@ -15,8 +15,8 @@ import kpn.server.analyzer.engine.analysis.location.LocationAnalyzer
 import kpn.server.analyzer.engine.analysis.location.LocationAnalyzerImpl
 import kpn.server.analyzer.engine.poi.PoiScopeAnalyzer
 import kpn.server.analyzer.engine.poi.PoiScopeAnalyzerImpl
-import kpn.server.analyzer.engine.tile.TileCalculator
-import kpn.server.analyzer.engine.tile.TileCalculatorImpl
+import kpn.server.analyzer.engine.tile.OldTileCalculator
+import kpn.server.analyzer.engine.tile.OldTileCalculatorImpl
 import kpn.server.api.analysis.pages.poi.MasterPoiAnalyzer
 import kpn.server.api.analysis.pages.poi.MasterPoiAnalyzerImpl
 import kpn.server.repository.PoiRepository
@@ -37,7 +37,7 @@ object PoiAnalyzerTool {
           val poiRepository = new PoiRepositoryImpl(poiDatabase)
           val locationAnalyzer = new LocationAnalyzerImpl(true)
           val poiScopeAnalyzer = new PoiScopeAnalyzerImpl(locationAnalyzer)
-          val tileCalculator: TileCalculator = new TileCalculatorImpl()
+          val tileCalculator: OldTileCalculator = new OldTileCalculatorImpl()
           val masterPoiAnalyzer = new MasterPoiAnalyzerImpl()
           val tool = new PoiAnalyzerTool(
             poiLoader,
@@ -65,7 +65,7 @@ class PoiAnalyzerTool(
   poiLoader: PoiLoader,
   poiScopeAnalyzer: PoiScopeAnalyzer,
   poiRepository: PoiRepository,
-  tileCalculator: TileCalculator,
+  tileCalculator: OldTileCalculator,
   locationAnalyzer: LocationAnalyzer,
   masterPoiAnalyzer: MasterPoiAnalyzer
 ) {

server/src/main/scala/kpn/core/tools/poi/PoiTileUpdateTool.scala

@@ -4,7 +4,7 @@ import kpn.database.util.Mongo
 import kpn.core.util.Log
 import kpn.server.analyzer.engine.poi.PoiTileBuilderImpl
 import kpn.server.analyzer.engine.poi.PoiTileUpdaterImpl
-import kpn.server.analyzer.engine.tile.TileCalculatorImpl
+import kpn.server.analyzer.engine.tile.OldTileCalculatorImpl
 import kpn.server.analyzer.engine.tiles.TileFileRepositoryImpl
 import kpn.server.analyzer.engine.tiles.vector.PoiVectorTileBuilder
 import kpn.server.repository.PoiRepositoryImpl
@@ -23,7 +23,7 @@ object PoiTileUpdateTool {
             val poiTileBuilder = {
               val tileBuilder = new PoiVectorTileBuilder()
               val poiRepository = new PoiRepositoryImpl(database)
-              val tileCalculator = new TileCalculatorImpl()
+              val tileCalculator = new OldTileCalculatorImpl()
               val tileFileRepository = new TileFileRepositoryImpl(options.tileDir, "mvt")
               new PoiTileBuilderImpl(
                 poiRepository,

server/src/main/scala/kpn/core/tools/tile/TileTool.scala

@@ -6,10 +6,10 @@ import kpn.database.base.Database
 import kpn.database.util.Mongo
 import kpn.core.tools.tile.TileTool.log
 import kpn.core.util.Log
-import kpn.server.analyzer.engine.tile.LinesTileCalculatorImpl
-import kpn.server.analyzer.engine.tile.NodeTileCalculatorImpl
+import kpn.server.analyzer.engine.tile.OldLinesTileCalculatorImpl
+import kpn.server.analyzer.engine.tile.OldNodeTileCalculatorImpl
 import kpn.server.analyzer.engine.tile.RouteTileCalculatorImpl
-import kpn.server.analyzer.engine.tile.TileCalculatorImpl
+import kpn.server.analyzer.engine.tile.OldTileCalculatorImpl
 import kpn.server.analyzer.engine.tile.TileFileBuilderImpl
 import kpn.server.analyzer.engine.tiles.TileAnalyzer
 import kpn.server.analyzer.engine.tiles.TileAnalyzerImpl
@@ -73,12 +73,12 @@ object TileTool {
     }
 
     val tilesBuilder: TilesBuilder = {
-      val tileCalculator = new TileCalculatorImpl()
+      val tileCalculator = new OldTileCalculatorImpl()
       val bitmapTileFileRepository = new TileFileRepositoryImpl(tileDir, "png")
       val vectorTileFileRepository = new TileFileRepositoryImpl(tileDir, "mvt")
       val tileFileBuilder = new TileFileBuilderImpl(bitmapTileFileRepository, vectorTileFileRepository)
-      val nodeTileCalculator = new NodeTileCalculatorImpl(tileCalculator)
-      val linesTileCalculator = new LinesTileCalculatorImpl(tileCalculator)
+      val nodeTileCalculator = new OldNodeTileCalculatorImpl(tileCalculator)
+      val linesTileCalculator = new OldLinesTileCalculatorImpl(tileCalculator)
       val routeTileCalculator = new RouteTileCalculatorImpl(linesTileCalculator)
       new TilesBuilder(
         bitmapTileFileRepository,

server/src/main/scala/kpn/server/analyzer/engine/analysis/node/analyzers/NodeTileAnalyzerImpl.scala

@@ -2,11 +2,11 @@ package kpn.server.analyzer.engine.analysis.node.analyzers
 
 import kpn.api.common.tiles.ZoomLevel
 import kpn.server.analyzer.engine.analysis.node.domain.NodeAnalysis
-import kpn.server.analyzer.engine.tile.NodeTileCalculator
+import kpn.server.analyzer.engine.tile.OldNodeTileCalculator
 import org.springframework.stereotype.Component
 
 @Component
-class NodeTileAnalyzerImpl(nodeTileCalculator: NodeTileCalculator) extends NodeTileAnalyzer {
+class NodeTileAnalyzerImpl(nodeTileCalculator: OldNodeTileCalculator) extends NodeTileAnalyzer {
   override def analyze(analysis: NodeAnalysis): NodeAnalysis = {
     val tiles = (ZoomLevel.nodeMinZoom to ZoomLevel.vectorTileMaxZoom).flatMap { z =>
       nodeTileCalculator.tiles(z, analysis.node)

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

@@ -7,7 +7,7 @@ import kpn.server.analyzer.engine.tiles.domain.Line
 import kpn.server.analyzer.engine.tiles.domain.Point
 import kpn.server.analyzer.engine.tiles.domain.RouteTileInfo
 import kpn.server.analyzer.engine.tiles.domain.RouteTileSegment
-import kpn.server.analyzer.engine.tiles.domain.Tile
+import kpn.server.analyzer.engine.tiles.domain.OldTile
 import org.locationtech.jts.geom.Coordinate
 import org.locationtech.jts.geom.GeometryFactory
 import org.locationtech.jts.geom.LineString
@@ -17,7 +17,7 @@ class RouteSegmentBuilder(zoomLevel: Int) {
 
   private val distanceTolerance = {
     val tileX = (zoomLevel - 7) * 65
-    (Tile.lon(zoomLevel, tileX + 1) - Tile.lon(zoomLevel, tileX)) / 256d
+    (OldTile.lon(zoomLevel, tileX + 1) - OldTile.lon(zoomLevel, tileX)) / 256d
   }
 
   private val geometryFactory = new GeometryFactory

server/src/main/scala/kpn/server/analyzer/engine/poi/PoiChangeAnalyzerImpl.scala

@@ -14,7 +14,7 @@ import kpn.core.poi.PoiDefinition
 import kpn.core.util.Log
 import kpn.server.analyzer.engine.analysis.location.LocationAnalyzer
 import kpn.server.analyzer.engine.changes.changes.OsmChange
-import kpn.server.analyzer.engine.tile.TileCalculator
+import kpn.server.analyzer.engine.tile.OldTileCalculator
 import kpn.server.api.analysis.pages.poi.MasterPoiAnalyzer
 import kpn.server.repository.PoiRepository
 import kpn.server.repository.TaskRepository
@@ -24,7 +24,7 @@ import org.springframework.stereotype.Component
 class PoiChangeAnalyzerImpl(
   knownPoiCache: KnownPoiCache,
   poiRepository: PoiRepository,
-  tileCalculator: TileCalculator,
+  tileCalculator: OldTileCalculator,
   taskRepository: TaskRepository,
   poiScopeAnalyzer: PoiScopeAnalyzer,
   poiQueryExecutor: PoiQueryExecutor,

server/src/main/scala/kpn/server/analyzer/engine/poi/PoiTileBuilderImpl.scala

@@ -1,7 +1,7 @@
 package kpn.server.analyzer.engine.poi
 
 import kpn.core.util.Log
-import kpn.server.analyzer.engine.tile.TileCalculator
+import kpn.server.analyzer.engine.tile.OldTileCalculator
 import kpn.server.analyzer.engine.tiles.PoiTileData
 import kpn.server.analyzer.engine.tiles.TileFileRepository
 import kpn.server.analyzer.engine.tiles.vector.PoiVectorTileBuilder
@@ -11,7 +11,7 @@ import org.springframework.stereotype.Component
 @Component
 class PoiTileBuilderImpl(
   poiRepository: PoiRepository,
-  tileCalculator: TileCalculator,
+  tileCalculator: OldTileCalculator,
   vectorTileRepository: TileFileRepository,
   poiVectorTileBuilder: PoiVectorTileBuilder
 ) extends PoiTileBuilder {

server/src/main/scala/kpn/server/analyzer/engine/poi/PoiTileTask.scala

@@ -1,6 +1,6 @@
 package kpn.server.analyzer.engine.poi
 
-import kpn.server.analyzer.engine.tiles.domain.Tile
+import kpn.server.analyzer.engine.tiles.domain.OldTile
 
 object PoiTileTask {
 
@@ -10,7 +10,7 @@ object PoiTileTask {
     task.substring(prefix.length)
   }
 
-  def withTile(tile: Tile): String = {
+  def withTile(tile: OldTile): String = {
     withTileName(tile.name)
   }
 

server/src/main/scala/kpn/server/analyzer/engine/tile/OldLinesTileCalculator.scala

@@ -0,0 +1,9 @@
+package kpn.server.analyzer.engine.tile
+
+import kpn.server.analyzer.engine.tiles.domain.Line
+import kpn.server.analyzer.engine.tiles.domain.OldTile
+
+trait OldLinesTileCalculator {
+
+  def tiles(z: Int, lines: Seq[Line]): Seq[OldTile]
+}

server/src/main/scala/kpn/server/analyzer/engine/tile/LinesTileCalculatorImpl.scala → server/src/main/scala/kpn/server/analyzer/engine/tile/OldLinesTileCalculatorImpl.scala

@@ -2,16 +2,16 @@ package kpn.server.analyzer.engine.tile
 
 import kpn.server.analyzer.engine.tiles.domain.Line
 import kpn.server.analyzer.engine.tiles.domain.Point
-import kpn.server.analyzer.engine.tiles.domain.Tile
+import kpn.server.analyzer.engine.tiles.domain.OldTile
 import org.springframework.stereotype.Component
 
 @Component
-class LinesTileCalculatorImpl(tileCalculator: TileCalculator) extends LinesTileCalculator {
+class OldLinesTileCalculatorImpl(tileCalculator: OldTileCalculator) extends OldLinesTileCalculator {
 
-  override def tiles(z: Int, lines: Seq[Line]): Seq[Tile] = {
+  override def tiles(z: Int, lines: Seq[Line]): Seq[OldTile] = {
 
-    val tileQueue = scala.collection.mutable.Queue[Tile]()
-    val foundTiles = scala.collection.mutable.Set[Tile]()
+    val tileQueue = scala.collection.mutable.Queue[OldTile]()
+    val foundTiles = scala.collection.mutable.Set[OldTile]()
 
     val tiles = lines.flatMap(_.points).map { p: Point =>
       tileCalculator.tileLonLat(z, p.x, p.y)
@@ -31,10 +31,10 @@ class LinesTileCalculatorImpl(tileCalculator: TileCalculator) extends LinesTileC
   }
 
   private def explore(
-    tileQueue: scala.collection.mutable.Queue[Tile],
-    foundTiles: scala.collection.mutable.Set[Tile],
+    tileQueue: scala.collection.mutable.Queue[OldTile],
+    foundTiles: scala.collection.mutable.Set[OldTile],
     lines: Seq[Line],
-    tile: Tile,
+    tile: OldTile,
     side: Line,
     xDelta: Int,
     yDelta: Int

server/src/main/scala/kpn/server/analyzer/engine/tile/OldNodeTileCalculator.scala

@@ -0,0 +1,9 @@
+package kpn.server.analyzer.engine.tile
+
+import kpn.api.common.LatLon
+import kpn.server.analyzer.engine.tiles.domain.OldTile
+
+trait OldNodeTileCalculator {
+
+  def tiles(z: Int, latLon: LatLon): Seq[OldTile]
+}

server/src/main/scala/kpn/server/analyzer/engine/tile/NodeTileCalculatorImpl.scala → server/src/main/scala/kpn/server/analyzer/engine/tile/OldNodeTileCalculatorImpl.scala

@@ -1,19 +1,19 @@
 package kpn.server.analyzer.engine.tile
 
 import kpn.api.common.LatLon
-import kpn.server.analyzer.engine.tiles.domain.Tile
+import kpn.server.analyzer.engine.tiles.domain.OldTile
 import org.springframework.stereotype.Component
 
 @Component
-class NodeTileCalculatorImpl(tileCalculator: TileCalculator) extends NodeTileCalculator {
+class OldNodeTileCalculatorImpl(tileCalculator: OldTileCalculator) extends OldNodeTileCalculator {
 
-  override def tiles(z: Int, latLon: LatLon): Seq[Tile] = {
+  override def tiles(z: Int, latLon: LatLon): Seq[OldTile] = {
 
     val lon = latLon.lon
     val lat = latLon.lat
 
-    val x = Tile.x(z, lon)
-    val y = Tile.y(z, lat)
+    val x = OldTile.x(z, lon)
+    val y = OldTile.y(z, lat)
 
     Seq(
       Some(tileCalculator.tileXY(z, x, y)),
@@ -28,7 +28,7 @@ class NodeTileCalculatorImpl(tileCalculator: TileCalculator) extends NodeTileCal
     ).flatten
   }
 
-  private def explore(lon: Double, lat: Double, z: Int, x: Int, y: Int): Option[Tile] = {
+  private def explore(lon: Double, lat: Double, z: Int, x: Int, y: Int): Option[OldTile] = {
     val tile = tileCalculator.tileXY(z, x, y)
     if (tile.clipBounds.contains(lon, lat)) Some(tile) else None
   }

server/src/main/scala/kpn/server/analyzer/engine/tile/OldTileCalculator.scala

@@ -0,0 +1,17 @@
+package kpn.server.analyzer.engine.tile
+
+import kpn.api.common.LatLon
+import kpn.core.poi.PoiDefinition
+import kpn.server.analyzer.engine.tiles.domain.OldTile
+
+trait OldTileCalculator {
+
+  def tileLonLat(z: Int, lon: Double, lat: Double): OldTile
+
+  def tileXY(z: Int, x: Int, y: Int): OldTile
+
+  def tileNamed(tileName: String): OldTile
+
+  def poiTiles(latLon: LatLon, poiDefinitions: Seq[PoiDefinition]): Seq[String]
+
+}