brilliantsole 0.0.29 → 0.0.30

package/src/utils/MathUtils.ts

@@ -3,7 +3,12 @@ import { createConsole } from "./Console.ts";
 
 const _console = createConsole("MathUtils", { log: false });
 
-export function getInterpolation(value: number, min: number, max: number, span: number) {
+export function getInterpolation(
+  value: number,
+  min: number,
+  max: number,
+  span: number
+) {
   if (span == undefined) {
     span = max - min;
   }
@@ -11,6 +16,8 @@ export function getInterpolation(value: number, min: number, max: number, span:
 }
 
 export const Uint16Max = 2 ** 16;
+export const Int16Max = 2 ** 15;
+export const Int16Min = -(2 ** 15) - 1;
 
 function removeLower2Bytes(number: number) {
   const lower2Bytes = number % Uint16Max;
@@ -36,6 +43,44 @@ export interface Vector2 {
   y: number;
 }
 
+export function getVector2Length(vector: Vector2) {
+  const { x, y } = vector;
+  return Math.sqrt(x ** 2 + y ** 2);
+}
+
+export function getVector2Distance(a: Vector2, b: Vector2) {
+  return Math.sqrt((b.x - a.x) ** 2 + (b.y - a.y) ** 2);
+}
+
+export function getVector2DistanceSquared(a: Vector2, b: Vector2) {
+  return (b.x - a.x) ** 2 + (b.y - a.y) ** 2;
+}
+
+export function getVector2Angle(vector: Vector2) {
+  const { x, y } = vector;
+  return Math.atan2(y, x);
+}
+
+export function getVector2Midpoint(a: Vector2, b: Vector2): Vector2 {
+  return {
+    x: (a.x + b.x) / 2,
+    y: (a.y + b.y) / 2,
+  };
+}
+
+export function multiplyVector2ByScalar(
+  vector: Vector2,
+  scalar: number
+): Vector2 {
+  let { x, y } = vector;
+  x *= scalar;
+  y *= scalar;
+  return { x, y };
+}
+export function normalizedVector2(vector: Vector2): Vector2 {
+  return multiplyVector2ByScalar(vector, 1 / getVector2Length(vector));
+}
+
 export interface Vector3 extends Vector2 {
   z: number;
 }
@@ -53,7 +98,10 @@ export interface Euler {
   roll: number;
 }
 
-export function computeVoronoiWeights(points: PressureSensorPosition[], sampleCount = 100000) {
+export function computeVoronoiWeights(
+  points: PressureSensorPosition[],
+  sampleCount = 100000
+) {
   const n = points.length;
   const counts = new Array(n).fill(0);
 
@@ -81,3 +129,41 @@ export function computeVoronoiWeights(points: PressureSensorPosition[], sampleCo
   // Convert counts to weights (sum to 1)
   return counts.map((c) => c / sampleCount);
 }
+
+export function getVector3Length(vector: Vector3) {
+  const { x, y, z } = vector;
+  return Math.sqrt(x ** 2 + y ** 2 + z ** 2);
+}
+
+export function clamp(value: number, min: number = 0, max: number = 1) {
+  return Math.min(Math.max(value, min), max);
+}
+
+export function degToRad(deg: number) {
+  return deg * (Math.PI / 180);
+}
+
+export function radToDeg(rad: number) {
+  return rad * (180 / Math.PI);
+}
+
+export const twoPi = Math.PI * 2;
+export function normalizeRadians(rad: number): number {
+  return ((rad % twoPi) + twoPi) % twoPi;
+}
+
+export function pointInPolygon(pt: Vector2, polygon: Vector2[]): boolean {
+  let inside = false;
+  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+    const xi = polygon[i].x,
+      yi = polygon[i].y;
+    const xj = polygon[j].x,
+      yj = polygon[j].y;
+
+    const intersect =
+      yi > pt.y !== yj > pt.y &&
+      pt.x < ((xj - xi) * (pt.y - yi)) / (yj - yi) + xi;
+    if (intersect) inside = !inside;
+  }
+  return inside;
+}

package/src/utils/ObjectUtils.ts

@@ -3,7 +3,12 @@ export function deepEqual(obj1: any, obj2: any): boolean {
     return true;
   }
 
-  if (typeof obj1 !== "object" || obj1 === null || typeof obj2 !== "object" || obj2 === null) {
+  if (
+    typeof obj1 !== "object" ||
+    obj1 === null ||
+    typeof obj2 !== "object" ||
+    obj2 === null
+  ) {
     return false;
   }
 

package/src/utils/PathUtils.ts

@@ -0,0 +1,192 @@
+import { createConsole } from "./Console.ts";
+import opentype from "opentype.js";
+import { Vector2 } from "./MathUtils.ts";
+
+const _console = createConsole("PathUtils", { log: false });
+
+type PathCommand = opentype.PathCommand;
+
+function perpendicularDistance(p: Vector2, p1: Vector2, p2: Vector2): number {
+  const dx = p2.x - p1.x;
+  const dy = p2.y - p1.y;
+  if (dx === 0 && dy === 0) return Math.hypot(p.x - p1.x, p.y - p1.y);
+  const t = ((p.x - p1.x) * dx + (p.y - p1.y) * dy) / (dx * dx + dy * dy);
+  const projX = p1.x + t * dx;
+  const projY = p1.y + t * dy;
+  return Math.hypot(p.x - projX, p.y - projY);
+}
+
+function rdp(points: Vector2[], epsilon: number): Vector2[] {
+  if (points.length < 3) return points;
+  let maxDist = 0;
+  let index = 0;
+  for (let i = 1; i < points.length - 1; i++) {
+    const d = perpendicularDistance(
+      points[i],
+      points[0],
+      points[points.length - 1]
+    );
+    if (d > maxDist) {
+      maxDist = d;
+      index = i;
+    }
+  }
+  if (maxDist > epsilon) {
+    const left = rdp(points.slice(0, index + 1), epsilon);
+    const right = rdp(points.slice(index), epsilon);
+    return left.slice(0, -1).concat(right);
+  }
+  return [points[0], points[points.length - 1]];
+}
+
+// Linear interpolation
+function lerp(a: number, b: number, t: number) {
+  return a + (b - a) * t;
+}
+
+// Sample quadratic Bezier
+function sampleQuadratic(
+  p0: Vector2,
+  p1: Vector2,
+  p2: Vector2,
+  steps: number = 5
+): Vector2[] {
+  const points: Vector2[] = [];
+  for (let i = 0; i <= steps; i++) {
+    const t = i / steps;
+    const x = (1 - t) ** 2 * p0.x + 2 * (1 - t) * t * p1.x + t ** 2 * p2.x;
+    const y = (1 - t) ** 2 * p0.y + 2 * (1 - t) * t * p1.y + t ** 2 * p2.y;
+    points.push({ x, y });
+  }
+  return points;
+}
+
+// Sample cubic Bezier
+function sampleCubic(
+  p0: Vector2,
+  p1: Vector2,
+  p2: Vector2,
+  p3: Vector2,
+  steps: number = 5
+): Vector2[] {
+  const points: Vector2[] = [];
+  for (let i = 0; i <= steps; i++) {
+    const t = i / steps;
+    const mt = 1 - t;
+    const x =
+      mt ** 3 * p0.x +
+      3 * mt ** 2 * t * p1.x +
+      3 * mt * t ** 2 * p2.x +
+      t ** 3 * p3.x;
+    const y =
+      mt ** 3 * p0.y +
+      3 * mt ** 2 * t * p1.y +
+      3 * mt * t ** 2 * p2.y +
+      t ** 3 * p3.y;
+    points.push({ x, y });
+  }
+  return points;
+}
+
+function areCollinear(
+  p1: Vector2,
+  p2: Vector2,
+  p3: Vector2,
+  epsilon = 1e-6
+): boolean {
+  // Vector p1->p2
+  const dx1 = p2.x - p1.x;
+  const dy1 = p2.y - p1.y;
+
+  // Vector p2->p3
+  const dx2 = p3.x - p2.x;
+  const dy2 = p3.y - p2.y;
+
+  // Cross product
+  const cross = dx1 * dy2 - dy1 * dx2;
+  return Math.abs(cross) < epsilon;
+}
+
+export function simplifyPath(
+  commands: PathCommand[],
+  epsilon = 1
+): PathCommand[] {
+  const simplified: PathCommand[] = [];
+  let cursor: Vector2 = { x: 0, y: 0 };
+
+  for (let i = 0; i < commands.length; i++) {
+    const cmd = commands[i];
+
+    switch (cmd.type) {
+      case "M":
+        simplified.push({ ...cmd });
+        cursor = { x: cmd.x, y: cmd.y };
+        break;
+
+      case "L": {
+        // Merge collinear lines
+        const nextPoint = { x: cmd.x, y: cmd.y };
+        const lastCmd = simplified[simplified.length - 1];
+        if (
+          lastCmd &&
+          lastCmd.type === "L" &&
+          simplified.length >= 2 &&
+          areCollinear(
+            simplified[simplified.length - 2] as Vector2,
+            lastCmd as Vector2,
+            nextPoint
+          )
+        ) {
+          // Remove middle collinear point
+          simplified.pop();
+        }
+        simplified.push({ ...cmd });
+        cursor = nextPoint;
+        break;
+      }
+
+      case "Q": {
+        const p0 = cursor;
+        const p1 = { x: cmd.x1, y: cmd.y1 };
+        const p2 = { x: cmd.x, y: cmd.y };
+
+        // Sample points along the curve
+        const sampled = sampleQuadratic(p0, p1, p2, 5);
+        const simplifiedPoints = rdp(sampled, epsilon);
+
+        // If curve is almost straight, convert to a line
+        if (simplifiedPoints.length === 2) {
+          simplified.push({ type: "L", x: p2.x, y: p2.y });
+        } else {
+          simplified.push({ ...cmd }); // Keep the curve
+        }
+        cursor = p2;
+        break;
+      }
+
+      case "C": {
+        const p0 = cursor;
+        const p1 = { x: cmd.x1, y: cmd.y1 };
+        const p2 = { x: cmd.x2, y: cmd.y2 };
+        const p3 = { x: cmd.x, y: cmd.y };
+
+        const sampled = sampleCubic(p0, p1, p2, p3, 5);
+        const simplifiedPoints = rdp(sampled, epsilon);
+
+        if (simplifiedPoints.length === 2) {
+          simplified.push({ type: "L", x: p3.x, y: p3.y });
+        } else {
+          simplified.push({ ...cmd }); // Keep the curve
+        }
+        cursor = p3;
+        break;
+      }
+
+      case "Z":
+        simplified.push({ ...cmd });
+        break;
+    }
+  }
+
+  return simplified;
+}

package/src/utils/RangeHelper.ts

@@ -1,6 +1,6 @@
 import { getInterpolation } from "./MathUtils.ts";
 
-interface Range {
+export interface Range {
   min: number;
   max: number;
   span: number;
@@ -9,13 +9,20 @@ interface Range {
 const initialRange: Range = { min: Infinity, max: -Infinity, span: 0 };
 
 class RangeHelper {
-  #range: Range = Object.assign({}, initialRange);
+  #range: Range = structuredClone(initialRange);
   get min() {
     return this.#range.min;
   }
   get max() {
     return this.#range.max;
   }
+  get span() {
+    return this.#range.span;
+  }
+
+  get range() {
+    return structuredClone(this.#range);
+  }
 
   set min(newMin) {
     this.#range.min = newMin;
@@ -43,7 +50,12 @@ class RangeHelper {
   }
 
   getNormalization(value: number, weightByRange: boolean) {
-    let normalization = getInterpolation(value, this.#range.min, this.#range.max, this.#range.span);
+    let normalization = getInterpolation(
+      value,
+      this.#range.min,
+      this.#range.max,
+      this.#range.span
+    );
     if (weightByRange) {
       normalization *= this.#range.span;
     }

package/src/utils/Timer.ts

@@ -3,7 +3,7 @@ import { createConsole } from "./Console.ts";
 const _console = createConsole("Timer", { log: false });
 
 export async function wait(delay: number) {
-  _console.log(`waiting for ${delay} ms`);
+  _console.log(`waiting for ${delay}ms`);
   return new Promise((resolve: Function) => {
     setTimeout(() => resolve(), delay);
   });

package/src/utils/environment.ts

@@ -1,13 +1,17 @@
 type ENVIRONMENT_FLAG = "__BRILLIANTSOLE__DEV__" | "__BRILLIANTSOLE__PROD__";
-const __BRILLIANTSOLE__ENVIRONMENT__: ENVIRONMENT_FLAG = "__BRILLIANTSOLE__DEV__";
+const __BRILLIANTSOLE__ENVIRONMENT__: ENVIRONMENT_FLAG =
+  "__BRILLIANTSOLE__DEV__";
 
 //@ts-expect-error
-const isInProduction = __BRILLIANTSOLE__ENVIRONMENT__ == "__BRILLIANTSOLE__PROD__";
+const isInProduction =
+  __BRILLIANTSOLE__ENVIRONMENT__ == "__BRILLIANTSOLE__PROD__";
 const isInDev = __BRILLIANTSOLE__ENVIRONMENT__ == "__BRILLIANTSOLE__DEV__";
 
 // https://github.com/flexdinesh/browser-or-node/blob/master/src/index.ts
-const isInBrowser = typeof window !== "undefined" && typeof window?.document !== "undefined";
-const isInNode = typeof process !== "undefined" && process?.versions?.node != null;
+const isInBrowser =
+  typeof window !== "undefined" && typeof window?.document !== "undefined";
+const isInNode =
+  typeof process !== "undefined" && process?.versions?.node != null;
 
 const userAgent = (isInBrowser && navigator.userAgent) || "";
 
@@ -22,13 +26,18 @@ const isInBluefy = isInBrowser && /Bluefy/i.test(userAgent);
 const isInWebBLE = isInBrowser && /WebBLE/i.test(userAgent);
 
 const isAndroid = isInBrowser && /Android/i.test(userAgent);
-const isSafari = isInBrowser && /Safari/i.test(userAgent) && !/Chrome/i.test(userAgent);
+const isSafari =
+  isInBrowser && /Safari/i.test(userAgent) && !/Chrome/i.test(userAgent);
 
 const isIOS = isInBrowser && /iPad|iPhone|iPod/i.test(userAgent);
 const isMac = isInBrowser && /Macintosh/i.test(userAgent);
 
 // @ts-expect-error
-const isInLensStudio = !isInBrowser && !isInNode && typeof global !== "undefined" && typeof Studio !== "undefined";
+const isInLensStudio =
+  !isInBrowser &&
+  !isInNode &&
+  typeof global !== "undefined" &&
+  typeof Studio !== "undefined";
 
 export {
   isInDev,

package/examples/microphone/gender.js

@@ -1,54 +0,0 @@
-import { pipeline } from "https://cdn.jsdelivr.net/npm/@huggingface/transformers@3.2.4";
-
-import { registerModel } from "./utils.js";
-
-let classifier = undefined;
-let isRunning = false;
-
-const createClassifier = async () => {
-  console.log("creating classifier");
-  classifier = await pipeline(
-    "audio-classification",
-    "Xenova/wav2vec2-large-xlsr-53-gender-recognition-librispeech"
-  );
-  console.log("created classifier", classifier);
-};
-
-registerModel(
-  "gender",
-  () => {
-    if (!classifier) {
-      createClassifier();
-    }
-  },
-  () => {},
-  async (microphoneRecordingAudio, mediaResultsElement) => {
-    if (!classifier) {
-      console.error("classifier not created yet");
-      return;
-    }
-    if (isRunning) {
-      return;
-    }
-    isRunning = true;
-    const output = await classifier(microphoneRecordingAudio.src);
-    isRunning = false;
-
-    console.log("output", output);
-    let maxLabel, maxScore;
-    output.forEach(({ label, score }) => {
-      maxLabel ??= label;
-      maxScore ??= score;
-      if (score > maxScore) {
-        maxScore = score;
-        maxLabel = label;
-      }
-    });
-    mediaResultsElement.innerText = `${maxLabel}: ${maxScore.toFixed(3)}`;
-  }
-);
-
-const sampleOutput = [
-  { label: "male", score: 0.9976564049720764 },
-  { label: "female", score: 0.002343568252399564 },
-];