fix: optimize marker direction when metro router is relegated to fallbackRoute (#5029)

* fix: optimize marker direction when metro router is relegated to fallbackRoute

Author: GaoFuhong

__tests__/registry/router/metro.spec.ts

@@ -0,0 +1,105 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { Point } from '../../../src/geometry'
+
+const manhattanMock = vi.hoisted(() => vi.fn())
+
+vi.mock('../../../src/registry/router/manhattan/index', () => ({
+  manhattan: manhattanMock,
+}))
+
+import { metro } from '../../../src/registry/router/metro'
+
+describe('metro router', () => {
+  beforeEach(() => {
+    manhattanMock.mockReset()
+  })
+
+  it('should call manhattan with metro defaults', () => {
+    manhattanMock.mockReturnValue([])
+
+    metro.call({} as any, [], {}, {} as any)
+
+    expect(manhattanMock).toHaveBeenCalledTimes(1)
+    const [, options] = manhattanMock.mock.calls[0]
+    expect(options.maxDirectionChange).toBe(45)
+    expect(typeof options.fallbackRoute).toBe('function')
+    expect(typeof options.directions).toBe('function')
+  })
+
+  it('should allow overriding default options', () => {
+    manhattanMock.mockReturnValue([])
+
+    metro.call({} as any, [], { maxDirectionChange: 90 }, {} as any)
+
+    const [, options] = manhattanMock.mock.calls[0]
+    expect(options.maxDirectionChange).toBe(90)
+  })
+
+  it('should generate 8-direction metro directions with diagonal costs', () => {
+    manhattanMock.mockReturnValue([])
+
+    metro.call({} as any, [], { step: 10, cost: 1 } as any, {} as any)
+
+    const [, options] = manhattanMock.mock.calls[0]
+    const dirs = options.directions.call(options)
+
+    expect(dirs).toHaveLength(8)
+    expect(dirs[0]).toMatchObject({ cost: 1, offsetX: 10, offsetY: 0 })
+    expect(dirs[1]).toMatchObject({ cost: 15, offsetX: 10, offsetY: 10 })
+    expect(dirs[2]).toMatchObject({ cost: 1, offsetX: 0, offsetY: 10 })
+    expect(dirs[3]).toMatchObject({ cost: 15, offsetX: -10, offsetY: 10 })
+    expect(dirs[4]).toMatchObject({ cost: 1, offsetX: -10, offsetY: 0 })
+    expect(dirs[5]).toMatchObject({ cost: 15, offsetX: -10, offsetY: -10 })
+    expect(dirs[6]).toMatchObject({ cost: 1, offsetX: 0, offsetY: -10 })
+    expect(dirs[7]).toMatchObject({ cost: 15, offsetX: 10, offsetY: -10 })
+  })
+
+  it('fallbackRoute should not include from/to points and should set previousDirectionAngle', () => {
+    manhattanMock.mockReturnValue([])
+
+    metro.call({} as any, [], {}, {} as any)
+
+    const [, options] = manhattanMock.mock.calls[0]
+    const fallbackRoute = options.fallbackRoute as any
+
+    const resolvedOptions: any = {
+      directions: Array.from({ length: 8 }, () => ({})),
+      previousDirectionAngle: null,
+    }
+
+    const from = new Point(0, 0)
+    const to = new Point(10, 0)
+    const route: Point[] = fallbackRoute(from, to, resolvedOptions)
+
+    expect(route.some((p) => p.equals(from))).toBe(false)
+    expect(route.some((p) => p.equals(to))).toBe(false)
+    expect(typeof resolvedOptions.previousDirectionAngle).toBe('number')
+    expect(resolvedOptions.previousDirectionAngle % 45).toBe(0)
+  })
+
+  it('fallbackRoute should return an intermediate point when lines intersect', () => {
+    manhattanMock.mockReturnValue([])
+
+    metro.call({} as any, [], {}, {} as any)
+
+    const [, options] = manhattanMock.mock.calls[0]
+    const fallbackRoute = options.fallbackRoute as any
+
+    const resolvedOptions: any = {
+      directions: Array.from({ length: 8 }, () => ({})),
+      previousDirectionAngle: null,
+    }
+
+    const from = new Point(0, 0)
+    const to = new Point(100, 80)
+    const route: Point[] = fallbackRoute(from, to, resolvedOptions)
+
+    expect(route.length).toBeLessThanOrEqual(1)
+    if (route.length === 1) {
+      expect(route[0].equals(from)).toBe(false)
+      expect(route[0].equals(to)).toBe(false)
+    }
+    expect(typeof resolvedOptions.previousDirectionAngle).toBe('number')
+    expect(resolvedOptions.previousDirectionAngle % 45).toBe(0)
+  })
+})

src/registry/router/metro.ts

@@ -1,8 +1,12 @@
 import { FunctionExt } from '../../common'
-import { toRad, normalize, Line, Point } from '../../geometry'
+import { Line, normalize, Point, toRad } from '../../geometry'
 import type { RouterDefinition } from './index'
 import { manhattan } from './manhattan/index'
-import { type ManhattanRouterOptions, resolve } from './manhattan/options'
+import {
+  type ManhattanRouterOptions,
+  type ResolvedOptions,
+  resolve,
+} from './manhattan/options'
 
 export interface MetroRouterOptions extends ManhattanRouterOptions {}
 
@@ -28,49 +32,51 @@ const defaults: Partial<MetroRouterOptions> = {
     ]
   },
 
-  // a simple route used in situations when main routing method fails
-  // (exceed max number of loop iterations, inaccessible)
-  fallbackRoute(from, to, options) {
-    // Find a route which breaks by 45 degrees ignoring all obstacles.
-
-    const theta = from.theta(to)
-
-    const route = []
-
-    let a = { x: to.x, y: from.y }
-    let b = { x: from.x, y: to.y }
-
-    if (theta % 180 > 90) {
-      const t = a
-      a = b
-      b = t
-    }
-
-    const p1 = theta % 90 < 45 ? a : b
-    const l1 = new Line(from, p1)
-
-    const alpha = 90 * Math.ceil(theta / 90)
-
-    const p2 = Point.fromPolar(l1.squaredLength(), toRad(alpha + 135), p1)
-    const l2 = new Line(to, p2)
-
-    const intersectionPoint = l1.intersectsWithLine(l2)
-    const point = intersectionPoint || to
-
-    const directionFrom = intersectionPoint ? point : from
-
-    const quadrant = 360 / options.directions.length
-    const angleTheta = directionFrom.theta(to)
-    const normalizedAngle = normalize(angleTheta + quadrant / 2)
-    const directionAngle = quadrant * Math.floor(normalizedAngle / quadrant)
-
-    options.previousDirectionAngle = directionAngle
-
-    if (point) route.push(point.round())
-    route.push(to)
+  fallbackRoute: metroFallbackRoute,
+}
 
-    return route
-  },
+function metroFallbackRoute(
+  this: any,
+  from: Point,
+  to: Point,
+  options: ResolvedOptions,
+) {
+  const theta = from.theta(to)
+  const route: Point[] = []
+
+  let a = { x: to.x, y: from.y }
+  let b = { x: from.x, y: to.y }
+
+  if (theta % 180 > 90) {
+    const t = a
+    a = b
+    b = t
+  }
+
+  const p1 = theta % 90 < 45 ? a : b
+  const l1 = new Line(from, p1)
+
+  const alpha = 90 * Math.ceil(theta / 90)
+
+  const p2 = Point.fromPolar(l1.squaredLength(), toRad(alpha + 135), p1)
+  const l2 = new Line(to, p2)
+
+  const intersectionPoint = l1.intersectsWithLine(l2)
+  const directionFrom = intersectionPoint || from
+  const quadrant = 360 / options.directions.length
+  const angleTheta = directionFrom.theta(to)
+  const normalizedAngle = normalize(angleTheta + quadrant / 2)
+  const directionAngle = quadrant * Math.floor(normalizedAngle / quadrant)
+  options.previousDirectionAngle = directionAngle
+  if (
+    intersectionPoint &&
+    !intersectionPoint.equals(from) &&
+    !intersectionPoint.equals(to)
+  ) {
+    route.push(intersectionPoint.round())
+  }
+
+  return route
 }
 
 export const metro: RouterDefinition<Partial<MetroRouterOptions>> = function (