matterviz 0.4.0 → 0.4.2

package/dist/plot/core/components/ReferenceLine.svelte

@@ -40,12 +40,16 @@
   } = $props()
 
   let endpoints = $derived(
-    resolve_line_endpoints(ref_line, { x_min, x_max, y_min, y_max }, {
-      x_scale,
-      x2_scale,
-      y_scale,
-      y2_scale,
-    }),
+    resolve_line_endpoints(
+      ref_line,
+      { x_min, x_max, y_min, y_max },
+      {
+        x_scale,
+        x2_scale,
+        y_scale,
+        y2_scale,
+      },
+    ),
   )
 
   let is_focused = $state(false)
@@ -61,18 +65,16 @@
   let annotation_pos = $derived(
     endpoints && ref_line.annotation
       ? calculate_annotation_position(
-        endpoints[0],
-        endpoints[1],
-        endpoints[2],
-        endpoints[3],
-        ref_line.annotation,
-      )
+          endpoints[0],
+          endpoints[1],
+          endpoints[2],
+          endpoints[3],
+          ref_line.annotation,
+        )
       : null,
   )
 
-  const make_event = (
-    event: MouseEvent | KeyboardEvent | FocusEvent,
-  ): RefLineEvent => ({
+  const make_event = (event: MouseEvent | KeyboardEvent | FocusEvent): RefLineEvent => ({
     event,
     line_idx,
     line_id: ref_line.id,
@@ -152,11 +154,12 @@
       {@const anno_padding = anno.padding ?? 2}
       {@const font_size = parseFloat(String(anno.font_size ?? 12))}
       {@const text_width = anno.text.length * font_size * 0.6}
-      {@const anchor_offset = {
-      start: 0,
-      middle: text_width / 2,
-      end: text_width,
-    }[annotation_pos.text_anchor] ?? 0}
+      {@const anchor_offset =
+        {
+          start: 0,
+          middle: text_width / 2,
+          end: text_width,
+        }[annotation_pos.text_anchor] ?? 0}
       {#if anno.background}
         <rect
           x={annotation_pos.x - anno_padding - anchor_offset}
@@ -167,8 +170,8 @@
           rx="2"
           ry="2"
           transform={annotation_pos.rotation
-          ? `rotate(${annotation_pos.rotation}, ${annotation_pos.x}, ${annotation_pos.y})`
-          : undefined}
+            ? `rotate(${annotation_pos.rotation}, ${annotation_pos.x}, ${annotation_pos.y})`
+            : undefined}
           style:pointer-events="none"
         />
       {/if}
@@ -178,8 +181,8 @@
         text-anchor={annotation_pos.text_anchor}
         dominant-baseline={annotation_pos.dominant_baseline}
         transform={annotation_pos.rotation
-        ? `rotate(${annotation_pos.rotation}, ${annotation_pos.x}, ${annotation_pos.y})`
-        : undefined}
+          ? `rotate(${annotation_pos.rotation}, ${annotation_pos.x}, ${annotation_pos.y})`
+          : undefined}
         fill={anno.color ?? style.color}
         font-size={anno.font_size ?? `12px`}
         font-family={anno.font_family ?? `inherit`}

package/dist/plot/core/components/ReferenceLine3D.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
   // ReferenceLine3D: 3D reference lines for axis-parallel, segments, and extended lines
   // Uses Line2 for proper variable-width lines (WebGL ignores linewidth on basic lines)
-  import type { Point3D, Vec3 } from '../../../math'
+  import type { Point3D, Vec2, Vec3 } from '../../../math'
   import { T, useThrelte } from '@threlte/core'
   import * as THREE from 'three'
   import { Line2 } from 'three/examples/jsm/lines/Line2.js'
@@ -10,10 +10,14 @@
   import { create_to_threejs, span_or } from '../reference-line'
   import type { RefLine3D } from '../types'
 
-  let { ref_line, scene_size = [10, 10, 5], ranges }: {
+  let {
+    ref_line,
+    scene_size = [10, 10, 5],
+    ranges,
+  }: {
     ref_line: RefLine3D
     scene_size?: Vec3
-    ranges: { x: [number, number]; y: [number, number]; z: [number, number] }
+    ranges: { x: Vec2; y: Vec2; z: Vec2 }
   } = $props()
 
   const { size } = useThrelte()
@@ -38,64 +42,57 @@
   ]
 
   // Compute line endpoints based on type
-  let endpoints = $derived.by(
-    (): [Point3D, Point3D] | null => {
-      if (ref_line.visible === false) return null
-      const [x_min, x_max] = span_or(ref_line.x_span, x_range)
-      const [y_min, y_max] = span_or(ref_line.y_span, y_range)
-      const [z_min, z_max] = span_or(ref_line.z_span, z_range)
+  let endpoints = $derived.by((): [Point3D, Point3D] | null => {
+    if (ref_line.visible === false) return null
+    const [x_min, x_max] = span_or(ref_line.x_span, x_range)
+    const [y_min, y_max] = span_or(ref_line.y_span, y_range)
+    const [z_min, z_max] = span_or(ref_line.z_span, z_range)
 
-      if (ref_line.type === `x-axis`) {
-        return endpoints_from([x_min, ref_line.y, ref_line.z], [x_max, ref_line.y, ref_line.z])
-      }
-      if (ref_line.type === `y-axis`) {
-        return endpoints_from([ref_line.x, y_min, ref_line.z], [ref_line.x, y_max, ref_line.z])
-      }
-      if (ref_line.type === `z-axis`) {
-        return endpoints_from([ref_line.x, ref_line.y, z_min], [ref_line.x, ref_line.y, z_max])
-      }
-      if (ref_line.type === `segment`) {
-        return endpoints_from(ref_line.p1, ref_line.p2)
-      }
-      if (ref_line.type === `line`) {
-        // Extend line through two points to bounding box
-        const [p1x, p1y, p1z] = ref_line.p1
-        const [dx, dy, dz] = [
-          ref_line.p2[0] - p1x,
-          ref_line.p2[1] - p1y,
-          ref_line.p2[2] - p1z,
-        ]
-        // Find t values at each boundary plane
-        const t_values = [
-          ...(dx !== 0 ? [(x_min - p1x) / dx, (x_max - p1x) / dx] : []),
-          ...(dy !== 0 ? [(y_min - p1y) / dy, (y_max - p1y) / dy] : []),
-          ...(dz !== 0 ? [(z_min - p1z) / dz, (z_max - p1z) / dz] : []),
-        ]
-        // Keep only t values where the resulting point is inside bounds
-        const eps = 1e-6
-        const valid_t = t_values.filter((t_value) => {
-          const [px, py, pz] = [
-            p1x + t_value * dx,
-            p1y + t_value * dy,
-            p1z + t_value * dz,
-          ]
-          return (
-            px >= x_min - eps && px <= x_max + eps &&
-            py >= y_min - eps && py <= y_max + eps &&
-            pz >= z_min - eps && pz <= z_max + eps
-          )
-        })
-        if (valid_t.length < 2) return null
-        const t_min = Math.min(...valid_t)
-        const t_max = Math.max(...valid_t)
-        return endpoints_from(
-          [p1x + t_min * dx, p1y + t_min * dy, p1z + t_min * dz],
-          [p1x + t_max * dx, p1y + t_max * dy, p1z + t_max * dz],
+    if (ref_line.type === `x-axis`) {
+      return endpoints_from([x_min, ref_line.y, ref_line.z], [x_max, ref_line.y, ref_line.z])
+    }
+    if (ref_line.type === `y-axis`) {
+      return endpoints_from([ref_line.x, y_min, ref_line.z], [ref_line.x, y_max, ref_line.z])
+    }
+    if (ref_line.type === `z-axis`) {
+      return endpoints_from([ref_line.x, ref_line.y, z_min], [ref_line.x, ref_line.y, z_max])
+    }
+    if (ref_line.type === `segment`) {
+      return endpoints_from(ref_line.p1, ref_line.p2)
+    }
+    if (ref_line.type === `line`) {
+      // Extend line through two points to bounding box
+      const [p1x, p1y, p1z] = ref_line.p1
+      const [dx, dy, dz] = [ref_line.p2[0] - p1x, ref_line.p2[1] - p1y, ref_line.p2[2] - p1z]
+      // Find t values at each boundary plane
+      const t_values = [
+        ...(dx !== 0 ? [(x_min - p1x) / dx, (x_max - p1x) / dx] : []),
+        ...(dy !== 0 ? [(y_min - p1y) / dy, (y_max - p1y) / dy] : []),
+        ...(dz !== 0 ? [(z_min - p1z) / dz, (z_max - p1z) / dz] : []),
+      ]
+      // Keep only t values where the resulting point is inside bounds
+      const eps = 1e-6
+      const valid_t = t_values.filter((t_value) => {
+        const [px, py, pz] = [p1x + t_value * dx, p1y + t_value * dy, p1z + t_value * dz]
+        return (
+          px >= x_min - eps &&
+          px <= x_max + eps &&
+          py >= y_min - eps &&
+          py <= y_max + eps &&
+          pz >= z_min - eps &&
+          pz <= z_max + eps
         )
-      }
-      return null
-    },
-  )
+      })
+      if (valid_t.length < 2) return null
+      const t_min = Math.min(...valid_t)
+      const t_max = Math.max(...valid_t)
+      return endpoints_from(
+        [p1x + t_min * dx, p1y + t_min * dy, p1z + t_min * dz],
+        [p1x + t_max * dx, p1y + t_max * dy, p1z + t_max * dz],
+      )
+    }
+    return null
+  })
 
   // Line style (with defaults)
   let style = $derived({

package/dist/plot/core/components/ReferenceLine3D.svelte.d.ts

@@ -1,12 +1,12 @@
-import type { Vec3 } from '../../../math';
+import type { Vec2, Vec3 } from '../../../math';
 import type { RefLine3D } from '../types';
 type $$ComponentProps = {
     ref_line: RefLine3D;
     scene_size?: Vec3;
     ranges: {
-        x: [number, number];
-        y: [number, number];
-        z: [number, number];
+        x: Vec2;
+        y: Vec2;
+        z: Vec2;
     };
 };
 declare const ReferenceLine3D: import("svelte").Component<$$ComponentProps, {}, "">;

package/dist/plot/core/components/ReferencePlane.svelte

@@ -1,16 +1,20 @@
 <script lang="ts">
   // ReferencePlane: 3D reference planes (axis-aligned, normal-defined, or point-defined)
-  import type { Vec3 } from '../../../math'
+  import type { Vec2, Vec3 } from '../../../math'
   import { cross_3d, normalize_vec } from '../../../math'
   import { T } from '@threlte/core'
   import * as THREE from 'three'
   import { create_to_threejs, span_or } from '../reference-line'
   import type { RefPlane } from '../types'
 
-  let { ref_plane, scene_size = [10, 10, 5], ranges }: {
+  let {
+    ref_plane,
+    scene_size = [10, 10, 5],
+    ranges,
+  }: {
     ref_plane: RefPlane
     scene_size?: Vec3
-    ranges: { x: [number, number]; y: [number, number]; z: [number, number] }
+    ranges: { x: Vec2; y: Vec2; z: Vec2 }
   } = $props()
 
   let [scene_x, scene_y, scene_z] = $derived(scene_size)
@@ -101,10 +105,7 @@
     const geo = new THREE.BufferGeometry()
     const [c0, c1, c2, c3] = corners
     const verts = [c0, c1, c2, c0, c2, c3].flatMap((corner) => [corner.x, corner.y, corner.z])
-    geo.setAttribute(
-      `position`,
-      new THREE.BufferAttribute(new Float32Array(verts), 3),
-    )
+    geo.setAttribute(`position`, new THREE.BufferAttribute(new Float32Array(verts), 3))
     geo.computeVertexNormals()
     return geo
   }
@@ -148,9 +149,7 @@
   let wireframe_geometry: THREE.WireframeGeometry | null = $state(null)
 
   $effect(() => {
-    const wf_geo = geometry && style.wireframe
-      ? new THREE.WireframeGeometry(geometry)
-      : null
+    const wf_geo = geometry && style.wireframe ? new THREE.WireframeGeometry(geometry) : null
     wireframe_geometry = wf_geo
     return () => wf_geo?.dispose()
   })

package/dist/plot/core/components/ReferencePlane.svelte.d.ts

@@ -1,12 +1,12 @@
-import type { Vec3 } from '../../../math';
+import type { Vec2, Vec3 } from '../../../math';
 import type { RefPlane } from '../types';
 type $$ComponentProps = {
     ref_plane: RefPlane;
     scene_size?: Vec3;
     ranges: {
-        x: [number, number];
-        y: [number, number];
-        z: [number, number];
+        x: Vec2;
+        y: Vec2;
+        z: Vec2;
     };
 };
 declare const ReferencePlane: import("svelte").Component<$$ComponentProps, {}, "">;

package/dist/plot/core/components/ZeroLines.svelte

@@ -56,32 +56,28 @@
     Math.min(range[0], range[1]) <= 0 && Math.max(range[0], range[1]) >= 0
 </script>
 
-{#if display.x_zero_line && get_scale_type_name(x_scale_type) !== `log` &&
-    !x_is_time && spans_zero(x_range)}
+{#if display.x_zero_line && get_scale_type_name(x_scale_type) !== `log` && !x_is_time && spans_zero(x_range)}
   {@const zero_x = x_scale_fn(0)}
   {#if isFinite(zero_x)}
     <line class="zero-line" x1={zero_x} x2={zero_x} y1={pad.t} y2={height - pad.b} />
   {/if}
 {/if}
 
-{#if display.x2_zero_line && has_x2 && x2_scale_fn && x2_range &&
-    get_scale_type_name(x2_scale_type) !== `log` && !x2_is_time && spans_zero(x2_range)}
+{#if display.x2_zero_line && has_x2 && x2_scale_fn && x2_range && get_scale_type_name(x2_scale_type) !== `log` && !x2_is_time && spans_zero(x2_range)}
   {@const zero_x2 = x2_scale_fn(0)}
   {#if isFinite(zero_x2)}
     <line class="zero-line" x1={zero_x2} x2={zero_x2} y1={pad.t} y2={height - pad.b} />
   {/if}
 {/if}
 
-{#if display.y_zero_line && get_scale_type_name(y_scale_type) !== `log` &&
-    spans_zero(y_range)}
+{#if display.y_zero_line && get_scale_type_name(y_scale_type) !== `log` && spans_zero(y_range)}
   {@const zero_y = y_scale_fn(0)}
   {#if isFinite(zero_y)}
     <line class="zero-line" x1={pad.l} x2={width - pad.r} y1={zero_y} y2={zero_y} />
   {/if}
 {/if}
 
-{#if display.y2_zero_line && has_y2 && y2_scale_fn && y2_range &&
-    get_scale_type_name(y2_scale_type) !== `log` && spans_zero(y2_range)}
+{#if display.y2_zero_line && has_y2 && y2_scale_fn && y2_range && get_scale_type_name(y2_scale_type) !== `log` && spans_zero(y2_range)}
   {@const zero_y2 = y2_scale_fn(0)}
   {#if isFinite(zero_y2)}
     <line class="zero-line" x1={pad.l} x2={width - pad.r} y1={zero_y2} y2={zero_y2} />

package/dist/plot/core/components/ZoomRect.svelte

@@ -4,8 +4,7 @@
   let { start, current }: { start: Point2D | null; current: Point2D | null } = $props()
 </script>
 
-{#if start && current && isFinite(start.x) && isFinite(start.y) &&
-    isFinite(current.x) && isFinite(current.y)}
+{#if start && current && isFinite(start.x) && isFinite(start.y) && isFinite(current.x) && isFinite(current.y)}
   {@const x = Math.min(start.x, current.x)}
   {@const y = Math.min(start.y, current.y)}
   {@const rect_width = Math.abs(start.x - current.x)}

package/dist/plot/core/components/index.d.ts

@@ -8,6 +8,7 @@ export { default as Line } from './Line.svelte';
 export { default as PlotAxis } from './PlotAxis.svelte';
 export { default as PlotControls } from './PlotControls.svelte';
 export { default as PlotLegend } from './PlotLegend.svelte';
+export { default as PlotMarginals } from './PlotMarginals.svelte';
 export { default as PlotTooltip } from './PlotTooltip.svelte';
 export { default as PortalSelect } from './PortalSelect.svelte';
 export { default as ReferenceLine } from './ReferenceLine.svelte';

package/dist/plot/core/components/index.js

@@ -8,6 +8,7 @@ export { default as Line } from './Line.svelte';
 export { default as PlotAxis } from './PlotAxis.svelte';
 export { default as PlotControls } from './PlotControls.svelte';
 export { default as PlotLegend } from './PlotLegend.svelte';
+export { default as PlotMarginals } from './PlotMarginals.svelte';
 export { default as PlotTooltip } from './PlotTooltip.svelte';
 export { default as PortalSelect } from './PortalSelect.svelte';
 export { default as ReferenceLine } from './ReferenceLine.svelte';

package/dist/plot/core/data-cleaning-signal.d.ts

@@ -0,0 +1,46 @@
+export interface OscillationWeights {
+    derivative_variance?: number;
+    amplitude_growth?: number;
+    sign_changes?: number;
+}
+export type SmoothingConfig = {
+    type: `moving_avg`;
+    window: number;
+} | {
+    type: `savgol`;
+    window: number;
+    polynomial_order?: number;
+} | {
+    type: `gaussian`;
+    sigma: number;
+};
+export interface LocalOutlierConfig {
+    window_half?: number;
+    mad_threshold?: number;
+    max_iterations?: number;
+}
+export interface LocalOutlierResult {
+    kept_indices: number[];
+    removed_indices: number[];
+    iterations_used: number;
+}
+export interface InstabilityResult {
+    detected: boolean;
+    onset_index: number;
+    onset_x: number;
+    combined_score: number;
+    method_scores: {
+        derivative_variance: number;
+        amplitude_growth: number;
+        sign_changes: number;
+    };
+}
+export declare function compute_local_variance(values: number[], window_size: number): number[];
+export declare function detect_instability(x_values: readonly number[], y_values: readonly number[], config?: {
+    oscillation_weights?: OscillationWeights;
+    oscillation_threshold?: number;
+    window_size?: number;
+}): InstabilityResult;
+export declare function smooth_moving_average(values: number[], window: number): number[];
+export declare function smooth_savitzky_golay(values: number[], window: number, polynomial_order?: number): number[];
+export declare function remove_local_outliers(y_values: readonly number[], config?: LocalOutlierConfig): LocalOutlierResult;