#368 migrate route map

frontend/src/app/analysis/route/map/components/route-map.service.ts

@@ -1,7 +1,6 @@
 import { inject } from '@angular/core';
 import { Injectable } from '@angular/core';
-import { RouteMapInfo } from '@api/common/route';
-import { OlUtil } from '@app/ol';
+import { RouteMapPage } from '@api/common/route';
 import { MapPosition } from '@app/ol/domain';
 import { ZoomLevel } from '@app/ol/domain';
 import { OpenDataLayers } from '@app/ol/layers';
@@ -11,22 +10,22 @@ import { MapLayerRegistry } from '@app/ol/layers';
 import { OsmLayer } from '@app/ol/layers';
 import { TileDebug256Layer } from '@app/ol/layers';
 import { NetworkVectorTileLayer } from '@app/ol/layers';
-import { RouteLayers } from '@app/ol/layers';
 import { MapClickService } from '@app/ol/services';
 import { OpenlayersMapService } from '@app/ol/services';
 import { NodeMapStyle } from '@app/ol/style';
 import { Coordinate } from 'ol/coordinate';
 import { Extent } from 'ol/extent';
 import Map from 'ol/Map';
+import { fromLonLat } from 'ol/proj';
 import { ViewOptions } from 'ol/View';
 import View from 'ol/View';
 
 @Injectable()
 export class RouteMapService extends OpenlayersMapService {
   private readonly mapClickService = inject(MapClickService);
 
-  init(routeMapInfo: RouteMapInfo, mapPositionFromUrl: MapPosition, urlLayerIds: string[]): void {
-    this.registerLayers(routeMapInfo, urlLayerIds);
+  init(routeMapPage: RouteMapPage, mapPositionFromUrl: MapPosition, urlLayerIds: string[]): void {
+    this.registerLayers(routeMapPage, urlLayerIds);
 
     let viewOptions: ViewOptions = {
       minZoom: ZoomLevel.minZoom,
@@ -57,33 +56,39 @@ export class RouteMapService extends OpenlayersMapService {
     const view = this.map.getView();
 
     if (!mapPositionFromUrl) {
-      view.fit(this.buildExtent(routeMapInfo));
+      view.fit(this.buildExtent(routeMapPage));
     }
 
     this.finalizeSetup(true);
   }
 
-  private registerLayers(routeMapInfo: RouteMapInfo, urlLayerIds: string[]): void {
+  private registerLayers(page: RouteMapPage, urlLayerIds: string[]): void {
     const networkVectorTileLayer = NetworkVectorTileLayer.build(
-      routeMapInfo.networkType,
+      page.routeMapInfo.networkType,
       new NodeMapStyle().styleFunction()
     );
-    const routeLayers = new RouteLayers(routeMapInfo.map).build();
+    // const routeLayers = new RouteLayers(page.map).build();
     const registry = new MapLayerRegistry();
     registry.register(urlLayerIds, BackgroundLayer.build(), true);
     registry.register(urlLayerIds, OsmLayer.build(), false);
     registry.register(urlLayerIds, networkVectorTileLayer, true);
-    routeLayers.forEach((mapLayer) => registry.register(urlLayerIds, mapLayer, true));
-    OpenDataLayers.register(registry, routeMapInfo.networkType, urlLayerIds);
+    // routeLayers.forEach((mapLayer) => registry.register(urlLayerIds, mapLayer, true));
+    OpenDataLayers.register(registry, page.routeMapInfo.networkType, urlLayerIds);
     registry.register(urlLayerIds, TileDebug256Layer.build(), false);
 
     this.register(registry);
   }
 
-  private buildExtent(routeMapInfo: RouteMapInfo): Extent {
-    const bounds = routeMapInfo.map.bounds;
-    const min = OlUtil.toCoordinate(bounds.latMin, bounds.lonMin);
-    const max = OlUtil.toCoordinate(bounds.latMax, bounds.lonMax);
+  private buildExtent(page: RouteMapPage): Extent {
+    const bounds = page.bounds;
+    const latExtra = (bounds.maxLat - bounds.minLat) / 5;
+    const lonExtra = (bounds.maxLon - bounds.minLon) / 5;
+    const latMinAdjusted = bounds.minLat - latExtra;
+    const latMaxAdjusted = bounds.maxLat + latExtra;
+    const lonMinAdjusted = bounds.minLon - lonExtra;
+    const lonMaxAdjusted = bounds.maxLon + lonExtra;
+    const min = fromLonLat([lonMinAdjusted, latMinAdjusted]);
+    const max = fromLonLat([lonMaxAdjusted, latMaxAdjusted]);
     return [min[0], min[1], max[0], max[1]];
   }
 }

frontend/src/app/analysis/route/map/route-map-page.service.ts

@@ -28,7 +28,7 @@ export class RouteMapPageService {
     const mapPositionString = this.routerService.queryParam('position');
     const mapPositionFromUrl = MapPosition.fromQueryParam(mapPositionString);
     this.routeMapService.init(
-      this.response().result.routeMapInfo,
+      this.response().result,
       mapPositionFromUrl,
       this.routerService.urlLayerIds()
     );

frontend/src/app/api/common/route/route-map-info.ts

@@ -1,11 +1,13 @@
 // this file is generated, please do not modify
 
 import { NetworkType } from '@api/custom';
-import { RouteMap } from './route-map';
+import { RoutePath } from './route-path';
+import { RouteSegment } from './route-segment';
 
 export interface RouteMapInfo {
   readonly routeId: number;
   readonly routeName: string;
   readonly networkType: NetworkType;
-  readonly map: RouteMap;
+  readonly segments: RouteSegment[];
+  readonly paths: RoutePath[];
 }

frontend/src/app/api/common/route/route-map-page.ts

@@ -1,8 +1,10 @@
 // this file is generated, please do not modify
 
+import { Bounds } from '@api/common';
 import { RouteMapInfo } from './route-map-info';
 
 export interface RouteMapPage {
   readonly routeMapInfo: RouteMapInfo;
+  readonly bounds: Bounds;
   readonly changeCount: number;
 }

server/src/main/scala/kpn/api/common/route/RouteMapInfo.scala

@@ -6,5 +6,6 @@ case class RouteMapInfo(
   routeId: Long,
   routeName: String,
   networkType: NetworkType,
-  map: RouteMap
+  segments: Seq[RouteSegment],
+  paths: Seq[RoutePath],
 )

server/src/main/scala/kpn/api/common/route/RouteMapPage.scala

@@ -1,6 +1,9 @@
 package kpn.api.common.route
 
+import kpn.api.common.Bounds
+
 case class RouteMapPage(
   routeMapInfo: RouteMapInfo,
+  bounds: Bounds,
   changeCount: Long
 )

server/src/main/scala/kpn/core/util/Util.scala

@@ -67,15 +67,15 @@ object Util {
 
   def classNameOf(obj: Any): String = obj.getClass.getSimpleName.filterNot(_ == '$')
 
-  def mergeBounds(boundss: Seq[Bounds]): Bounds = {
-    if (boundss.isEmpty) {
+  def mergeBounds(boundsCollection: Seq[Bounds]): Bounds = {
+    if (boundsCollection.isEmpty) {
       Bounds()
     }
     else {
-      val minLat = boundss.map(_.minLat).min
-      val maxLat = boundss.map(_.maxLat).max
-      val minLon = boundss.map(_.minLon).min
-      val maxLon = boundss.map(_.maxLon).max
+      val minLat = boundsCollection.map(_.minLat).min
+      val maxLat = boundsCollection.map(_.maxLat).max
+      val minLon = boundsCollection.map(_.minLon).min
+      val maxLon = boundsCollection.map(_.maxLon).max
       Bounds(
         minLat,
         minLon,

server/src/main/scala/kpn/database/actions/routes/MongoQueryRouteMapInfo.scala

@@ -1,14 +1,15 @@
 package kpn.database.actions.routes
 
 import kpn.api.common.route.RouteMapInfo
-import kpn.database.base.Database
 import kpn.core.util.Log
+import kpn.database.base.Database
 import org.mongodb.scala.model.Aggregates.filter
 import org.mongodb.scala.model.Aggregates.project
 import org.mongodb.scala.model.Filters.equal
 import org.mongodb.scala.model.Projections.computed
 import org.mongodb.scala.model.Projections.excludeId
 import org.mongodb.scala.model.Projections.fields
+import org.mongodb.scala.model.Projections.include
 
 object MongoQueryRouteMapInfo {
   private val log = Log(classOf[MongoQueryRouteMapInfo])
@@ -28,12 +29,13 @@ class MongoQueryRouteMapInfo(database: Database) {
             computed("routeId", "$_id"),
             computed("routeName", "$summary.name"),
             computed("networkType", "$summary.networkType"),
-            computed("map", "$analysis.map"),
+            include("segments"),
+            include("paths"),
           )
         )
       )
       val routeMapInfo = database.routes.optionAggregate[RouteMapInfo](pipeline, log)
-      (s"route map info: ${routeMapInfo.size}", routeMapInfo)
+      (s"route map info", routeMapInfo)
     }
   }
 }

server/src/main/scala/kpn/server/api/analysis/pages/route/RouteMapPageBuilder.scala

@@ -1,9 +1,22 @@
 package kpn.server.api.analysis.pages.route
 
 import kpn.api.common.route.RouteMapPage
+import kpn.core.util.Util
+import kpn.server.repository.ChangeSetRepository
+import kpn.server.repository.RouteRepository
+import org.springframework.stereotype.Component
 
-trait RouteMapPageBuilder {
-
-  def build(routeId: Long): Option[RouteMapPage]
+@Component
+class RouteMapPageBuilder(
+  routeRepository: RouteRepository,
+  changeSetRepository: ChangeSetRepository
+) {
 
+  def build(routeId: Long): Option[RouteMapPage] = {
+    routeRepository.mapInfo(routeId).map { routeMapInfo =>
+      val changeCount = changeSetRepository.routeChangesCount(routeId)
+      val bounds = Util.mergeBounds(routeMapInfo.segments.map(_.bounds))
+      RouteMapPage(routeMapInfo, bounds, changeCount)
+    }
+  }
 }