@jjlmoya/utils-forensic-science 1.20.0 → 1.21.0

package/src/tool/forensic-evidence-scale-calculator/i18n/nl.ts

@@ -0,0 +1,3 @@
+import { createLocalizedContent } from "./localized-content";
+
+export const content = createLocalizedContent("nl");

package/src/tool/forensic-evidence-scale-calculator/i18n/pl.ts

@@ -0,0 +1,3 @@
+import { createLocalizedContent } from "./localized-content";
+
+export const content = createLocalizedContent("pl");

package/src/tool/forensic-evidence-scale-calculator/i18n/pt.ts

@@ -0,0 +1,3 @@
+import { createLocalizedContent } from "./localized-content";
+
+export const content = createLocalizedContent("pt");

package/src/tool/forensic-evidence-scale-calculator/i18n/ru.ts

@@ -0,0 +1,3 @@
+import { createLocalizedContent } from "./localized-content";
+
+export const content = createLocalizedContent("ru");

package/src/tool/forensic-evidence-scale-calculator/i18n/sv.ts

@@ -0,0 +1,3 @@
+import { createLocalizedContent } from "./localized-content";
+
+export const content = createLocalizedContent("sv");

package/src/tool/forensic-evidence-scale-calculator/i18n/tr.ts

@@ -0,0 +1,3 @@
+import { createLocalizedContent } from "./localized-content";
+
+export const content = createLocalizedContent("tr");

package/src/tool/forensic-evidence-scale-calculator/i18n/zh.ts

@@ -0,0 +1,3 @@
+import { createLocalizedContent } from "./localized-content";
+
+export const content = createLocalizedContent("zh");

package/src/tool/forensic-evidence-scale-calculator/index.ts

@@ -0,0 +1,11 @@
+import { forensicEvidenceScaleCalculator } from "./entry";
+import type { ToolDefinition } from "../../types";
+
+export * from "./entry";
+
+export const FORENSIC_EVIDENCE_SCALE_CALCULATOR_TOOL: ToolDefinition = {
+  entry: forensicEvidenceScaleCalculator,
+  Component: () => import("./component.astro"),
+  SEOComponent: () => import("./seo.astro"),
+  BibliographyComponent: () => import("./bibliography.astro"),
+};

package/src/tool/forensic-evidence-scale-calculator/logic.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import { calculateEvidenceScale, formatMeasurement } from "./logic";
+
+describe("calculateEvidenceScale", () => {
+  it("converts image pixels into a real-world size and propagates uncertainty", () => {
+    const result = calculateEvidenceScale({
+      referenceRealSize: 25,
+      referencePixelLength: 200,
+      evidencePixelLength: 80,
+      uncertaintyPercent: 5,
+      unit: "mm",
+      samePlane: true,
+    });
+    expect(result.valid).toBe(true);
+    expect(result.scalePerPixel).toBe(0.125);
+    expect(result.evidenceSize).toBe(10);
+    expect(result.uncertainty).toBe(0.5);
+    expect(result.lowerBound).toBe(9.5);
+    expect(result.upperBound).toBe(10.5);
+    expect(result.warnings).toEqual([]);
+  });
+
+  it("keeps the selected unit in the formula and warns about different planes", () => {
+    const result = calculateEvidenceScale({
+      referenceRealSize: 10,
+      referencePixelLength: 500,
+      evidencePixelLength: 125,
+      uncertaintyPercent: 2,
+      unit: "cm",
+      samePlane: false,
+    });
+    expect(result.formula).toBe("125 px x (10 cm / 500 px)");
+    expect(result.evidenceSize).toBe(2.5);
+    expect(result.warnings).toEqual(["perspective"]);
+    expect(formatMeasurement(result.evidenceSize, result.unit)).toBe("2.5 cm");
+  });
+
+  it("rejects missing or unsafe measurements", () => {
+    const result = calculateEvidenceScale({
+      referenceRealSize: 0,
+      referencePixelLength: 0,
+      evidencePixelLength: -1,
+      uncertaintyPercent: 101,
+      unit: "mm",
+      samePlane: true,
+    });
+    expect(result.valid).toBe(false);
+    expect(result.errors).toEqual([
+      "referenceRealSize",
+      "referencePixelLength",
+      "evidencePixelLength",
+      "uncertaintyPercent",
+    ]);
+  });
+});

package/src/tool/forensic-evidence-scale-calculator/logic.ts

@@ -0,0 +1,107 @@
+export type MeasurementUnit = "mm" | "cm" | "in";
+
+export interface ScaleInput {
+  referenceRealSize: number;
+  referencePixelLength: number;
+  evidencePixelLength: number;
+  uncertaintyPercent: number;
+  unit: MeasurementUnit;
+  samePlane: boolean;
+}
+
+export interface ScaleResult {
+  valid: boolean;
+  errors: string[];
+  warnings: string[];
+  scalePerPixel: number;
+  evidenceSize: number;
+  uncertainty: number;
+  lowerBound: number;
+  upperBound: number;
+  formula: string;
+  unit: MeasurementUnit;
+}
+
+export const UNIT_LABELS: Record<MeasurementUnit, string> = {
+  mm: "mm",
+  cm: "cm",
+  in: "in",
+};
+const UNITS: MeasurementUnit[] = ["mm", "cm", "in"];
+const isFinitePositive = (value: number): boolean =>
+  Number.isFinite(value) && value > 0;
+const isUnit = (value: string): value is MeasurementUnit =>
+  UNITS.includes(value as MeasurementUnit);
+const round = (value: number, decimals = 6): number =>
+  Number(value.toFixed(decimals));
+
+export const formatMeasurement = (
+  value: number,
+  unit: MeasurementUnit,
+): string => {
+  if (!Number.isFinite(value)) return "-";
+  const absolute = Math.abs(value);
+  let decimals = 3;
+  if (absolute >= 100) decimals = 0;
+  else if (absolute >= 10) decimals = 2;
+  return `${value.toFixed(decimals).replace(/\.0+$|(?<=\.\d)0+$/, "")} ${UNIT_LABELS[unit]}`;
+};
+
+const validateInput = (input: ScaleInput): string[] => {
+  const errors: string[] = [];
+  if (!isFinitePositive(input.referenceRealSize))
+    errors.push("referenceRealSize");
+  if (!isFinitePositive(input.referencePixelLength))
+    errors.push("referencePixelLength");
+  if (!isFinitePositive(input.evidencePixelLength))
+    errors.push("evidencePixelLength");
+  if (
+    !Number.isFinite(input.uncertaintyPercent) ||
+    input.uncertaintyPercent < 0 ||
+    input.uncertaintyPercent > 100
+  ) {
+    errors.push("uncertaintyPercent");
+  }
+  return errors;
+};
+
+const emptyResult = (
+  unit: MeasurementUnit,
+  errors: string[],
+  warnings: string[],
+): ScaleResult => ({
+  valid: false,
+  errors,
+  warnings,
+  scalePerPixel: 0,
+  evidenceSize: 0,
+  uncertainty: 0,
+  lowerBound: 0,
+  upperBound: 0,
+  formula: "-",
+  unit,
+});
+
+export const calculateEvidenceScale = (input: ScaleInput): ScaleResult => {
+  const unit = isUnit(input.unit) ? input.unit : "mm";
+  const errors = validateInput(input);
+  const warnings = input.samePlane ? [] : ["perspective"];
+
+  if (errors.length > 0) return emptyResult(unit, errors, warnings);
+
+  const scalePerPixel = input.referenceRealSize / input.referencePixelLength;
+  const evidenceSize = input.evidencePixelLength * scalePerPixel;
+  const uncertainty = evidenceSize * (input.uncertaintyPercent / 100);
+  return {
+    valid: true,
+    errors,
+    warnings,
+    scalePerPixel: round(scalePerPixel),
+    evidenceSize: round(evidenceSize),
+    uncertainty: round(uncertainty),
+    lowerBound: round(Math.max(0, evidenceSize - uncertainty)),
+    upperBound: round(evidenceSize + uncertainty),
+    formula: `${input.evidencePixelLength} px x (${input.referenceRealSize} ${unit} / ${input.referencePixelLength} px)`,
+    unit,
+  };
+};

package/src/tool/forensic-evidence-scale-calculator/seo.astro

@@ -0,0 +1,10 @@
+---
+import { SEORenderer } from '@jjlmoya/utils-shared';
+import { forensicEvidenceScaleCalculator } from './index';
+import type { KnownLocale } from '../../types';
+interface Props { locale?: KnownLocale; }
+const { locale = 'en' } = Astro.props;
+const content = await forensicEvidenceScaleCalculator.i18n[locale]?.();
+if (!content) return null;
+---
+{content.seo?.length > 0 && <SEORenderer content={{ locale, sections: content.seo }} />}

package/src/tool/forensic-evidence-scale-calculator/ui.ts

@@ -0,0 +1,3 @@
+export interface ForensicEvidenceScaleUI {
+  [key: string]: string;
+}

package/src/tool/forensic-evidence-scale-calculator/unit-selector.ts

@@ -0,0 +1,120 @@
+import type { MeasurementUnit } from "./logic";
+
+interface UnitSelector {
+  choice: HTMLElement;
+  trigger: HTMLButtonElement;
+  label: HTMLElement;
+  menu: HTMLElement;
+  options: HTMLButtonElement[];
+}
+
+const getElement = <T extends Element>(
+  root: ParentNode,
+  selector: string,
+): T | null => root.querySelector<T>(selector);
+
+const getSelector = (root: HTMLElement): UnitSelector | null => {
+  const choice = getElement<HTMLElement>(root, "[data-unit-choice]");
+  const trigger = getElement<HTMLButtonElement>(root, "[data-unit-trigger]");
+  const label = getElement<HTMLElement>(root, "[data-unit-label]");
+  const menu = getElement<HTMLElement>(root, "[data-unit-menu]");
+  if (!choice || !trigger || !label || !menu) return null;
+  return {
+    choice,
+    trigger,
+    label,
+    menu,
+    options: Array.from(
+      menu.querySelectorAll<HTMLButtonElement>("[data-unit-option]"),
+    ),
+  };
+};
+
+const setUnit = (selector: UnitSelector, unit: MeasurementUnit): void => {
+  const hidden = getElement<HTMLInputElement>(selector.choice, '[name="unit"]');
+  if (hidden) hidden.value = unit;
+  selector.options.forEach((option) => {
+    const selected = option.dataset.unitOption === unit;
+    option.setAttribute("aria-selected", String(selected));
+    if (selected) selector.label.textContent = option.textContent?.trim() ?? "";
+  });
+};
+
+const bindTrigger = (
+  selector: UnitSelector,
+  open: () => void,
+  close: () => void,
+): void => {
+  selector.trigger.addEventListener("click", () => {
+    if (selector.menu.hidden) open();
+    else close();
+  });
+  selector.trigger.addEventListener("keydown", (event) => {
+    if (event.key !== "ArrowDown" && event.key !== "Enter" && event.key !== " ")
+      return;
+    event.preventDefault();
+    open();
+    selector.options[0]?.focus();
+  });
+};
+
+interface OptionContext {
+  selector: UnitSelector;
+  close: () => void;
+  onChange: () => void;
+}
+
+const bindOption = (
+  { selector, close, onChange }: OptionContext,
+  option: HTMLButtonElement,
+  index: number,
+): void => {
+  option.addEventListener("click", () => {
+    setUnit(selector, option.dataset.unitOption as MeasurementUnit);
+    close();
+    onChange();
+    selector.trigger.focus();
+  });
+  option.addEventListener("keydown", (event) => {
+    if (event.key === "Escape") {
+      event.preventDefault();
+      close();
+      selector.trigger.focus();
+    } else if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+      event.preventDefault();
+      const direction = event.key === "ArrowDown" ? 1 : -1;
+      selector.options[
+        (index + direction + selector.options.length) % selector.options.length
+      ]?.focus();
+    }
+  });
+};
+
+export const setupUnitSelector = (
+  root: HTMLElement,
+  onChange: () => void,
+): void => {
+  const selector = getSelector(root);
+  if (!selector || selector.options.length === 0) return;
+  const close = (): void => {
+    selector.menu.hidden = true;
+    selector.trigger.setAttribute("aria-expanded", "false");
+  };
+  const open = (): void => {
+    selector.menu.hidden = false;
+    selector.trigger.setAttribute("aria-expanded", "true");
+  };
+  bindTrigger(selector, open, close);
+  selector.options.forEach((option, index) =>
+    bindOption({ selector, close, onChange }, option, index),
+  );
+  root.addEventListener("click", (event) => {
+    if (event.target instanceof Node && !selector.choice.contains(event.target))
+      close();
+  });
+  const initialUnit = getElement<HTMLInputElement>(
+    root,
+    '[name="unit"]',
+  )?.value;
+  setUnit(selector, (initialUnit ?? "mm") as MeasurementUnit);
+};

package/src/tool/forensic-evidence-scale-calculator/view.ts

@@ -0,0 +1,203 @@
+import {
+  calculateEvidenceScale,
+  formatMeasurement,
+  type MeasurementUnit,
+  type ScaleInput,
+} from "./logic";
+import type { ForensicEvidenceScaleUI } from "./ui";
+import { setupUnitSelector } from "./unit-selector";
+
+type ScaleResult = ReturnType<typeof calculateEvidenceScale>;
+
+const getElement = <T extends Element>(
+  root: ParentNode,
+  selector: string,
+): T | null => root.querySelector<T>(selector);
+
+const readNumber = (root: ParentNode, name: string): number =>
+  Number(getElement<HTMLInputElement>(root, `[name="${name}"]`)?.value ?? NaN);
+
+const readInput = (root: HTMLElement): ScaleInput => ({
+  referenceRealSize: readNumber(root, "referenceRealSize"),
+  referencePixelLength: readNumber(root, "referencePixelLength"),
+  evidencePixelLength: readNumber(root, "evidencePixelLength"),
+  uncertaintyPercent: readNumber(root, "uncertaintyPercent"),
+  unit: (getElement<HTMLInputElement>(root, '[name="unit"]')?.value ??
+    "mm") as MeasurementUnit,
+  samePlane:
+    getElement<HTMLInputElement>(root, '[name="samePlane"]')?.checked ?? false,
+});
+
+const setText = (root: ParentNode, selector: string, text: string): void => {
+  const element = getElement<HTMLElement>(root, selector);
+  if (element) element.textContent = text;
+};
+
+const uiText = (ui: ForensicEvidenceScaleUI, key: string): string =>
+  ui[key] ?? "";
+
+interface ReadoutContext {
+  ui: ForensicEvidenceScaleUI;
+  result: ScaleResult;
+  unit: MeasurementUnit;
+  uncertaintyPercent: number;
+}
+
+const readoutValue = (
+  result: ScaleResult,
+  validText: string,
+  fallback: string,
+): string => (result.valid ? validText : fallback);
+
+const updateMainReadouts = (
+  root: HTMLElement,
+  context: ReadoutContext,
+): void => {
+  const { ui, result } = context;
+  setText(
+    root,
+    '[data-result="size"]',
+    readoutValue(
+      result,
+      formatMeasurement(result.evidenceSize, result.unit),
+      uiText(ui, "notCalculated"),
+    ),
+  );
+  setText(
+    root,
+    '[data-result="interval"]',
+    readoutValue(
+      result,
+      `${formatMeasurement(result.lowerBound, result.unit)} - ${formatMeasurement(result.upperBound, result.unit)}`,
+      uiText(ui, "enterValues"),
+    ),
+  );
+};
+
+const updateScaleReadouts = (
+  root: HTMLElement,
+  context: ReadoutContext,
+): void => {
+  const { result, unit, uncertaintyPercent } = context;
+  setText(
+    root,
+    '[data-result="scale"]',
+    readoutValue(result, `${result.scalePerPixel} ${unit}/px`, "-"),
+  );
+  setText(
+    root,
+    '[data-result="margin"]',
+    readoutValue(result, `${uncertaintyPercent}%`, "-"),
+  );
+};
+
+const updateTraceReadouts = (
+  root: HTMLElement,
+  context: ReadoutContext,
+): void => {
+  const { ui, result } = context;
+  setText(
+    root,
+    '[data-result="formula"]',
+    readoutValue(result, result.formula, uiText(ui, "formulaPending")),
+  );
+  setText(
+    root,
+    '[data-result="message"]',
+    readoutValue(
+      result,
+      uiText(ui, "calculatedMessage"),
+      uiText(ui, "enterValues"),
+    ),
+  );
+};
+
+const updateReadouts = (root: HTMLElement, context: ReadoutContext): void => {
+  updateMainReadouts(root, context);
+  updateScaleReadouts(root, context);
+  updateTraceReadouts(root, context);
+};
+
+const updateWarning = (
+  root: HTMLElement,
+  ui: ForensicEvidenceScaleUI,
+  result: ScaleResult,
+): void => {
+  const warning = getElement<HTMLElement>(root, '[data-result="warning"]');
+  if (!warning) return;
+  warning.textContent =
+    result.warnings.length > 0
+      ? uiText(ui, "perspectiveWarning")
+      : uiText(ui, "samePlaneMessage");
+  warning.dataset.visible = result.warnings.length > 0 ? "true" : "false";
+};
+
+const referenceEnd = (input: ScaleInput): number =>
+  Math.min(
+    520,
+    220 +
+      Math.max(
+        45,
+        (input.referencePixelLength / Math.max(input.evidencePixelLength, 1)) *
+          70,
+      ),
+  );
+
+const evidenceEnd = (input: ScaleInput): number =>
+  Math.min(
+    560,
+    250 +
+      Math.max(
+        34,
+        (input.evidencePixelLength / Math.max(input.referencePixelLength, 1)) *
+          260,
+      ),
+  );
+
+const updateScene = (
+  root: HTMLElement,
+  input: ScaleInput,
+  result: ScaleResult,
+): void => {
+  const referenceLine = getElement<SVGLineElement>(
+    root,
+    '[data-scene="reference-line"]',
+  );
+  const evidenceLine = getElement<SVGLineElement>(
+    root,
+    '[data-scene="evidence-line"]',
+  );
+  const scene = getElement<HTMLElement>(root, "[data-scene]");
+  if (scene)
+    scene.dataset.warning = result.warnings.length > 0 ? "true" : "false";
+  if (!result.valid) return;
+  if (referenceLine)
+    referenceLine.setAttribute("x2", String(referenceEnd(input)));
+  if (evidenceLine) evidenceLine.setAttribute("x2", String(evidenceEnd(input)));
+};
+
+const render = (root: HTMLElement, ui: ForensicEvidenceScaleUI): void => {
+  const input = readInput(root);
+  const result = calculateEvidenceScale(input);
+  root.dataset.ready = result.valid ? "true" : "false";
+  updateReadouts(root, {
+    ui,
+    result,
+    unit: input.unit,
+    uncertaintyPercent: input.uncertaintyPercent,
+  });
+  updateWarning(root, ui, result);
+  updateScene(root, input, result);
+};
+
+export const initForensicEvidenceScale = (
+  root: HTMLElement,
+  ui: ForensicEvidenceScaleUI,
+): void => {
+  setupUnitSelector(root, () => render(root, ui));
+  root.querySelectorAll<HTMLInputElement>("input").forEach((field) => {
+    field.addEventListener("input", () => render(root, ui));
+    field.addEventListener("change", () => render(root, ui));
+  });
+  render(root, ui);
+};

package/src/tools.ts

@@ -15,9 +15,10 @@ import { BLOODSTAIN_PATTERN_ORIGIN_ANALYZER_TOOL } from './tool/bloodstain-patte
 import { FORENSIC_FINGERPRINT_MINUTIAE_IDENTIFIER_TOOL } from './tool/forensic-fingerprint-minutiae-identifier/index';
 import { FIRE_PATTERN_ORIGIN_ANALYZER_TOOL } from './tool/fire-pattern-origin-analyzer/index';
 import { FORENSIC_TOOLMARK_STRIATION_MATCHER_TOOL } from './tool/forensic-toolmark-striation-matcher/index';
-import { TIME_OF_DEATH_ALGOR_MORTIS_CALCULATOR_TOOL } from './tool/time-of-death-algor-mortis-calculator/index';
-import { VOICE_SPECTROGRAM_ANALYZER_TOOL } from './tool/voice-spectrogram-analyzer/index';
-import { DNA_PROFILE_MATCH_PROBABILITY_LAB_TOOL } from './tool/dna-profile-match-probability-lab/index';
+import { TIME_OF_DEATH_ALGOR_MORTIS_CALCULATOR_TOOL } from './tool/time-of-death-algor-mortis-calculator/index';
+import { VOICE_SPECTROGRAM_ANALYZER_TOOL } from './tool/voice-spectrogram-analyzer/index';
+import { DNA_PROFILE_MATCH_PROBABILITY_LAB_TOOL } from './tool/dna-profile-match-probability-lab/index';
+import { FORENSIC_EVIDENCE_SCALE_CALCULATOR_TOOL } from './tool/forensic-evidence-scale-calculator/index';
 
 export const ALL_TOOLS: ToolDefinition[] = [
   FORENSIC_AGE_ESTIMATOR_TOOL,
@@ -35,7 +36,8 @@ export const ALL_TOOLS: ToolDefinition[] = [
   FORENSIC_FINGERPRINT_MINUTIAE_IDENTIFIER_TOOL,
   FIRE_PATTERN_ORIGIN_ANALYZER_TOOL,
   FORENSIC_TOOLMARK_STRIATION_MATCHER_TOOL,
-  TIME_OF_DEATH_ALGOR_MORTIS_CALCULATOR_TOOL,
-  VOICE_SPECTROGRAM_ANALYZER_TOOL,
-  DNA_PROFILE_MATCH_PROBABILITY_LAB_TOOL
+  TIME_OF_DEATH_ALGOR_MORTIS_CALCULATOR_TOOL,
+  VOICE_SPECTROGRAM_ANALYZER_TOOL,
+  DNA_PROFILE_MATCH_PROBABILITY_LAB_TOOL,
+  FORENSIC_EVIDENCE_SCALE_CALCULATOR_TOOL
 ];