#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)
+ }
+ }
 }