waveform-analysis 0.1.48 → 0.1.50

package/src/core/data.ts

@@ -4,8 +4,10 @@ import type {
   WaveformPoint,
   WaveformLineStyle,
   NormalizedWaveformSeries,
+  WaveformTypedValues,
 } from '../types'
 import { ERROR_BAR_DEFAULTS } from '../components/core/constants'
+import { createWaveformPointSource, type WaveformPointSource } from './waveformPointSource'
 
 const DEFAULT_ERROR_BAR_WIDTH = ERROR_BAR_DEFAULTS.WIDTH
 const DEFAULT_ERROR_BAR_CAP_WIDTH = ERROR_BAR_DEFAULTS.CAP_WIDTH
@@ -31,6 +33,95 @@ function normalizeWaveformPoint(point: WaveformPoint): WaveformPoint {
   }
 }
 
+function isWaveformTypedValues(value: unknown): value is WaveformTypedValues {
+  return value instanceof Float32Array || value instanceof Float64Array
+}
+
+function normalizeSampleValues(
+  values: ArrayLike<number>,
+  sampleRate: number,
+  startTime: number | undefined,
+): WaveformPoint[] {
+  if (!Number.isFinite(sampleRate) || sampleRate <= 0) return []
+
+  const normalizedStartTime = Number.isFinite(startTime) ? (startTime ?? 0) : 0
+  const points: WaveformPoint[] = []
+  for (let index = 0; index < values.length; index += 1) {
+    const value = values[index]
+    if (!Number.isFinite(value)) continue
+    points.push({ x: normalizedStartTime + index / sampleRate, y: value })
+  }
+  return points
+}
+
+function normalizeTypedSamples(data: {
+  values: unknown
+  sampleRate: number
+  startTime?: number
+}): WaveformPoint[] {
+  if (
+    !isWaveformTypedValues(data.values) ||
+    !Number.isFinite(data.sampleRate) ||
+    data.sampleRate <= 0 ||
+    (data.startTime !== undefined && !Number.isFinite(data.startTime))
+  ) {
+    return []
+  }
+  return normalizeSampleValues(data.values, data.sampleRate, data.startTime)
+}
+
+function typedPointValuesHaveMatchingLengths(data: {
+  x: unknown
+  y: unknown
+  error?: unknown
+  lowerError?: unknown
+  upperError?: unknown
+}): data is {
+  x: Float64Array
+  y: WaveformTypedValues
+  error?: WaveformTypedValues
+  lowerError?: WaveformTypedValues
+  upperError?: WaveformTypedValues
+} {
+  if (!(data.x instanceof Float64Array) || !isWaveformTypedValues(data.y)) return false
+  const length = data.x.length
+  const values = [data.error, data.lowerError, data.upperError]
+  return (
+    values.every(
+      (value) => value === undefined || (isWaveformTypedValues(value) && value.length === length),
+    ) && data.y.length === length
+  )
+}
+
+function normalizeTypedPoints(data: {
+  x: Float64Array
+  y: WaveformTypedValues
+  error?: WaveformTypedValues
+  lowerError?: WaveformTypedValues
+  upperError?: WaveformTypedValues
+}): WaveformPoint[] {
+  const points: WaveformPoint[] = []
+  let previousX = Number.NEGATIVE_INFINITY
+  let sorted = true
+  for (let index = 0; index < data.x.length; index += 1) {
+    const x = data.x[index]
+    const y = data.y[index]
+    if (!Number.isFinite(x) || !Number.isFinite(y)) continue
+    const normalized = normalizeWaveformPoint({
+      x,
+      y,
+      error: data.error?.[index],
+      lowerError: data.lowerError?.[index],
+      upperError: data.upperError?.[index],
+    })
+    if (normalized.x < previousX) sorted = false
+    previousX = normalized.x
+    points.push(normalized)
+  }
+  if (!sorted) points.sort((left, right) => left.x - right.x)
+  return points
+}
+
 export function resolveWaveformPointErrors(point: WaveformPoint): {
   lower: number
   upper: number
@@ -44,24 +135,21 @@ export function resolveWaveformPointErrors(point: WaveformPoint): {
 
 /**
  * 规范化单波形数据
- * @param data 输入数据（samples 或 points 格式）
+ * @param data 输入数据（对象数组或 TypedArray 格式）
  * @returns 规范化后的点数组
  */
 export function normalizeWaveformData(data: SingleWaveformData): WaveformPoint[] {
   if (data.kind === 'samples') {
-    if (!Number.isFinite(data.sampleRate) || data.sampleRate <= 0) return []
-
-    const startTime = Number.isFinite(data.startTime) ? (data.startTime ?? 0) : 0
-    const points: WaveformPoint[] = []
-    for (let index = 0; index < data.values.length; index += 1) {
-      const value = data.values[index]
-      if (!Number.isFinite(value)) continue
-      points.push({ x: startTime + index / data.sampleRate, y: value })
-    }
+    return normalizeSampleValues(data.values, data.sampleRate, data.startTime)
+  }
 
-    return points
+  if (data.kind === 'typed-samples') {
+    return normalizeTypedSamples(data)
   }
 
+  if (data.kind === 'typed-points')
+    return typedPointValuesHaveMatchingLengths(data) ? normalizeTypedPoints(data) : []
+
   const points: WaveformPoint[] = []
   let previousX = Number.NEGATIVE_INFINITY
   let sorted = true
@@ -77,78 +165,92 @@ export function normalizeWaveformData(data: SingleWaveformData): WaveformPoint[]
   return points
 }
 
-/**
- * 规范化波形系列数据
- * @param data 输入数据（单波形或多通道）
- * @returns 规范化后的系列数组
- */
-export function normalizeWaveformSeries(data: WaveformData): NormalizedWaveformSeries[] {
+export interface NormalizedWaveformSourceSeries extends Omit<NormalizedWaveformSeries, 'points'> {
+  source: WaveformPointSource
+}
+
+function normalizedSeriesOptions(
+  id: string,
+  series: {
+    shotNo?: string
+    trackId?: string
+    name: string
+    unit?: string
+    color?: string
+    lineType?: NormalizedWaveformSeries['lineType']
+    lineStyle?: WaveformLineStyle
+    pointType?: NormalizedWaveformSeries['pointType']
+    errorBar?: { visible?: boolean; color?: string; width?: number; capWidth?: number }
+  },
+) {
+  const requestedLineType = series.lineType ?? 'linear'
+  const lineStyle = normalizeLineStyle(series.lineStyle)
+  const requestedPointType = series.pointType ?? 'none'
+  const errorBarVisible = series.errorBar?.visible === true
+  const lineType =
+    requestedLineType === 'none' && requestedPointType === 'none' && !errorBarVisible
+      ? 'linear'
+      : requestedLineType
+  const width = Number(series.errorBar?.width)
+  const capWidth = Number(series.errorBar?.capWidth)
+  return {
+    id,
+    shotNo: series.shotNo?.trim() || undefined,
+    trackId: series.trackId?.trim() || undefined,
+    name: series.name,
+    unit: series.unit,
+    color: series.color,
+    lineType,
+    lineStyle,
+    pointType: requestedPointType,
+    errorBar: {
+      visible: errorBarVisible,
+      color: series.errorBar?.color,
+      width: Number.isFinite(width) && width > 0 ? width : DEFAULT_ERROR_BAR_WIDTH,
+      capWidth: Number.isFinite(capWidth) && capWidth > 0 ? capWidth : DEFAULT_ERROR_BAR_CAP_WIDTH,
+    },
+  }
+}
+
+/** Internal normalized series which preserves compact TypedArray storage for chart rendering. */
+export function normalizeWaveformSeriesSources(
+  data: WaveformData,
+): NormalizedWaveformSourceSeries[] {
   if (data.kind !== 'series') {
-    const points = normalizeWaveformData(data)
-    return points.length > 0
+    const source = createWaveformPointSource(data, normalizeWaveformData)
+    return source.length
       ? [
           {
-            id: 'series-0',
-            name: '',
-            lineType: 'linear',
-            lineStyle: 'solid',
-            pointType: 'none',
-            errorBar: {
-              visible: false,
-              width: DEFAULT_ERROR_BAR_WIDTH,
-              capWidth: DEFAULT_ERROR_BAR_CAP_WIDTH,
-            },
-            points,
+            ...normalizedSeriesOptions('series-0', { name: '' }),
+            source,
           },
         ]
       : []
   }
 
   const usedIds = new Set<string>()
+  return data.series.flatMap((series, index) => {
+    const id = series.id?.trim() || `series-${index}`
+    let uniqueId = id
+    let suffix = 1
+    while (usedIds.has(uniqueId)) {
+      uniqueId = `${id}-${suffix}`
+      suffix += 1
+    }
+    usedIds.add(uniqueId)
+    const source = createWaveformPointSource(series.data, normalizeWaveformData)
+    return source.length ? [{ ...normalizedSeriesOptions(uniqueId, series), source }] : []
+  })
+}
 
-  return data.series
-    .map((series, index) => {
-      const id = series.id?.trim() || `series-${index}`
-
-      // 确保 ID 唯一，如果重复则添加后缀
-      let uniqueId = id
-      let suffix = 1
-      while (usedIds.has(uniqueId)) {
-        uniqueId = `${id}-${suffix}`
-        suffix++
-      }
-      usedIds.add(uniqueId)
-
-      const requestedLineType = series.lineType ?? 'linear'
-      const lineStyle = normalizeLineStyle((series as { lineStyle?: unknown }).lineStyle)
-      const requestedPointType = series.pointType ?? 'none'
-      const errorBarVisible = series.errorBar?.visible === true
-      const lineType =
-        requestedLineType === 'none' && requestedPointType === 'none' && !errorBarVisible
-          ? 'linear'
-          : requestedLineType
-      const width = Number(series.errorBar?.width)
-      const capWidth = Number(series.errorBar?.capWidth)
-
-      return {
-        id: uniqueId,
-        shotNo: series.shotNo?.trim() || undefined,
-        trackId: series.trackId?.trim() || undefined,
-        name: series.name,
-        unit: series.unit,
-        color: series.color,
-        lineType,
-        lineStyle,
-        pointType: requestedPointType,
-        errorBar: {
-          visible: errorBarVisible,
-          color: series.errorBar?.color,
-          width: Number.isFinite(width) && width > 0 ? width : DEFAULT_ERROR_BAR_WIDTH,
-          capWidth:
-            Number.isFinite(capWidth) && capWidth > 0 ? capWidth : DEFAULT_ERROR_BAR_CAP_WIDTH,
-        },
-        points: normalizeWaveformData(series.data),
-      }
-    })
-    .filter((series) => series.points.length > 0)
+/**
+ * 规范化波形系列数据
+ * @param data 输入数据（单波形或多通道）
+ * @returns 规范化后的系列数组
+ */
+export function normalizeWaveformSeries(data: WaveformData): NormalizedWaveformSeries[] {
+  return normalizeWaveformSeriesSources(data).map(({ source, ...series }) => ({
+    ...series,
+    points: source.pointsInRange(),
+  }))
 }

package/src/core/index.ts

@@ -10,4 +10,15 @@ export {
   selectDecorationPoints,
   selectRenderablePoints,
   type ResolvedWaveformRenderingOptions,
+  type ResolvedWaveformSamplingOptions,
 } from './rendering'
+export {
+  calculateWasmRange,
+  findWasmVisibleRange,
+  initializeWasmSampling,
+  sampleWaveformWasm,
+  type WasmRangeMetrics,
+  type WasmSamplingRequest,
+  type WasmSamplingResult,
+  type WasmSamplingStrategy,
+} from './wasmSampling'

package/src/core/rendering.test.ts

@@ -1,7 +1,8 @@
 import { describe, expect, it } from 'vitest'
 
-import type { WaveformPoint } from '../types'
+import type { WaveformPoint, WaveformRenderingOptions } from '../types'
 import {
+  DEFAULT_WAVEFORM_RENDERING_OPTIONS,
   hasMinimumVisibleXValues,
   resolveWaveformRenderingOptions,
   selectDecorationPoints,
@@ -49,25 +50,80 @@ describe('waveform rendering selection', () => {
         pointMinSpacing: -1,
         errorBarMinSpacing: Number.POSITIVE_INFINITY,
       }),
-    ).toEqual({
-      downsample: true,
-      downsampleThreshold: 2_000,
-      maxPointsPerPixel: 4,
-      pointMinSpacing: 10,
-      errorBarMinSpacing: 12,
-    })
+    ).toEqual(DEFAULT_WAVEFORM_RENDERING_OPTIONS)
   })
 
   it('accepts custom decoration spacing and uses zero to disable it', () => {
     expect(resolveWaveformRenderingOptions({ pointMinSpacing: 6, errorBarMinSpacing: 0 })).toEqual({
-      downsample: true,
-      downsampleThreshold: 2_000,
-      maxPointsPerPixel: 4,
+      ...DEFAULT_WAVEFORM_RENDERING_OPTIONS,
       pointMinSpacing: 6,
       errorBarMinSpacing: 0,
     })
   })
 
+  it('normalizes sampling options with strict runtime validation', () => {
+    const options: WaveformRenderingOptions = {
+      sampling: {
+        mode: 'wasm',
+        autoThreshold: 1_001.9,
+        autoHysteresis: 20.8,
+        strategy: 'minmax',
+        maxPointsPerPixel: 2.5,
+        rawPointLimit: 50_000.2,
+        wasmFailureFallback: 'javascript',
+      },
+    }
+
+    expect(resolveWaveformRenderingOptions(options)).toMatchObject({
+      downsample: true,
+      maxPointsPerPixel: 2.5,
+      sampling: {
+        mode: 'wasm',
+        autoThreshold: 1_001,
+        autoHysteresis: 20,
+        strategy: 'minmax',
+        maxPointsPerPixel: 2.5,
+        rawPointLimit: 50_000,
+        wasmFailureFallback: 'javascript',
+      },
+    })
+
+    expect(
+      resolveWaveformRenderingOptions({
+        sampling: {
+          mode: 'invalid',
+          autoThreshold: 0,
+          autoHysteresis: -1,
+          strategy: 'invalid',
+          maxPointsPerPixel: Number.POSITIVE_INFINITY,
+          rawPointLimit: 0,
+          wasmFailureFallback: 'fallback',
+        },
+      } as unknown as WaveformRenderingOptions),
+    ).toMatchObject({ sampling: DEFAULT_WAVEFORM_RENDERING_OPTIONS.sampling })
+  })
+
+  it('maps legacy downsample flags and gives explicit sampling mode precedence', () => {
+    expect(resolveWaveformRenderingOptions({ downsample: false }).sampling.mode).toBe('raw')
+    expect(resolveWaveformRenderingOptions({ downsample: true }).sampling.mode).toBe('auto')
+    expect(
+      resolveWaveformRenderingOptions({ downsample: false, sampling: { mode: 'wasm' } }),
+    ).toMatchObject({ downsample: true, sampling: { mode: 'wasm' } })
+  })
+
+  it('prefers nested sampling density over the legacy rendering field', () => {
+    const legacy = resolveWaveformRenderingOptions({ maxPointsPerPixel: 2 })
+    const nested = resolveWaveformRenderingOptions({
+      maxPointsPerPixel: 2,
+      sampling: { maxPointsPerPixel: 3 },
+    })
+
+    expect(legacy.maxPointsPerPixel).toBe(2)
+    expect(legacy.sampling.maxPointsPerPixel).toBe(2)
+    expect(nested.maxPointsPerPixel).toBe(3)
+    expect(nested.sampling.maxPointsPerPixel).toBe(3)
+  })
+
   it('selects evenly distributed source points for dense decorations', () => {
     const selected = selectDecorationPoints(points, [0, 9_999], 100, 10, true)
 
@@ -135,7 +191,10 @@ describe('waveform rendering selection', () => {
       densePoints,
       [99_999, 0],
       500,
-      resolveWaveformRenderingOptions({ downsampleThreshold: 100 }),
+      resolveWaveformRenderingOptions({
+        downsampleThreshold: 100,
+        sampling: { autoThreshold: 200_000 },
+      }),
       {
         lineVisible: true,
         pointVisible: true,
@@ -152,6 +211,22 @@ describe('waveform rendering selection', () => {
     expect(selected.errorBarRenderPoints.every((point) => (point.error ?? 0) > 0)).toBe(true)
   })
 
+  it('uses a width-bounded placeholder while large-series Worker sampling is pending', () => {
+    const rendering = resolveWaveformRenderingOptions({
+      sampling: { mode: 'auto', autoThreshold: 1_000, maxPointsPerPixel: 2 },
+    })
+    const selected = selectSeriesRenderPoints(points, [0, 9_999], 100, rendering, {
+      lineVisible: true,
+      pointVisible: false,
+      errorBarVisible: false,
+      hasErrorPoints: false,
+    })
+
+    expect(selected.linePoints).toHaveLength(200)
+    expect(selected.linePoints[0]).toBe(points[0])
+    expect(selected.linePoints.at(-1)).toBe(points.at(-1))
+  })
+
   it('counts unique visible x values across series and reversed domains', () => {
     const first = {
       points: [

package/src/core/rendering.ts

@@ -12,6 +12,7 @@ export {
   DEFAULT_WAVEFORM_RENDERING_OPTIONS,
   resolveWaveformRenderingOptions,
   type ResolvedWaveformRenderingOptions,
+  type ResolvedWaveformSamplingOptions,
 } from './renderingOptions'
 
 const pointBisector = bisector((point: WaveformPoint) => point.x)
@@ -23,6 +24,8 @@ interface PointSeriesSource {
 
 interface SeriesRenderSelectionOptions {
   lineVisible: boolean
+  /** A current Worker result used only for the SVG line. */
+  linePointOverride?: WaveformPoint[]
   pointVisible: boolean
   errorBarVisible: boolean
   hasErrorPoints: boolean
@@ -84,6 +87,34 @@ function selectRenderablePointsInRange(
   })
 }
 
+function shouldDeferLineSampling(
+  visibleCount: number,
+  options: ResolvedWaveformRenderingOptions,
+): boolean {
+  if (options.sampling.mode === 'wasm') return true
+  return options.sampling.mode === 'auto' && visibleCount > options.sampling.autoThreshold
+}
+
+function selectSamplingPlaceholderPoints(
+  points: WaveformPoint[],
+  range: VisiblePointRange,
+  width: number,
+  options: ResolvedWaveformRenderingOptions,
+): WaveformPoint[] {
+  const start = Math.max(0, range.start - 1)
+  const end = Math.min(points.length, range.end + 1)
+  const count = end - start
+  if (count <= 0) return []
+  if (options.sampling.strategy === 'none') return points.slice(start, end)
+  const target = Math.max(1, Math.floor(width * options.sampling.maxPointsPerPixel))
+  if (count <= target) return points.slice(start, end)
+  if (target === 1) return [points[start]!]
+  return Array.from({ length: target }, (_, index) => {
+    const offset = Math.round((index * (count - 1)) / (target - 1))
+    return points[start + offset]!
+  })
+}
+
 /**
  * Select the visible source range and preserve first/min/max/last values in each X bucket.
  * Source points must be sorted by X.
@@ -247,7 +278,10 @@ export function selectSeriesRenderPoints(
   }
   const range = resolveVisiblePointRange(points, domain)
   const linePoints = selection.lineVisible
-    ? selectRenderablePointsInRange(points, range, domain, width, rendering)
+    ? (selection.linePointOverride ??
+      (shouldDeferLineSampling(range.end - range.start, rendering)
+        ? selectSamplingPlaceholderPoints(points, range, width, rendering)
+        : selectRenderablePointsInRange(points, range, domain, width, rendering)))
     : []
   const errorBarVisible = selection.errorBarVisible && selection.hasErrorPoints
   if (selection.pointVisible && errorBarVisible) {

package/src/core/renderingOptions.ts

@@ -1,4 +1,19 @@
-import type { WaveformRenderingOptions } from '@/types'
+import type {
+  WaveformRenderingOptions,
+  WaveformSamplingMode,
+  WaveformSamplingOptions,
+  WaveformSamplingStrategy,
+} from '@/types'
+
+export interface ResolvedWaveformSamplingOptions {
+  mode: WaveformSamplingMode
+  autoThreshold: number
+  autoHysteresis: number
+  strategy: WaveformSamplingStrategy
+  maxPointsPerPixel: number
+  rawPointLimit: number
+  wasmFailureFallback: 'error' | 'javascript'
+}
 
 export interface ResolvedWaveformRenderingOptions {
   downsample: boolean
@@ -6,6 +21,7 @@ export interface ResolvedWaveformRenderingOptions {
   maxPointsPerPixel: number
   pointMinSpacing: number
   errorBarMinSpacing: number
+  sampling: ResolvedWaveformSamplingOptions
 }
 
 export const DEFAULT_WAVEFORM_RENDERING_OPTIONS: ResolvedWaveformRenderingOptions = {
@@ -14,32 +30,125 @@ export const DEFAULT_WAVEFORM_RENDERING_OPTIONS: ResolvedWaveformRenderingOption
   maxPointsPerPixel: 4,
   pointMinSpacing: 10,
   errorBarMinSpacing: 12,
+  sampling: {
+    mode: 'auto',
+    autoThreshold: 1_000,
+    autoHysteresis: 0,
+    strategy: 'peak',
+    maxPointsPerPixel: 4,
+    rawPointLimit: 100_000,
+    wasmFailureFallback: 'error',
+  },
+}
+
+const samplingModes: readonly WaveformSamplingMode[] = ['auto', 'wasm', 'raw']
+const samplingStrategies: readonly WaveformSamplingStrategy[] = [
+  'auto',
+  'none',
+  'peak',
+  'lttb',
+  'average',
+  'min',
+  'max',
+  'minmax',
+  'sum',
+]
+
+function isSamplingMode(value: unknown): value is WaveformSamplingMode {
+  return typeof value === 'string' && samplingModes.includes(value as WaveformSamplingMode)
+}
+
+function isSamplingStrategy(value: unknown): value is WaveformSamplingStrategy {
+  return typeof value === 'string' && samplingStrategies.includes(value as WaveformSamplingStrategy)
+}
+
+function resolveFiniteInteger(value: unknown, minimum: number, fallback: number): number {
+  return typeof value === 'number' && Number.isFinite(value) && value >= minimum
+    ? Math.floor(value)
+    : fallback
+}
+
+function resolvePositiveNumber(value: unknown, fallback: number): number {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : fallback
+}
+
+function resolveNonNegativeNumber(value: number, fallback: number): number {
+  return Number.isFinite(value) && value >= 0 ? value : fallback
+}
+
+function resolveSamplingOptions(
+  options: WaveformSamplingOptions | undefined,
+  legacyDownsample: boolean | undefined,
+  legacyMaxPointsPerPixel: number,
+): ResolvedWaveformSamplingOptions {
+  const mode = isSamplingMode(options?.mode)
+    ? options.mode
+    : legacyDownsample === false
+      ? 'raw'
+      : DEFAULT_WAVEFORM_RENDERING_OPTIONS.sampling.mode
+  const maxPointsPerPixel = resolvePositiveNumber(
+    options?.maxPointsPerPixel,
+    legacyMaxPointsPerPixel,
+  )
+  return {
+    mode,
+    autoThreshold: resolveFiniteInteger(
+      options?.autoThreshold,
+      1,
+      DEFAULT_WAVEFORM_RENDERING_OPTIONS.sampling.autoThreshold,
+    ),
+    autoHysteresis: resolveFiniteInteger(
+      options?.autoHysteresis,
+      0,
+      DEFAULT_WAVEFORM_RENDERING_OPTIONS.sampling.autoHysteresis,
+    ),
+    strategy: isSamplingStrategy(options?.strategy)
+      ? options.strategy
+      : DEFAULT_WAVEFORM_RENDERING_OPTIONS.sampling.strategy,
+    maxPointsPerPixel,
+    rawPointLimit: resolveFiniteInteger(
+      options?.rawPointLimit,
+      1,
+      DEFAULT_WAVEFORM_RENDERING_OPTIONS.sampling.rawPointLimit,
+    ),
+    wasmFailureFallback:
+      options?.wasmFailureFallback === 'javascript' || options?.wasmFailureFallback === 'error'
+        ? options.wasmFailureFallback
+        : DEFAULT_WAVEFORM_RENDERING_OPTIONS.sampling.wasmFailureFallback,
+  }
 }
 
 export function resolveWaveformRenderingOptions(
   options?: WaveformRenderingOptions,
 ): ResolvedWaveformRenderingOptions {
   const threshold = Number(options?.downsampleThreshold)
-  const pointsPerPixel = Number(options?.maxPointsPerPixel)
+  const legacyMaxPointsPerPixel = Number(options?.maxPointsPerPixel)
   const pointMinSpacing = Number(options?.pointMinSpacing)
   const errorBarMinSpacing = Number(options?.errorBarMinSpacing)
+  const resolvedLegacyMaxPointsPerPixel =
+    Number.isFinite(legacyMaxPointsPerPixel) && legacyMaxPointsPerPixel > 0
+      ? legacyMaxPointsPerPixel
+      : DEFAULT_WAVEFORM_RENDERING_OPTIONS.maxPointsPerPixel
+  const sampling = resolveSamplingOptions(
+    options?.sampling,
+    typeof options?.downsample === 'boolean' ? options.downsample : undefined,
+    resolvedLegacyMaxPointsPerPixel,
+  )
   return {
-    downsample: options?.downsample ?? DEFAULT_WAVEFORM_RENDERING_OPTIONS.downsample,
+    downsample: sampling.mode !== 'raw',
     downsampleThreshold:
       Number.isFinite(threshold) && threshold >= 2
         ? Math.floor(threshold)
         : DEFAULT_WAVEFORM_RENDERING_OPTIONS.downsampleThreshold,
-    maxPointsPerPixel:
-      Number.isFinite(pointsPerPixel) && pointsPerPixel > 0
-        ? pointsPerPixel
-        : DEFAULT_WAVEFORM_RENDERING_OPTIONS.maxPointsPerPixel,
-    pointMinSpacing:
-      Number.isFinite(pointMinSpacing) && pointMinSpacing >= 0
-        ? pointMinSpacing
-        : DEFAULT_WAVEFORM_RENDERING_OPTIONS.pointMinSpacing,
-    errorBarMinSpacing:
-      Number.isFinite(errorBarMinSpacing) && errorBarMinSpacing >= 0
-        ? errorBarMinSpacing
-        : DEFAULT_WAVEFORM_RENDERING_OPTIONS.errorBarMinSpacing,
+    maxPointsPerPixel: sampling.maxPointsPerPixel,
+    pointMinSpacing: resolveNonNegativeNumber(
+      pointMinSpacing,
+      DEFAULT_WAVEFORM_RENDERING_OPTIONS.pointMinSpacing,
+    ),
+    errorBarMinSpacing: resolveNonNegativeNumber(
+      errorBarMinSpacing,
+      DEFAULT_WAVEFORM_RENDERING_OPTIONS.errorBarMinSpacing,
+    ),
+    sampling,
   }
 }