Zaehlung auf oertlichen Kontrast umgestellt (Otsu versagte am echten Foto)

Otsu (bisheriges Verfahren) meldete am echten Foto des Auftraggebers
(~20 Schrauben auf Leder, unter 1% Flaechenanteil) 76712 statt rund
zwanzig - Otsu taugt nur bei etwa gleich grossen Objekt-/
Untergrundflaechen. countObjects() vergleicht jetzt jeden Bildpunkt mit
einem oertlichen Hintergrund (Kastenfilter ueber Summenbild, Radius
max(Breite,Hoehe)/12), was Ausleuchtungsunterschiede abfaengt und am
echten Foto 18 statt 76712 liefert (Test in
test/count-objects-photo.test.js, ~30-49ms Laufzeit).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

src/count-objects.js

@@ -1,37 +1,70 @@
 // Zaehlt zusammenhaengende Objektflaechen in einem Kamera-Ausschnitt - die
 // vierte Scan-Funktion "Zaehlen" (siehe scan-modes.js). Reine Berechnung auf
 // Bilddaten, ohne jeden Browser-Zugriff (kein window/document/canvas) und
-// ohne neue Abhaengigkeit: derselbe Otsu-Schwellwert wie bei der
-// Texterkennung (siehe threshold.js), kein Bilderkennungsmodell.
+// ohne neue Abhaengigkeit.
 //
-// Ablauf, siehe Bericht (.superpowers/sdd/counting-report.md) fuer die
-// Begruendung der einzelnen Schwellen:
-//  1. Otsu-Schwellwert trennt den Ausschnitt in zwei Klassen (threshold.js -
-//     dasselbe Modul, das auch preprocess() in ocr.js nutzt).
-//  2. Die flaechenmaessig kleinere der beiden Klassen gilt als Objekt - die
-//     ausgelegten Teile nehmen fast immer weniger Flaeche ein als der
-//     Untergrund, egal ob sie heller oder dunkler sind als dieser. Kein
-//     Umschalten durch den Nutzer noetig.
-//  3. Connected-Component-Labeling mit 4er-Nachbarschaft (oben/unten/links/
-//     rechts) ueber eine eigene Arbeitsliste statt Rekursion - der Ausschnitt
-//     hat rund eine Million Bildpunkte, ein rekursiver Aufruf je Bildpunkt
-//     liefe in den Stapelueberlauf. 4er- statt 8er-Nachbarschaft, damit zwei
-//     nur diagonal beruehrende, tatsaechlich getrennte Teile nicht ueber ein
-//     einzelnes Eckpixel hinweg zu einer Flaeche verschmelzen.
-//  4. Winzige Flaechen (Staub, Kratzer, Lichtreflexe) werden verworfen: alles
-//     deutlich kleiner als die (vorlaeufige) typische Fundstueckgroesse.
-//  5. Auffaellig grosse Flaechen (mehrere beruehrende Teile) werden auf ein
-//     Vielfaches der typischen Groesse hochgerechnet.
+// Otsu (threshold.js) taugt nur, wenn Objekt- und Untergrundflaeche etwa
+// gleich gross sind. Am echten Foto des Auftraggebers (rund zwanzig
+// Festplattenschrauben auf dunklem Leder) belegen die Schrauben unter einem
+// Prozent der Flaeche - Otsu rutscht dann auf den hoechsten Helligkeitswert
+// und erklaert nur die hellsten Punkte der Ledernarbung zum Objekt
+// (gemessen: 76712 statt rund zwanzig, siehe
+// test/count-objects-photo.test.js). Otsu betrachtet zudem nur die absolute
+// Helligkeit ueber das ganze Bild hinweg; am echten Foto sind Schraube und
+// Untergrund darueber gar nicht trennbar (Median 114, 90. Perzentil 221,
+// 99. Perzentil 254 - deutliche Ueberlappung).
+//
+// Dieses Modul verwendet stattdessen oertlichen Kontrast (siehe
+// .superpowers/sdd/counting-rework-report.md fuer die Herleitung und die
+// Messungen am echten Foto):
+//  1. Auf 800 Bildpunkte Breite normieren (Seitenverhaeltnis erhalten) -
+//     macht alle folgenden Groessen unabhaengig von der Kameraaufloesung und
+//     die Rechnung schneller.
+//  2. Graustufen (uebliche Gewichte 0,299 / 0,587 / 0,114).
+//  3. Glaetten mit einem Kastenfilter (unterdrueckt feine Untergrundnarbung,
+//     ohne Teile zu verschmieren) ueber ein Summenbild, damit die
+//     Mittelwertbildung unabhaengig vom Radius in gleicher Zeit laeuft.
+//  4. Oertlichen Hintergrund ueber einen zweiten, deutlich groesseren
+//     Kastenmittelwert bestimmen - faengt ungleichmaessige Ausleuchtung ab
+//     und bleibt auch dann noch "Untergrund", wenn ein einzelnes Teil den
+//     Mittelwert an seiner eigenen Stelle nicht dominieren kann (das Fenster
+//     ist viel groesser als ein einzelnes Teil).
+//  5. Maske: Bildpunkt geglaettet vs. oertlicher Hintergrund +/- Marge.
+//  6. Connected-Component-Labeling mit 4er-Nachbarschaft ueber eine eigene
+//     Arbeitsliste statt Rekursion (rund eine Viertelmillion Bildpunkte
+//     wuerden einen rekursiven Aufruf je Bildpunkt in den Stapelueberlauf
+//     laufen lassen).
+//  7. Grobes Rauschen verwerfen (Staub, Kratzer, Lichtreflexe).
+//  8. Massstab aus der groessten verbliebenen Flaeche ableiten: nur Flaechen
+//     ab einem festen Anteil der groessten Flaeche behalten - bewusst
+//     relativ, nicht absolut, damit ein naeher oder weiter weg gehaltenes
+//     Kamerabild die Zaehlung nicht verstellt.
+//  9. Typische Einzelgroesse: Median der verbliebenen Flaechen.
+// 10. Zaehlen: jede Flaeche zaehlt max(1, gerundet(flaeche / typischeGroesse)).
+//
+// Beide Polaritaeten (helle Objekte auf dunklerem Grund, dunkle auf
+// hellerem) werden berechnet; es gewinnt die mit den meisten behaltenen
+// Flaechen (siehe Begruendung und Messung am echten Foto in
+// countObjects() unten und im Bericht) - nur bei Gleichstand entscheidet
+// ersatzweise die kleinere Gesamtflaeche (Objekte belegen in aller Regel
+// weniger Flaeche als der Untergrund).
 
-import { computeOtsuThreshold } from './threshold.js';
+// Zielbreite fuer die Normierung (Schritt 1). Schmalere Bilder bleiben
+// unveraendert.
+const TARGET_WIDTH = 800;
 
-// Flaechen unterhalb dieses Anteils der vorlaeufigen Medianflaeche gelten
-// als Rauschen, nicht als eigenes Fundstueck. Ein Viertel der typischen
-// Groesse laesst echten Teilen deutlichen Spielraum (z. B. ein Teil, das nur
-// zum groessten Teil im Rahmen liegt), verwirft aber zuverlaessig die
-// deutlich kleineren Einzelpixel- bis Handvoll-Pixel-Flaechen von Staub,
-// Kratzern und Reflexen. Siehe Bericht fuer die Abwaegung.
-const NOISE_AREA_FRACTION = 0.25;
+// Kontrastmarge fuer die Maskenbildung (Schritt 5): ein Bildpunkt muss um
+// mehr als diesen Betrag heller/dunkler sein als sein oertlicher Hintergrund,
+// um als Objekt zu gelten - unterdrueckt Sensorrauschen und feine
+// Resthelligkeitsschwankungen, die die Glaettung (Schritt 3) nicht restlos
+// entfernt.
+const LOCAL_CONTRAST_MARGIN = 25;
+
+// Anteil der groessten Flaeche, ab dem eine kleinere Flaeche noch als
+// eigenes Fundstueck zaehlt (Schritt 8). Bewusst relativ zur groessten
+// gefundenen Flaeche - siehe Moduldoku oben. Am echten Foto ist das Ergebnis
+// zwischen 15 und 25 Prozent unveraendert.
+const SCALE_FRACTION_OF_LARGEST = 0.2;
 
 /**
  * Median einer Zahlenliste - robust gegen einzelne sehr grosse (verschmolzene
@@ -47,14 +80,124 @@ function median(values) {
     : sorted[middle];
 }
 
+/**
+ * Normiert einen Bildausschnitt auf `targetWidth` Bildpunkte Breite
+ * (Seitenverhaeltnis erhalten, naechster Nachbar). Ist der Ausschnitt bereits
+ * schmaler oder gleich breit, wird er unveraendert zurueckgegeben - macht
+ * alle nachfolgenden Groessen (Glaettungsradius, Hintergrundradius,
+ * Rauschschwelle) unabhaengig von der Kameraaufloesung.
+ * @param {{width: number, height: number, data: Uint8ClampedArray}} imageData
+ * @param {number} targetWidth
+ * @returns {{width: number, height: number, data: Uint8ClampedArray}}
+ */
+function resizeToWidth(imageData, targetWidth) {
+  const { width, height, data } = imageData;
+  if (width <= targetWidth) {
+    return imageData;
+  }
+
+  const scale = targetWidth / width;
+  const newHeight = Math.max(1, Math.round(height * scale));
+  const newData = new Uint8ClampedArray(targetWidth * newHeight * 4);
+
+  for (let y = 0; y < newHeight; y += 1) {
+    const srcY = Math.min(height - 1, Math.floor((y + 0.5) / scale));
+    for (let x = 0; x < targetWidth; x += 1) {
+      const srcX = Math.min(width - 1, Math.floor((x + 0.5) / scale));
+      const srcIndex = (srcY * width + srcX) * 4;
+      const dstIndex = (y * targetWidth + x) * 4;
+      newData[dstIndex] = data[srcIndex];
+      newData[dstIndex + 1] = data[srcIndex + 1];
+      newData[dstIndex + 2] = data[srcIndex + 2];
+      newData[dstIndex + 3] = data[srcIndex + 3];
+    }
+  }
+
+  return { width: targetWidth, height: newHeight, data: newData };
+}
+
+/**
+ * Graustufen (uebliche Gewichte) aus RGBA-Bilddaten.
+ * @param {{width: number, height: number, data: Uint8ClampedArray}} imageData
+ * @returns {Float64Array} ein Eintrag je Bildpunkt
+ */
+function toGrayscale({ width, height, data }) {
+  const gray = new Float64Array(width * height);
+  for (let p = 0, i = 0; p < width * height; p += 1, i += 4) {
+    gray[p] = 0.299 * data[i] + 0.587 * data[i + 1] + 0.114 * data[i + 2];
+  }
+  return gray;
+}
+
+/**
+ * Summenbild (Integral Image): jede Zelle enthaelt die Summe aller
+ * Bildpunkte oben links davon. Erlaubt es, die Summe ueber ein beliebiges
+ * Rechteck in konstanter Zeit zu bestimmen - Grundlage fuer den
+ * radius-unabhaengigen Kastenmittelwert unten.
+ * @param {Float64Array} values width*height Eintraege
+ * @param {number} width
+ * @param {number} height
+ * @returns {Float64Array} (width+1)*(height+1) Eintraege
+ */
+function buildIntegralImage(values, width, height) {
+  const stride = width + 1;
+  const integral = new Float64Array(stride * (height + 1));
+
+  for (let y = 0; y < height; y += 1) {
+    let rowSum = 0;
+    const rowAbove = y * stride;
+    const rowHere = (y + 1) * stride;
+    for (let x = 0; x < width; x += 1) {
+      rowSum += values[y * width + x];
+      integral[rowHere + x + 1] = integral[rowAbove + x + 1] + rowSum;
+    }
+  }
+
+  return integral;
+}
+
+/**
+ * Kastenmittelwert ueber `values` mit gegebenem Radius, berechnet aus einem
+ * zuvor gebauten Summenbild - unabhaengig vom Radius in derselben Zeit (nur
+ * vier Zugriffe auf das Summenbild je Bildpunkt). Am Bildrand wird das
+ * Fenster auf das Bild geklemmt und durch die tatsaechliche (kleinere)
+ * Fensterflaeche geteilt, statt den Rand mit Nullen aufzufuellen.
+ * @param {Float64Array} values width*height Eintraege
+ * @param {number} width
+ * @param {number} height
+ * @param {number} radius
+ * @returns {Float64Array} width*height Eintraege
+ */
+function boxBlur(values, width, height, radius) {
+  const integral = buildIntegralImage(values, width, height);
+  const stride = width + 1;
+  const out = new Float64Array(width * height);
+
+  for (let y = 0; y < height; y += 1) {
+    const y0 = Math.max(0, y - radius);
+    const y1 = Math.min(height, y + radius + 1);
+    for (let x = 0; x < width; x += 1) {
+      const x0 = Math.max(0, x - radius);
+      const x1 = Math.min(width, x + radius + 1);
+      const sum =
+        integral[y1 * stride + x1] -
+        integral[y0 * stride + x1] -
+        integral[y1 * stride + x0] +
+        integral[y0 * stride + x0];
+      const count = (x1 - x0) * (y1 - y0);
+      out[y * width + x] = sum / count;
+    }
+  }
+
+  return out;
+}
+
 /**
  * Flutet eine zusammenhaengende Objektflaeche ausgehend von startIndex ueber
  * eine eigene Arbeitsliste (kein Rekursionsaufruf je Bildpunkt) und markiert
  * dabei jeden erreichten Bildpunkt in `visited`. Der Stapelspeicher `stack`
  * wird vom Aufrufer einmal pro Bild angelegt und fuer alle Flaechen
- * wiederverwendet - bei mehrmals pro Sekunde laufender Zaehlung auf rund
- * einer Million Bildpunkten spart das die wiederholte Neuanlage eines
- * Arrays je Flaeche.
+ * (und beide Polaritaeten) wiederverwendet.
  * @param {number} startIndex
  * @param {(index: number) => boolean} isObjectPixel
  * @param {Uint8Array} visited
@@ -115,73 +258,138 @@ function floodFill(startIndex, isObjectPixel, visited, width, height, stack) {
   return area;
 }
 
+/**
+ * Fuehrt Schritte 6-10 (siehe Moduldoku oben) fuer eine Polaritaet aus
+ * (helle Objekte auf dunklerem Grund oder umgekehrt).
+ * @param {(index: number) => boolean} isObjectPixel
+ * @param {number} width
+ * @param {number} height
+ * @param {number} totalPixels
+ * @param {Uint8Array} visited wiederverwendeter, bei Aufruf bereits genullter Arbeitsspeicher
+ * @param {Int32Array} stack wiederverwendeter Arbeitsspeicher
+ * @returns {{count: number, totalArea: number, significantCount: number} | null}
+ *   null, wenn keine Flaeche dieser Polaritaet uebrig bleibt (kein Rauschen
+ *   ausgenommen, oder gar keine gefunden)
+ */
+function analyzePolarity(isObjectPixel, width, height, totalPixels, visited, stack) {
+  const rawAreas = [];
+  for (let p = 0; p < totalPixels; p += 1) {
+    if (visited[p] || !isObjectPixel(p)) continue;
+    rawAreas.push(floodFill(p, isObjectPixel, visited, width, height, stack));
+  }
+  if (rawAreas.length === 0) {
+    return null;
+  }
+
+  // Schritt 7: grobes Rauschen (Staub, Kratzer, Lichtreflexe) verwerfen.
+  const noiseThreshold = Math.max(8, 0.00002 * totalPixels);
+  const afterNoise = rawAreas.filter((area) => area >= noiseThreshold);
+  if (afterNoise.length === 0) {
+    return null;
+  }
+
+  // Schritt 8: Massstab aus der groessten verbliebenen Flaeche ableiten -
+  // bewusst relativ (siehe Moduldoku), nicht als fester Bildpunktwert.
+  const largestArea = Math.max(...afterNoise);
+  const scaleThreshold = largestArea * SCALE_FRACTION_OF_LARGEST;
+  const significantAreas = afterNoise.filter((area) => area >= scaleThreshold);
+  if (significantAreas.length === 0) {
+    return null;
+  }
+
+  // Schritt 9: typische Einzelgroesse.
+  const typicalArea = median(significantAreas);
+
+  // Schritt 10: zaehlen, dabei rundet auf statt abzuschneiden (siehe alte
+  // Fassung: ein nur leicht groesseres Einzelteil soll nicht faelschlich als
+  // zwei zaehlen).
+  let count = 0;
+  let totalArea = 0;
+  for (const area of significantAreas) {
+    count += Math.max(1, Math.round(area / typicalArea));
+    totalArea += area;
+  }
+
+  return { count, totalArea, significantCount: significantAreas.length };
+}
+
 /**
  * Zaehlt die Fundstuecke (z. B. ausgelegte Schrauben) in einem
- * Kamera-Ausschnitt. Reine Anzeigefunktion - erzeugt keinen Zustand, bucht
- * nichts, veraendert keine Sitzung.
+ * Kamera-Ausschnitt anhand oertlichen Kontrasts. Reine Anzeigefunktion -
+ * erzeugt keinen Zustand, bucht nichts, veraendert keine Sitzung.
  * @param {{width: number, height: number, data: Uint8ClampedArray}} imageData
  * @returns {{count: number}} count: ermittelte, bereits gerundete Anzahl -
  *   0, wenn keine Objektflaeche gefunden wurde (leerer Ausschnitt, reiner
  *   Untergrund ohne Kontrast oder ein Ausschnitt ohne Bildpunkte).
  */
 export function countObjects(imageData) {
-  const { width, height } = imageData;
-  const totalPixels = width * height;
-  if (totalPixels === 0) {
+  if (imageData.width * imageData.height === 0) {
     return { count: 0 };
   }
 
-  const { gray, threshold } = computeOtsuThreshold(imageData);
+  // Schritt 1: auf feste Breite normieren.
+  const resized = resizeToWidth(imageData, TARGET_WIDTH);
+  const { width, height } = resized;
+  const totalPixels = width * height;
 
-  let brightPixels = 0;
-  for (let p = 0; p < totalPixels; p += 1) {
-    if (gray[p] >= threshold) brightPixels += 1;
-  }
-  const darkPixels = totalPixels - brightPixels;
-  // Die Objekte belegen in aller Regel weniger Flaeche als der Untergrund -
-  // die flaechenmaessig kleinere Klasse gilt deshalb als Objekt, unabhaengig
-  // davon, ob sie heller oder dunkler ist als die andere.
-  const objectIsBright = brightPixels < darkPixels;
-  const isObjectPixel = (p) => (gray[p] >= threshold) === objectIsBright;
+  // Schritt 2: Graustufen.
+  const gray = toGrayscale(resized);
+
+  // Schritt 3: glaetten (unterdrueckt feine Untergrundnarbung).
+  const smoothRadius = Math.max(2, Math.round(width * 0.0025));
+  const smoothed = boxBlur(gray, width, height, smoothRadius);
+
+  // Schritt 4: oertlichen Hintergrund bestimmen (deutlich groesseres
+  // Fenster als der Glaettungsradius - faengt ungleichmaessige Ausleuchtung
+  // ab, ohne von einem einzelnen Fundstueck selbst dominiert zu werden). Ein
+  // Mindestradius von 1 verhindert ein entartetes Ein-Bildpunkt-Fenster bei
+  // sehr kleinen Ausschnitten, in dem der "Hintergrund" schlicht der
+  // geglaettete Wert selbst waere.
+  const backgroundRadius = Math.max(1, Math.round(Math.max(width, height) / 12));
+  const localBackground = boxBlur(smoothed, width, height, backgroundRadius);
 
   const visited = new Uint8Array(totalPixels);
   const stack = new Int32Array(totalPixels);
-  const rawAreas = [];
 
-  for (let p = 0; p < totalPixels; p += 1) {
-    if (visited[p] || !isObjectPixel(p)) continue;
-    rawAreas.push(floodFill(p, isObjectPixel, visited, width, height, stack));
-  }
+  // Beide Polaritaeten: helle Objekte auf dunklerem Grund ...
+  const isBrightObject = (p) => smoothed[p] > localBackground[p] + LOCAL_CONTRAST_MARGIN;
+  const bright = analyzePolarity(isBrightObject, width, height, totalPixels, visited, stack);
 
-  if (rawAreas.length === 0) {
+  // ... und dunkle Objekte auf hellerem Grund. Arbeitsspeicher wird
+  // wiederverwendet, muss dafuer zurueckgesetzt werden.
+  visited.fill(0);
+  const isDarkObject = (p) => smoothed[p] < localBackground[p] - LOCAL_CONTRAST_MARGIN;
+  const dark = analyzePolarity(isDarkObject, width, height, totalPixels, visited, stack);
+
+  if (!bright && !dark) {
     return { count: 0 };
   }
-
-  // Vorlaeufiger Massstab (siehe NOISE_AREA_FRACTION oben), um Rauschen zu
-  // verwerfen, bevor der endgueltige Massstab fuer die Hochrechnung bestimmt
-  // wird - Rauschflaechen sollen diesen Massstab selbst nicht mehr verzerren.
-  const provisionalTypicalArea = median(rawAreas);
-  const noiseThreshold = provisionalTypicalArea * NOISE_AREA_FRACTION;
-  const significantAreas = rawAreas.filter((area) => area >= noiseThreshold);
-
-  if (significantAreas.length === 0) {
-    return { count: 0 };
+  if (!dark) {
+    return { count: bright.count };
+  }
+  if (!bright) {
+    return { count: dark.count };
   }
 
-  // Massstab fuer die Hochrechnung: Median der um Rauschen bereinigten
-  // Flaechen - robust gegen die verbliebenen Ausreisser (z. B. eine grosse,
-  // aus mehreren beruehrenden Teilen verschmolzene Flaeche).
-  const typicalArea = median(significantAreas);
-
-  let count = 0;
-  for (const area of significantAreas) {
-    // Runden statt Abschneiden: Eine Flaeche, die nur wenig groesser ist als
-    // der Median (z. B. 1,3-fach, weil ein Teil zufaellig etwas naeher an
-    // der Kamera oder etwas groesser im Bild liegt), rundet auf 1 ab und wird
-    // nicht faelschlich als zwei gezaehlt - erst deutlich ueber dem
-    // 1,5-fachen rundet auf 2 usw. Jede Flaeche zaehlt mindestens einmal.
-    count += Math.max(1, Math.round(area / typicalArea));
+  // Beide Polaritaeten haben etwas gefunden - eine muss gewinnen. Am echten
+  // Foto (silberne, glaenzende Schrauben, einseitig beleuchtet) traegt jede
+  // Schraube sowohl eine helle Reflexflaeche als auch einen dunklen
+  // Schlagschatten - beide Polaritaeten finden also echte, nicht zufaellige
+  // Struktur, und ihre Gesamtflaechen liegen dicht beieinander (am
+  // Pruefbild rund 2826 zu 2140 Bildpunkte). Die Gesamtflaeche allein
+  // (kleinere gewinnt) ist in diesem Fall kein verlaessliches Kriterium: der
+  // Schlagschatten jeder Schraube ist schmaler als ihre Reflexflaeche und
+  // summiert sich deshalb zu einer kleineren Gesamtflaeche, obwohl die
+  // Reflexflaechen die tatsaechlichen Fundstuecke vollstaendiger und
+  // stabiler nachzeichnen (siehe .superpowers/sdd/counting-rework-report.md
+  // fuer die Messung). Ausschlaggebend ist deshalb, welche Polaritaet mehr
+  // der (bekanntermassen um die zwanzig) tatsaechlichen Fundstuecke als
+  // eigene, den Rausch- und Groessenfilter ueberstehende Flaeche auflaesst -
+  // die Polaritaet mit den meisten behaltenen Flaechen gewinnt. Nur bei
+  // gleich vielen behaltenen Flaechen entscheidet die kleinere
+  // Gesamtflaeche (die urspruengliche Regel) als Ausweichkriterium.
+  if (bright.significantCount !== dark.significantCount) {
+    return { count: bright.significantCount > dark.significantCount ? bright.count : dark.count };
   }
-
-  return { count };
+  return { count: bright.totalArea <= dark.totalArea ? bright.count : dark.count };
 }

test/count-objects-photo.test.js

@@ -0,0 +1,57 @@
+// Prueffall am echten Foto des Auftraggebers (siehe
+// .superpowers/sdd/counting-rework-report.md): Otsu allein scheiterte hier,
+// weil die Schrauben unter einem Prozent der Bildflaeche belegen - Otsu
+// rutscht in so einem Fall auf den hoechsten Helligkeitswert und erklaert nur
+// die hellsten Punkte der Ledernarbung zum Objekt. Die fruehere Fassung
+// meldete an genau diesem Bild 76712 statt der rund zwanzig tatsaechlich
+// ausgelegten Schrauben. Dieser Test schuetzt vor einem Rueckfall in dieses
+// Verhalten.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { countObjects } from '../src/count-objects.js';
+import {
+  SCREWS_WIDTH,
+  SCREWS_HEIGHT,
+  SCREWS_GRAY_BASE64,
+} from './fixtures/screws-photo.js';
+
+/**
+ * Baut aus dem Base64-kodierten Graustufenraster ein ImageData-artiges
+ * Objekt: Graustufenwert auf R, G und B gelegt, Alpha 255 - wie eine echte
+ * Kameraaufnahme ohne Farbinformation.
+ */
+function grayscaleImage(width, height, base64) {
+  const gray = Buffer.from(base64, 'base64');
+  const data = new Uint8ClampedArray(width * height * 4);
+  for (let p = 0, i = 0; p < width * height; p += 1, i += 4) {
+    const value = gray[p];
+    data[i] = value;
+    data[i + 1] = value;
+    data[i + 2] = value;
+    data[i + 3] = 255;
+  }
+  return { width, height, data };
+}
+
+test('echtes Foto (~20 Festplattenschrauben auf Leder) ergibt eine Zahl zwischen 15 und 24', () => {
+  const imageData = grayscaleImage(SCREWS_WIDTH, SCREWS_HEIGHT, SCREWS_GRAY_BASE64);
+
+  const start = performance.now();
+  const result = countObjects(imageData);
+  const durationMs = performance.now() - start;
+
+  // Nur zur Beobachtung im Testlauf, keine Zusicherung ueber die Konsole -
+  // die Laufzeit selbst wird unten geprueft.
+  console.log(`countObjects(screws-photo) dauerte ${durationMs.toFixed(2)} ms`);
+
+  assert.ok(
+    result.count >= 15 && result.count <= 24,
+    `erwartet 15..24, erhalten ${result.count} (fruehere Fassung meldete 76712)`,
+  );
+
+  // Soll mehrmals je Sekunde laufen koennen (laufende Anzeige waehrend die
+  // Kamera laeuft) - grosszuegige Grenze, die auf langsamerer Hardware nicht
+  // faelschlich anschlaegt, aber ein grundlegend zu langsames Verfahren
+  // (z. B. eine versehentlich quadratische Rechnung) auffangen wuerde.
+  assert.ok(durationMs < 500, `erwartet unter 500 ms, gemessen ${durationMs.toFixed(2)} ms`);
+});