waveform-analysis 0.1.58 → 0.1.59

package/src/components/interaction/useWaveformZoom.ts

@@ -21,6 +21,11 @@ import {
   transformForDomain,
   type ZoomSeriesGroup,
 } from './zoomConstraints'
+import {
+  emitIndependentWheelZoomEnds,
+  emitSharedWheelZoomEnd,
+  seriesIdentity,
+} from './zoomEventPayload'
 
 interface ZoomContext {
   props: ResolvedWaveformChartProps
@@ -70,9 +75,10 @@ export function useWaveformZoom(context: ZoomContext) {
   let lastSharedZoomGesture: ZoomGestureKind | null = null
   const pendingIndependentZoomTransforms = new Map<number, ZoomTransform>()
   const pendingIndependentZoomGestures = new Map<number, ZoomGestureKind>()
-  const lastIndependentZoomGestures = new Map<number, ZoomGestureKind>()
-  const lastZoomedTrackIndexes = new Set<number>()
+  const lastIndependentWheelSeriesIds = new Map<string, string[]>()
   let wheelZoomEndTimer: ReturnType<typeof setTimeout> | undefined
+  let preservePendingWheelDuringDataRebind = false
+  let zoomBindingEpoch = 0
 
   const scheduleZoomCommit = () => zoomThrottle.schedule(commitPendingZoom)
   const handleSharedZoom = (event: D3ZoomEvent<SVGRectElement, unknown>) => {
@@ -80,8 +86,12 @@ export function useWaveformZoom(context: ZoomContext) {
     cancelPendingHover()
     pendingSharedZoomTransform = event.transform
     pendingSharedZoomGesture = 'wheel'
-    scheduleZoomCommit()
     scheduleWheelZoomEnd()
+    const domain = event.transform
+      .rescaleX(scaleLinear(initialXDomain.value, [0, innerWidth.value]))
+      .domain()
+    emit('zoom-intent', { start: domain[0], end: domain[1], gesture: 'wheel' })
+    scheduleZoomCommit()
   }
   const handleIndependentZoom = (
     event: D3ZoomEvent<SVGRectElement, unknown>,
@@ -91,8 +101,21 @@ export function useWaveformZoom(context: ZoomContext) {
     cancelPendingHover()
     pendingIndependentZoomTransforms.set(trackIndex, event.transform)
     pendingIndependentZoomGestures.set(trackIndex, 'wheel')
-    scheduleZoomCommit()
     scheduleWheelZoomEnd()
+    const track = trackLayouts.value.find((item) => item.index === trackIndex)
+    if (track) {
+      const domain = event.transform
+        .rescaleX(scaleLinear(resolveInitialTrackDomain(track), [0, track.width]))
+        .domain()
+      emit('zoom-intent', {
+        start: domain[0],
+        end: domain[1],
+        trackIndex,
+        seriesIds: track.seriesList.map((series) => series.id),
+        gesture: 'wheel',
+      })
+    }
+    scheduleZoomCommit()
   }
   function commitPendingZoom() {
     if (isPresentationMode.value) {
@@ -113,12 +136,7 @@ export function useWaveformZoom(context: ZoomContext) {
     if (!pendingIndependentZoomTransforms.size) return
     const nextTransforms = [...independentTransforms.value]
     const changedTrackIndexes = Array.from(pendingIndependentZoomTransforms.keys())
-    lastZoomedTrackIndexes.clear()
-    changedTrackIndexes.forEach((trackIndex) => lastZoomedTrackIndexes.add(trackIndex))
-    changedTrackIndexes.forEach((trackIndex) => {
-      const gesture = pendingIndependentZoomGestures.get(trackIndex)
-      if (gesture) lastIndependentZoomGestures.set(trackIndex, gesture)
-    })
+    const changedGestures = new Map(pendingIndependentZoomGestures)
     pendingIndependentZoomTransforms.forEach((transform, trackIndex) => {
       nextTransforms[trackIndex] = transform
     })
@@ -129,69 +147,37 @@ export function useWaveformZoom(context: ZoomContext) {
     changedTrackIndexes.forEach((trackIndex) => {
       const track = tracksByIndex.get(trackIndex)
       if (!track) return
+      if (changedGestures.get(trackIndex) === 'wheel') {
+        const seriesIds = track.seriesList.map((series) => series.id)
+        lastIndependentWheelSeriesIds.set(seriesIdentity(seriesIds), seriesIds)
+      }
       const domain = track.xScale.domain()
       emit('zoom-change', [domain[0], domain[1]])
     })
   }
   const emitZoomEnd = () => {
     if (props.displayMode === 'independent') {
-      const tracksByIndex = new Map(trackLayouts.value.map((track) => [track.index, track]))
-      lastZoomedTrackIndexes.forEach((trackIndex) => {
-        if (lastIndependentZoomGestures.get(trackIndex) !== 'wheel') return
-        const track = tracksByIndex.get(trackIndex)
-        if (!track) return
-        const domain = track.xScale.domain() as [number, number]
-        const yDomain = track.yScale.domain()
-        emit('zoom-end', {
-          start: domain[0],
-          end: domain[1],
-          yStart: yDomain[0],
-          yEnd: yDomain[1],
-          trackIndex,
-          seriesIds: track.seriesList.map((series) => series.id),
-          gesture: 'wheel',
-        })
-      })
-      lastZoomedTrackIndexes.clear()
-      lastIndependentZoomGestures.clear()
+      emitIndependentWheelZoomEnds(emit, trackLayouts.value, lastIndependentWheelSeriesIds.values())
+      lastIndependentWheelSeriesIds.clear()
       return
     }
     if (lastSharedZoomGesture !== 'wheel') {
       lastSharedZoomGesture = null
       return
     }
-    const domain = sharedZoomDomain.value
-    const visibleTracks = trackLayouts.value.filter((track) => track.hasVisibleSeries)
-    if (visibleTracks.length === 1) {
-      const yDomain = visibleTracks[0]?.yScale.domain()
-      emit('zoom-end', {
-        start: domain[0],
-        end: domain[1],
-        yStart: yDomain?.[0],
-        yEnd: yDomain?.[1],
-        gesture: 'wheel',
-      })
-    } else {
-      emit('zoom-end', {
-        start: domain[0],
-        end: domain[1],
-        yRanges: Object.fromEntries(
-          visibleTracks.map((track) => [
-            track.series?.trackId ?? track.series?.id ?? track.id,
-            track.yScale.domain() as [number, number],
-          ]),
-        ),
-        gesture: 'wheel',
-      })
-    }
+    emitSharedWheelZoomEnd(emit, sharedZoomDomain.value, trackLayouts.value)
     lastSharedZoomGesture = null
   }
   const flushPendingZoom = () => {
     zoomThrottle.flush()
     commitPendingZoom()
-    if (lastSharedZoomGesture === 'wheel' || lastIndependentZoomGestures.size) return
+    if (lastSharedZoomGesture === 'wheel' || lastIndependentWheelSeriesIds.size) return
     emitZoomEnd()
   }
+  const handleD3ZoomEnd = (bindingEpoch: number) => {
+    if (bindingEpoch !== zoomBindingEpoch) return
+    flushPendingZoom()
+  }
   function scheduleWheelZoomEnd() {
     if (wheelZoomEndTimer !== undefined) clearTimeout(wheelZoomEndTimer)
     wheelZoomEndTimer = setTimeout(() => {
@@ -199,24 +185,32 @@ export function useWaveformZoom(context: ZoomContext) {
       zoomThrottle.flush()
       commitPendingZoom()
       emitZoomEnd()
+      preservePendingWheelDuringDataRebind = false
     }, WHEEL_ZOOM_DEBOUNCE_MS)
   }
+  const prepareForDataChange = () => {
+    if (wheelZoomEndTimer === undefined) return
+    zoomThrottle.flush()
+    commitPendingZoom()
+    preservePendingWheelDuringDataRebind = true
+  }
   const cancelPendingZoom = () => {
     pendingSharedZoomTransform = null
     pendingSharedZoomGesture = null
     lastSharedZoomGesture = null
     pendingIndependentZoomTransforms.clear()
     pendingIndependentZoomGestures.clear()
-    lastZoomedTrackIndexes.clear()
-    lastIndependentZoomGestures.clear()
+    lastIndependentWheelSeriesIds.clear()
     zoomThrottle.cancel()
+    preservePendingWheelDuringDataRebind = false
     if (wheelZoomEndTimer !== undefined) {
       clearTimeout(wheelZoomEndTimer)
       wheelZoomEndTimer = undefined
     }
   }
-  const clearZoomBindings = () => {
-    cancelPendingZoom()
+  const clearZoomBindings = (preservePendingWheel = false) => {
+    zoomBindingEpoch += 1
+    if (!preservePendingWheel) cancelPendingZoom()
     svgElement.value
       ?.querySelectorAll<SVGRectElement>('.waveform-chart__overlay')
       .forEach((overlay) => select(overlay).on('.zoom', null))
@@ -268,7 +262,9 @@ export function useWaveformZoom(context: ZoomContext) {
     return false
   }
   const configureZoom = () => {
-    clearZoomBindings()
+    const preservePendingWheel = preservePendingWheelDuringDataRebind
+    clearZoomBindings(preservePendingWheel)
+    const bindingEpoch = zoomBindingEpoch
     if (
       isPresentationMode.value ||
       !props.zoomable ||
@@ -303,7 +299,7 @@ export function useWaveformZoom(context: ZoomContext) {
             [track.width, track.height],
           ])
           .on('zoom', (event) => handleIndependentZoom(event, track.index))
-          .on('end', flushPendingZoom)
+          .on('end', () => handleD3ZoomEnd(bindingEpoch))
         zoomBehaviors.set(track.index, behavior)
         synchronizingZoomTransform = true
         try {
@@ -337,7 +333,7 @@ export function useWaveformZoom(context: ZoomContext) {
         [innerWidth.value, innerHeight.value],
       ])
       .on('zoom', handleSharedZoom)
-      .on('end', flushPendingZoom)
+      .on('end', () => handleD3ZoomEnd(bindingEpoch))
     zoomBehaviors.set('shared', behavior)
     synchronizingZoomTransform = true
     try {
@@ -356,5 +352,6 @@ export function useWaveformZoom(context: ZoomContext) {
     canZoomTrack,
     canZoomSharedTracks,
     configureZoom,
+    prepareForDataChange,
   }
 }

package/src/components/interaction/zoomEventPayload.ts

@@ -0,0 +1,88 @@
+import type { TrackLayout } from '../core/types'
+import type { WaveformChartEmit } from '../core/waveformChartTypes'
+
+export function seriesIdentity(seriesIds: readonly string[]) {
+  return [...seriesIds].sort().join('\u0000')
+}
+
+export function findTrackBySeriesIds(
+  trackLayouts: readonly TrackLayout[],
+  seriesIds: readonly string[],
+) {
+  const identity = seriesIdentity(seriesIds)
+  return trackLayouts.find(
+    (track) => seriesIdentity(track.seriesList.map((series) => series.id)) === identity,
+  )
+}
+
+export function emitBoxZoomIntent(
+  emit: WaveformChartEmit,
+  domain: [number, number],
+  track: TrackLayout,
+  independent: boolean,
+) {
+  emit(
+    'zoom-intent',
+    independent
+      ? {
+          start: domain[0],
+          end: domain[1],
+          trackIndex: track.index,
+          seriesIds: track.seriesList.map((series) => series.id),
+          gesture: 'box',
+        }
+      : { start: domain[0], end: domain[1], gesture: 'box' },
+  )
+}
+
+export function emitIndependentWheelZoomEnds(
+  emit: WaveformChartEmit,
+  trackLayouts: readonly TrackLayout[],
+  pendingSeriesIds: Iterable<readonly string[]>,
+) {
+  for (const seriesIds of pendingSeriesIds) {
+    const track = findTrackBySeriesIds(trackLayouts, seriesIds)
+    if (!track) continue
+    const domain = track.xScale.domain() as [number, number]
+    const yDomain = track.yScale.domain()
+    emit('zoom-end', {
+      start: domain[0],
+      end: domain[1],
+      yStart: yDomain[0],
+      yEnd: yDomain[1],
+      trackIndex: track.index,
+      seriesIds: [...seriesIds],
+      gesture: 'wheel',
+    })
+  }
+}
+
+export function emitSharedWheelZoomEnd(
+  emit: WaveformChartEmit,
+  domain: [number, number],
+  trackLayouts: readonly TrackLayout[],
+) {
+  const visibleTracks = trackLayouts.filter((track) => track.hasVisibleSeries)
+  if (visibleTracks.length === 1) {
+    const yDomain = visibleTracks[0]?.yScale.domain()
+    emit('zoom-end', {
+      start: domain[0],
+      end: domain[1],
+      yStart: yDomain?.[0],
+      yEnd: yDomain?.[1],
+      gesture: 'wheel',
+    })
+    return
+  }
+  emit('zoom-end', {
+    start: domain[0],
+    end: domain[1],
+    yRanges: Object.fromEntries(
+      visibleTracks.map((track) => [
+        track.series?.trackId ?? track.series?.id ?? track.id,
+        track.yScale.domain() as [number, number],
+      ]),
+    ),
+    gesture: 'wheel',
+  })
+}

package/src/components/waveformChartCases/zoomIntentAndDataRebind.test.ts

@@ -0,0 +1,213 @@
+import { flushPromises, mount } from '@vue/test-utils'
+import { defineComponent, h, ref } from 'vue'
+import { describe, expect, it, vi } from 'vitest'
+
+import WaveformChart from '../WaveformChart.vue'
+import type { WaveformData } from '../waveform'
+import { resizeObservers } from '../../test/setup'
+import { gridSeries, mountSizedChart } from '../../test/waveformChart'
+
+function seriesWindow(ids: string[]) {
+  return {
+    kind: 'series' as const,
+    series: ids.map((id, index) => ({
+      id,
+      name: id,
+      data: {
+        kind: 'points' as const,
+        points: [
+          { x: 40, y: index },
+          { x: 50, y: index + 1 },
+          { x: 60, y: index + 2 },
+        ],
+      },
+    })),
+  }
+}
+
+function fullSeries(ids: string[]): WaveformData {
+  return {
+    kind: 'series',
+    series: ids.map((id, index) => ({
+      id,
+      name: id,
+      data: {
+        kind: 'points',
+        points: [
+          { x: 0, y: index },
+          { x: 50, y: index + 1 },
+          { x: 100, y: index + 2 },
+        ],
+      },
+    })),
+  }
+}
+
+function configureOverlay(overlay: ReturnType<typeof mount>['element']) {
+  const width = Number(overlay.getAttribute('width'))
+  const height = Number(overlay.getAttribute('height'))
+  Object.defineProperty(overlay, 'getBoundingClientRect', {
+    value: () => ({ left: 0, top: 0, width, height }),
+  })
+  return { width, height }
+}
+
+function dispatchWheel(overlay: Element, deltaY: number, width: number, height: number) {
+  overlay.dispatchEvent(
+    new WheelEvent('wheel', {
+      deltaY,
+      clientX: width / 2,
+      clientY: height / 2,
+      bubbles: true,
+      cancelable: true,
+    }),
+  )
+}
+
+describe('WaveformChart zoom intent and data rebind', () => {
+  it('keeps one shared wheel end after an immediate intent-driven data replacement', async () => {
+    vi.useFakeTimers()
+    try {
+      const data = ref<WaveformData>(fullSeries(['shared']))
+      const host = mount(
+        defineComponent({
+          setup() {
+            return () =>
+              h(WaveformChart, {
+                data: data.value,
+                displayMode: 'separated',
+                initialXDomain: [0, 100],
+                onZoomIntent: () => {
+                  data.value = seriesWindow(['shared'])
+                },
+              })
+          },
+        }),
+      )
+      resizeObservers.at(-1)?.resize(800, 360)
+      await flushPromises()
+
+      const chart = host.findComponent(WaveformChart)
+      const overlay = chart.get('.waveform-chart__overlay')
+      const { width, height } = configureOverlay(overlay.element)
+      dispatchWheel(overlay.element, -4_000, width, height)
+
+      const firstIntent = chart.emitted('zoom-intent')?.[0]?.[0] as {
+        start: number
+        end: number
+      }
+      expect(firstIntent.end - firstIntent.start).toBeCloseTo(2.5)
+      expect(chart.emitted('zoom-change')).toBeUndefined()
+
+      await flushPromises()
+      dispatchWheel(overlay.element, 1_000, width, height)
+      await flushPromises()
+      await vi.advanceTimersByTimeAsync(199)
+      expect(chart.emitted('zoom-end')).toBeUndefined()
+
+      await vi.advanceTimersByTimeAsync(1)
+      await flushPromises()
+      const zoomEnd = chart.emitted('zoom-end')?.[0]?.[0] as { start: number; end: number }
+      expect(chart.emitted('zoom-intent')).toHaveLength(2)
+      expect(chart.emitted('zoom-end')).toHaveLength(1)
+      expect(zoomEnd.end - zoomEnd.start).toBeGreaterThan(firstIntent.end - firstIntent.start)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('retains a pending independent wheel gesture by stable series identity', async () => {
+    vi.useFakeTimers()
+    try {
+      const data = ref<WaveformData>(fullSeries(['channel-a', 'channel-b']))
+      const host = mount(
+        defineComponent({
+          setup() {
+            return () =>
+              h(WaveformChart, {
+                data: data.value,
+                displayMode: 'independent',
+                grid: { rowCount: 1, columnCount: 2 },
+                initialXDomain: [0, 100],
+                onZoomIntent: () => {
+                  data.value = seriesWindow(['channel-b', 'channel-a'])
+                },
+              })
+          },
+        }),
+      )
+      resizeObservers.at(-1)?.resize(800, 360)
+      await flushPromises()
+
+      const chart = host.findComponent(WaveformChart)
+      const overlay = chart.findAll('.waveform-chart__overlay--independent')[0]!
+      const { width, height } = configureOverlay(overlay.element)
+      dispatchWheel(overlay.element, -4_000, width, height)
+      await flushPromises()
+      await vi.advanceTimersByTimeAsync(200)
+      await flushPromises()
+
+      const zoomEnd = chart.emitted('zoom-end')?.[0]?.[0] as {
+        trackIndex: number
+        seriesIds: string[]
+      }
+      expect(chart.emitted('zoom-intent')?.[0]?.[0]).toMatchObject({
+        trackIndex: 0,
+        seriesIds: ['channel-a'],
+        gesture: 'wheel',
+      })
+      expect(zoomEnd).toMatchObject({ trackIndex: 1, seriesIds: ['channel-a'], gesture: 'wheel' })
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('emits box intent with the selected independent series', async () => {
+    const wrapper = await mountSizedChart(fullSeries(['series-a']), { initialXDomain: [0, 100] })
+    const overlay = wrapper.get('.waveform-chart__overlay--independent')
+    const { width, height } = configureOverlay(overlay.element)
+    const dispatchPointer = (type: string, clientX: number, clientY: number) => {
+      const event = new MouseEvent(type, { button: 0, clientX, clientY, bubbles: true })
+      Object.defineProperty(event, 'pointerId', { value: 11 })
+      overlay.element.dispatchEvent(event)
+    }
+
+    dispatchPointer('pointerdown', width * 0.25, height / 2)
+    dispatchPointer('pointermove', width * 0.75, height / 2)
+    dispatchPointer('pointerup', width * 0.75, height / 2)
+    await flushPromises()
+
+    expect(wrapper.emitted('zoom-intent')?.[0]?.[0]).toMatchObject({
+      trackIndex: 0,
+      seriesIds: ['series-a'],
+      gesture: 'box',
+    })
+  })
+
+  it('cancels pending wheel ends when reset or pagination changes the viewport', async () => {
+    vi.useFakeTimers()
+    try {
+      const reset = await mountSizedChart(fullSeries(['reset']), { initialXDomain: [0, 100] })
+      const resetOverlay = reset.get('.waveform-chart__overlay--independent')
+      const resetBounds = configureOverlay(resetOverlay.element)
+      dispatchWheel(resetOverlay.element, -4_000, resetBounds.width, resetBounds.height)
+      ;(reset.vm as unknown as { resetViewport: () => void }).resetViewport()
+      await vi.advanceTimersByTimeAsync(200)
+      expect(reset.emitted('zoom-end')).toBeUndefined()
+
+      const paged = await mountSizedChart(gridSeries(2), {
+        displayMode: 'independent',
+        grid: { rowCount: 1, columnCount: 1 },
+      })
+      const pageOverlay = paged.get('.waveform-chart__overlay--independent')
+      const pageBounds = configureOverlay(pageOverlay.element)
+      dispatchWheel(pageOverlay.element, -4_000, pageBounds.width, pageBounds.height)
+      await paged.get('.ant-pagination-next button').trigger('click')
+      await flushPromises()
+      await vi.advanceTimersByTimeAsync(200)
+      expect(paged.emitted('zoom-end')).toBeUndefined()
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+})

package/src/core/rendering.ts

@@ -1,6 +1,6 @@
 import { bisector } from 'd3'
 
-import type { WaveformPoint } from '@/types'
+import type { WaveformPoint } from '../types'
 import { resolveWaveformPointErrors } from './data'
 import type { ResolvedWaveformRenderingOptions } from './renderingOptions'
 import {

package/src/core/renderingOptions.ts

@@ -3,7 +3,7 @@ import type {
   WaveformSamplingMode,
   WaveformSamplingOptions,
   WaveformSamplingStrategy,
-} from '@/types'
+} from '../types'
 
 export interface ResolvedWaveformSamplingOptions {
   mode: WaveformSamplingMode

package/src/core/workerSampling/multiresolution.ts

@@ -1,4 +1,4 @@
-import type { WaveformPoint } from '@/types'
+import type { WaveformPoint } from '../../types'
 
 import type { WorkerSamplingOutput } from './protocol'
 

package/src/core/workerSampling/protocol.ts

@@ -6,7 +6,7 @@ import type {
   WaveformSamplingDiagnostics,
   WaveformSamplingMode,
   WaveformSamplingStrategy,
-} from '@/types'
+} from '../../types'
 import type { WorkerSamplingDataset } from '../waveformPointSource'
 
 export const DEFAULT_WORKER_SAMPLING_AUTO_THRESHOLD = 1_000

package/src/core/workerSampling/repository.ts

@@ -1,4 +1,4 @@
-import type { WaveformPoint } from '@/types'
+import type { WaveformPoint } from '../../types'
 import type { WorkerSamplingDataset } from '../waveformPointSource'
 import { javascriptSamplingBackend } from './javascriptBackend'
 import {

package/src/core/workerSampling/repositoryDataset.ts

@@ -1,4 +1,4 @@
-import type { WaveformPoint } from '@/types'
+import type { WaveformPoint } from '../../types'
 import type { WorkerSamplingDataset } from '../waveformPointSource'
 import type { WasmDatasetSamplingBackend } from '../wasmSampling'
 import { MultiResolutionSamplingIndex } from './multiresolution'

package/src/core/workerSampling/repositorySupport.ts

@@ -1,6 +1,6 @@
 import { bisector } from 'd3'
 
-import type { WaveformPoint } from '@/types'
+import type { WaveformPoint } from '../../types'
 import {
   DEFAULT_WORKER_SAMPLING_AUTO_THRESHOLD,
   DEFAULT_WORKER_SAMPLING_MAX_POINTS_PER_PIXEL,

package/src/index.ts

@@ -14,6 +14,7 @@ export type {
   WaveformOverlayMode,
   WaveformInteractionMode,
   WaveformXDomainStrategy,
+  WaveformZoomIntentPayload,
   WaveformZoomEndPayload,
   WaveformZoomResetPayload,
   WaveformAnnotationStyle,

package/src/types/chart.ts

@@ -49,6 +49,15 @@ export interface WaveformZoomEndPayload {
   gesture?: 'wheel' | 'box'
 }
 
+/** Describes the X-axis viewport targeted by a user zoom gesture before rendering settles. */
+export interface WaveformZoomIntentPayload {
+  start: number
+  end: number
+  gesture: 'wheel' | 'box'
+  trackIndex?: number
+  seriesIds?: string[]
+}
+
 /** Identifies the viewport reset by a double-click gesture. */
 export interface WaveformZoomResetPayload {
   trackIndex?: number

package/src/types/index.ts

@@ -9,6 +9,7 @@ export type {
   WaveformOverlayMode,
   WaveformInteractionMode,
   WaveformXDomainStrategy,
+  WaveformZoomIntentPayload,
   WaveformZoomEndPayload,
   WaveformZoomResetPayload,
   WaveformAnnotationStyle,

package/src/utils/geometry.ts

@@ -1,4 +1,4 @@
-import type { WaveformDisplayMode } from '@/types'
+import type { WaveformDisplayMode } from '../types'
 
 /**
  * 轨道几何信息