README: Zählen-Abschnitte auf Aufnahme statt Dauerbetrieb aktualisiert

Beschreibt die neue Aufnahme-Schaltfläche ("Zählen"/"Nochmal zählen"), die
fünf Bilder je Aufnahme samt Median, die um die Einzelmessungen erweiterte
Diagnosezeile und das Zurücksetzen beim Verlassen der Funktion. Aufbau-
Tabelle, Testanzahl und der Prüfabschnitt "Am Gerät noch zu prüfen" folgen.

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

README.md

@@ -4,10 +4,14 @@ Browser-App, die per Handykamera gebrauchte Server-RAM-Module erkennt und
 beim physischen Sortieren am Tisch anleitet: Modul vor die Kamera halten, die
 App nennt den Stapel.
 
-Vor dem Scannen wählt der Nutzer eine von drei Funktionen — Strichcode,
-QR-Code oder Text erkennen (siehe „Funktionsweise" unten). Jede Funktion nutzt
-ausschließlich ihre eigene Quelle; anders als früher weicht die App nicht mehr
-automatisch auf Texterkennung aus, wenn kein Code gefunden wird.
+Vor dem Scannen wählt der Nutzer eine von vier Funktionen — Strichcode,
+QR-Code, Text erkennen oder Zählen (siehe „Funktionsweise" unten). Jede
+Funktion nutzt ausschließlich ihre eigene Quelle; anders als früher weicht die
+App nicht mehr automatisch auf Texterkennung aus, wenn kein Code gefunden
+wird. Die vierte Funktion, „Zählen", gehört nicht zum eigentlichen Sortieren:
+Sie bucht nichts, sondern ermittelt auf Knopfdruck beim Auslegen von
+Kleinteilen (z. B. Festplattenschrauben) deren Anzahl und zeigt sie an, bis
+der Nutzer erneut antippt.
 
 Zwei Module gelten als zusammengehörig, wenn sie denselben Barcode-Inhalt
 tragen — ein Barcode ist exakt gelesen, das ist der zuverlässigste Maßstab.
@@ -57,16 +61,17 @@ keine Daten verlassen das Gerät.
 ## Funktionsweise
 
 0. **Funktion wählen.** Vor dem ersten Scan (und jederzeit erneut über die
-   antippbare Anzeige in der Scan-Ansicht) wählt der Nutzer eine von drei
+   antippbare Anzeige in der Scan-Ansicht) wählt der Nutzer eine von vier
    Funktionen. Kennung, Beschriftung, gelesene Codearten und Verhalten stehen
    ausschließlich in `src/scan-modes.js` — es gibt keine zweite Stelle, an der
    das steht:
 
-   | Funktion | Liest | Laufende Suche | Texterkennung |
+   | Funktion | Liest | Laufende Codesuche | Texterkennung |
    |---|---|---|---|
    | **Strichcode** | Code128, Code39, Code93, ITF, EAN-13, EAN-8, UPC-A, UPC-E, Codabar | ja | nein |
    | **QR-Code** | QRCode, MicroQRCode, RMQRCode, DataMatrix, Aztec, PDF417 | ja | nein |
    | **Text erkennen** | keine Codes | nein | ja, auf Knopfdruck |
+   | **Zählen** | keine Codes | nein | nein, dafür Zählung auf Knopfdruck (keine Buchung) |
 
    „QR-Code" heißt auf Wunsch des Auftraggebers „QR-Code", liest aber bewusst
    nicht nur QR-Varianten, sondern auch DataMatrix, Aztec und PDF417. Der
@@ -76,31 +81,41 @@ keine Daten verlassen das Gerät.
    `src/scan-modes.js`), und der Name ist Absicht — es ist der Wunsch des
    Auftraggebers für seinen Sprachgebrauch.
 
-   „Modul scannen" erscheint nur in „Text erkennen" — in „Strichcode" und
-   „QR-Code" sucht die App ohnehin laufend, ein Knopf ohne Texterkennung hätte
-   dort nichts zu tun. Der Zielrahmen hebt sich in „Strichcode" und „QR-Code"
-   hervor, sobald ein passender Code im Bild ist; in „Text erkennen" bleibt er
+   Eine einzige Aufnahme-Schaltfläche bedient beide Knopfdruck-Funktionen —
+   „Modul scannen" in „Text erkennen", „Zählen" bzw. (nach der ersten
+   Aufnahme seit Betreten der Funktion) „Nochmal zählen" in „Zählen" — statt
+   einer zweiten Schaltfläche daneben; nur Wortlaut und Rückruf unterscheiden
+   sich
+   (`setCaptureLabel` in `src/ui/scan-view.js`, verdrahtet in
+   `src/main.js`/`applyMode()`). In „Strichcode" und „QR-Code" bleibt sie
+   verborgen — dort sucht die App ohnehin laufend, ein Knopf hätte nichts zu
+   tun. Der Zielrahmen hebt sich in „Strichcode" und „QR-Code" hervor, sobald
+   ein passender Code im Bild ist; in „Text erkennen" und „Zählen" bleibt er
    schlicht, weil dort nichts laufend erkannt wird. Trotzdem ist der Rahmen
-   auch dort wirksam: „Modul scannen" liest genau den Bildausschnitt innerhalb
-   des Rahmens, in voller Kameraauflösung, nicht mehr das gesamte,
-   heruntergerechnete Kamerabild (`grabFrameRegion` in `src/camera.js` —
-   derselbe Ausschnitt, den auch die laufende Barcode-Suche benutzt). Ein
-   Wechsel der Funktion während des Sortierens (z. B. bei gemischter Ware)
-   gilt sofort: laufende Suche startet oder stoppt, der Knopf erscheint oder
-   verschwindet.
+   auch dort wirksam: Sowohl „Modul scannen" als auch „Zählen" lesen genau den
+   Bildausschnitt innerhalb des Rahmens, in voller Kameraauflösung, nicht das
+   gesamte, heruntergerechnete Kamerabild (`grabFrameRegion` in
+   `src/camera.js` — derselbe Ausschnitt, den auch die laufende Barcode-Suche
+   benutzt). Ein Wechsel der Funktion während des Sortierens (z. B. bei
+   gemischter Ware) gilt sofort: laufende Suche startet oder stoppt, die
+   Schaltfläche erscheint, verschwindet oder ändert ihren Wortlaut.
 
    Liegt beim Start eine gesicherte Sitzung vor, erscheint zuerst die Frage
-   nach dem Fortsetzen (siehe Punkt 5 unten) und erst danach die Funktionswahl
+   nach dem Fortsetzen (siehe Punkt 6 unten) und erst danach die Funktionswahl
    — die Kamera startet in jedem Fall erst, nachdem beides geklärt ist.
 
    Technisch bekommen „Strichcode" und „QR-Code" eine Texterkennung
    hineingereicht, die sofort leeren Text liefert, ohne Tesseract anzustoßen;
    „Text erkennen" bekommt eine Barcode-Dekodierung hineingereicht, die sofort
-   eine leere Liste liefert (`buildRecognitionAdapters` in
-   `src/scan-recognition.js`). Die Erkennungs-Pipeline selbst (`src/pipeline.js`,
-   Punkte 1–4 unten) bleibt dabei unverändert und kennt keine Funktionen — die
-   drei Funktionen unterscheiden sich ausschließlich darin, welche Adapter ihr
-   übergeben werden.
+   eine leere Liste liefert; „Zählen" bekommt beides leer hineingereicht
+   (`buildRecognitionAdapters` in `src/scan-recognition.js`). Die
+   Erkennungs-Pipeline selbst (`src/pipeline.js`, Punkte 1–3 und 5 unten)
+   bleibt dabei unverändert und kennt keine Funktionen — die drei
+   code-/textbasierten Funktionen unterscheiden sich ausschließlich darin,
+   welche Adapter ihr übergeben werden. „Zählen" ruft diese Pipeline im
+   normalen Betrieb gar nicht erst auf (siehe Punkt 4 unten) — es gibt dort ja
+   nichts zu buchen, das leere Adapterpaar dient nur als Absicherung für den
+   seltenen Ersatzweg ohne Kamera (Punkt 7).
 1. **Barcode-Dekodierung** (nur in „Strichcode" und „QR-Code"). Die zur
    Funktion gehörenden Codearten werden laufend aus dem Kamerabild dekodiert
    (`zxing-wasm`, `decodeBarcodes` in `src/barcode.js` bekommt die Codearten
@@ -163,18 +178,84 @@ keine Daten verlassen das Gerät.
    auszublenden wie in den beiden Barcode-Funktionen (`showResult` in
    `src/ui/result-overlay.js`). Der Rohtext jedes Eintrags lässt sich später
    auch in der Sitzungsliste nachlesen.
-4. **Stapel-Zuweisung.** Grün (Barcode) und Gelb (OCR) laufen ohne Eingabe
+4. **Zählen** (ausschließlich in Funktion „Zählen"). Reine Anzeige, ohne
+   jeden Bezug zur Sitzung — und, anders als die drei übrigen Funktionen mit
+   laufender Erkennung, auf **Aufnahme statt Dauerbetrieb**: Eine Zählung ist
+   eine Schätzung, kein eindeutiger Treffer wie ein Barcode; sie mehrmals pro
+   Sekunde neu anzuzeigen macht sie nicht genauer, nur unruhig (am
+   Nutzergerät sprang die Anzeige im Dauerbetrieb zwischen etwa 3 und 60, an
+   einem Standfoto derselben Teile lieferte dasselbe Verfahren stabil 18).
+   Antippen der Schaltfläche „Zählen“/„Nochmal zählen“ nimmt deshalb binnen
+   rund einer Sekunde fünf Bilder aus dem Zielrahmen des laufenden
+   Videobilds auf (`grabFrameRegion` in `src/camera.js` — bewusst nicht die
+   native Fotoaufnahme des Geräts, deren Bildausschnitt von der Vorschau
+   abweichen kann), zählt jedes einzeln (`countObjects` in
+   `src/count-objects.js`, unverändert) und zeigt als Ergebnis deren Median
+   (`combineCaptureCounts` in `src/count-capture.js`) — robust gegen ein
+   einzelnes verwackeltes oder mitten in eine Fokusregelung fallendes Bild,
+   ohne die frühere fortlaufende Glättung über die letzten neun Messungen
+   (`count-history.js`, entfallen: eine Aufnahme mit fünf Bildern leistet
+   dieselbe Robustheit bereits selbst). Während der rund einen Sekunde zeigt
+   die Statuszeile „zähle …“, damit der Nutzer die Kamera ruhig hält und den
+   Knopfdruck nicht für wirkungslos hält (`runCountCapture` in
+   `src/main.js`). Das Ergebnis bleibt danach stehen, bis der Nutzer erneut
+   antippt — verlässt er die Funktion oder wechselt zu einer anderen, werden
+   Ergebnis und Diagnosezeile zurückgesetzt. Es gibt in dieser Funktion keine
+   Treffer-Rückmeldung und keine Stapel-Zuweisung; die Zahl wird nirgends
+   gespeichert, nicht einmal flüchtig für die Dauer der Sitzung. Die
+   Diagnosezeile unter der großen Zahl (Antippen der Zahl blendet sie ein
+   oder aus) zeigt zusätzlich zu den übrigen Zwischenwerten (die sich auf die
+   *letzte* der fünf Einzelmessungen beziehen) die fünf Einzelmessungen
+   dieser Aufnahme selbst — daran erkennen Nutzer und Entwickler sofort, ob
+   das Ergebnis belastbar ist: Fünf Messungen von 17 bis 19 bedeuten etwas
+   anderes als fünf Messungen von 4 bis 50.
+
+   Kein Bilderkennungsmodell: Der **Otsu-Schwellwert** (`threshold.js`),
+   den die Texterkennung weiterhin nutzt, taugt für „Zählen" nicht — er
+   setzt voraus, dass Objekt- und Untergrundfläche etwa gleich groß sind.
+   Am echten Foto des Auftraggebers (rund zwanzig silberne
+   Festplattenschrauben auf dunklem Leder) belegen die Schrauben unter
+   einem Prozent der Fläche; Otsu rutschte deshalb auf den höchsten
+   Helligkeitswert und erklärte nur die hellsten Punkte der Ledernarbung
+   zum Objekt (gemessenes Fehlverhalten: 76712 statt rund zwanzig). Über
+   die Helligkeit allein sind Schraube und Untergrund an diesem Foto gar
+   nicht trennbar.
+
+   `countObjects` (`src/count-objects.js`) verwendet stattdessen
+   **örtlichen Kontrast**: Der Ausschnitt wird auf 800 Bildpunkte Breite
+   normiert (schmalere Ausschnitte bleiben unverändert — macht alle
+   folgenden Maße unabhängig von der Kameraauflösung), in Graustufen
+   gewandelt und mit einem Kastenfilter geglättet (unterdrückt feine
+   Untergrundnarbung, über ein Summenbild für radius-unabhängige
+   Laufzeit). Ein zweiter, deutlich größerer Kastenmittelwert liefert den
+   **örtlichen Hintergrund** an jeder Stelle — das fängt ungleichmäßige
+   Ausleuchtung ab. Ein Bildpunkt gilt als Objekt, wenn er um mehr als
+   einen festen Betrag heller **oder** dunkler ist als sein örtlicher
+   Hintergrund (beide Richtungen werden berechnet; es gewinnt die mit den
+   meisten gefundenen Einzelflächen — Details siehe unten). Anschließend
+   werden zusammenhängende Objektflächen ermittelt
+   (Connected-Component-Labeling mit einer eigenen Arbeitsliste statt
+   Rekursion, damit ein rund eine Viertelmillion Bildpunkte großer
+   Ausschnitt nicht in den Stapelüberlauf läuft), winzige Flächen als
+   Rauschen verworfen und nur Flächen ab einem festen **Anteil der
+   größten gefundenen Fläche** behalten — bewusst relativ, nicht absolut,
+   damit ein näher oder weiter weg gehaltenes Kamerabild die Zählung nicht
+   verstellt. Auffällig große Flächen (mehrere berührende Teile) werden
+   auf ein Vielfaches der typischen (Median-)Einzelteilgröße
+   hochgerechnet. Details, alle verwendeten Schwellen und die Messung am
+   echten Foto: `.superpowers/sdd/counting-rework-report.md`.
+5. **Stapel-Zuweisung.** Grün (Barcode) und Gelb (OCR) laufen ohne Eingabe
    durch; nur bei roter Konfidenz (nichts Eindeutiges erkannt, widersprüchliche
    Barcodes oder widersprüchliche unbekannte Barcodes ohne jede OCR-Kapazität)
    oder mehrdeutiger Stapelzuordnung fragt die App nach.
-5. **Sitzungsfortsetzung beim Start.** Findet die App beim Laden eine in
+6. **Sitzungsfortsetzung beim Start.** Findet die App beim Laden eine in
    `localStorage` gesicherte, nicht leere Sitzung vor, wird sie nicht
    stillschweigend übernommen, sondern zur Fortsetzung oder zum Verwerfen
    angeboten (`askResumeSession` in `src/ui/resume-dialog.js`, verdrahtet über
    `initResumeOffer()` in `src/main.js`). Erst „fortsetzen“ stellt Stapel,
    Zähler und die „Zuletzt“-Zeile wieder her; „verwerfen“ löscht den
    gesicherten Stand und die App startet leer.
-6. **Ersatzweg ohne Kamera.** Lässt sich die Kamera nicht starten (z. B.
+7. **Ersatzweg ohne Kamera.** Lässt sich die Kamera nicht starten (z. B.
    verweigerte Berechtigung), bleibt die App bedienbar: eine dauerhaft
    sichtbare Schaltfläche „Bild auswählen“ öffnet stattdessen die native
    Dateiauswahl (`setFilePickerVisible` in `src/ui/scan-view.js`). Die App
@@ -213,22 +294,30 @@ korrekt funktioniert.
 npm test
 ```
 
-154 Tests, alle grün (Stand dieses Dokuments). Getestet werden ausschließlich
+179 Tests, alle grün (Stand dieses Dokuments). Getestet werden ausschließlich
 die reinen Module ohne Browser-Zugriff: Teilenummer-Decoder, Spec-Normalisierung
-und toleranter Vergleich, OCR-Bildaufbereitung (Otsu-Schwellwert) und
--Feldextraktion, Stapel-Zuweisung, die Erkennungs-Pipeline samt Zeitgrenzen,
-Mehrdeutigkeitsbehandlung und dem additiven OCR-Rohtext (`rawText` wird nur
-zurückgegeben, wenn die Texterkennung tatsächlich lief, und beeinflusst
-nachweislich nie die Stapelzuordnung), die Sitzungssicherung samt Prüfung
-eines wiederhergestellten Zustands (einschließlich `entry.rawText`), die drei
-Scan-Funktionen (`scan-modes.js` —
-Codearten je Funktion, DataMatrix/Aztec/PDF417 in „QR-Code") sowie die je Funktion
+und toleranter Vergleich, OCR-Bildaufbereitung (Otsu-Schwellwert, jetzt in
+`threshold.js`) und -Feldextraktion, Stapel-Zuweisung, die Erkennungs-Pipeline
+samt Zeitgrenzen, Mehrdeutigkeitsbehandlung und dem additiven OCR-Rohtext
+(`rawText` wird nur zurückgegeben, wenn die Texterkennung tatsächlich lief,
+und beeinflusst nachweislich nie die Stapelzuordnung), die Sitzungssicherung
+samt Prüfung eines wiederhergestellten Zustands (einschließlich
+`entry.rawText`), die vier Scan-Funktionen (`scan-modes.js` — Codearten je
+Funktion, DataMatrix/Aztec/PDF417 in „QR-Code") sowie die je Funktion
 tatsächlich aufgerufenen Adapter (`scan-recognition.js` — Texterkennung läuft
 nachweislich nie in „Strichcode"/„QR-Code", Barcode-Dekodierung nachweislich
-nie in „Text erkennen"). Kamera, Barcode-/OCR-Adapter selbst, die
-Auswahl-Oberfläche und die Verdrahtung in `main.js` laufen nur im echten
-Browser und werden dort manuell geprüft (siehe „Am Gerät noch zu prüfen"
-unten) — `node --test` kennt kein DOM.
+nie in „Text erkennen"/„Zählen"). Dazu die Zähl-Berechnung selbst
+(`count-objects.js` — leeres Bild, einzelne und mehrere getrennte Flächen,
+verworfenes Rauschen, Hochrechnung berührender Teile ohne ein nur leicht
+größeres Einzelteil zu verdoppeln, helle wie dunkle Objekte, ein Bild ohne
+Bildpunkte). Dazu die reine Zusammenfassung der fünf Einzelmessungen einer
+Zaehl-Aufnahme zu deren Median (`count-capture.js` — auch für den Fall
+weniger als fünf verwertbarer Bilder, sowie eine leere Messreihe, die
+regulär wirft statt stillschweigend `NaN` zu liefern). Kamera,
+Barcode-/OCR-Adapter selbst, die Auswahl-Oberfläche und
+die Verdrahtung in `main.js` laufen nur im echten Browser und werden dort
+manuell geprüft (siehe „Am Gerät noch zu prüfen" unten) — `node --test` kennt
+kein DOM.
 
 ## Produktion
 
@@ -293,14 +382,17 @@ worauf du bei der Veröffentlichung achten solltest.
 | `src/ocr-extract.js` | OCR-Rohtext → Spec-Felder |
 | `src/session.js` | Stapel halten, vorschlagen, buchen, umsortieren, zurücknehmen — inklusive der aus den Einträgen abgeleiteten, je Stapel bekannten Barcode-Inhalte (`stack.codes`), die vor dem Vergleich der technischen Angaben über die Zuordnung entscheiden, sofern diese Angaben nicht widersprechen |
 | `src/pipeline.js` | Barcode → Teilenummer → OCR → Ampelfarbe, inkl. Zeitgrenzen, Mehrdeutigkeitsbehandlung und Kurzschluss über einen bereits bekannten Barcode-Inhalt (`deps.isKnownCode`) — kennt keine Scan-Funktionen; liefert zusätzlich (additiv) den ungefilterten OCR-Rohtext (`rawText`), leer, wenn keine Texterkennung lief |
-| `src/scan-modes.js` | Die drei Scan-Funktionen (Strichcode, QR-Code, Text erkennen): Kennung, deutsche Beschriftung, gelesene Codearten, laufende Suche ja/nein, Texterkennung ja/nein — einzige Quelle, sowohl für die Auswahl-Oberfläche als auch für `main.js` |
-| `src/scan-recognition.js` | Baut die an `recognize()` übergebenen Adapter anhand der gewählten Funktion: in „Strichcode"/„QR-Code" liefert die Texterkennung sofort leeren Text ohne Tesseract anzustoßen, in „Text erkennen" liefert die Barcode-Dekodierung sofort eine leere Liste ohne `zxing-wasm` anzustoßen |
+| `src/scan-modes.js` | Die vier Scan-Funktionen (Strichcode, QR-Code, Text erkennen, Zählen): Kennung, deutsche Beschriftung, gelesene Codearten, laufende Codesuche ja/nein, Texterkennung ja/nein — einzige Quelle, sowohl für die Auswahl-Oberfläche als auch für `main.js`. „Zählen" läuft wie „Text erkennen" auf Knopfdruck (`continuousSearch: false`) und braucht dafür kein eigenes Merkmal mehr |
+| `src/scan-recognition.js` | Baut die an `recognize()` übergebenen Adapter anhand der gewählten Funktion: liest eine Funktion keine Codearten (leeres `barcodeFormats`, bei „Text erkennen" und „Zählen"), liefert die Barcode-Dekodierung sofort eine leere Liste ohne `zxing-wasm` anzustoßen; nur bei `useOcr` läuft die echte Texterkennung, sonst liefert sie sofort leeren Text ohne Tesseract anzustoßen (in „Zählen" ruft `recognize()` im normalen Betrieb ohnehin nicht auf — siehe `count-capture.js`) |
+| `src/count-capture.js` | Reine Berechnung für die Aufnahme in Funktion „Zählen": bildet aus den (bis zu fünf) Einzelmessungen einer Aufnahme (`countObjects()` je Bild) deren Median (`combineCaptureCounts`) — robust gegen ein einzelnes verwackeltes oder unscharfes Bild, bleibt auch bei weniger als fünf verwertbaren Bildern sinnvoll |
+| `src/threshold.js` | Otsu-Schwellwertbestimmung (Graustufen, Histogramm, Schwellwert) — reines Modul ohne Browser-Zugriff, aus `ocr.js` herausgezogen; gemeinsame Grundlage für `preprocess()` (ocr.js) und `countObjects()` (count-objects.js) |
+| `src/count-objects.js` | Reine Berechnung für Funktion „Zählen": zählt zusammenhängende Objektflächen in einem Bildausschnitt über örtlichen Kontrast (Normierung auf 800 Bildpunkte Breite, Glättung und örtlicher Hintergrund je über Kastenfilter/Summenbild, Maske aus geglättetem Bild vs. örtlichem Hintergrund ± Marge, beide Polaritäten, Connected-Component-Labeling mit eigener Arbeitsliste, Rauschfilter, Massstab relativ zur größten Fläche, Hochrechnung berührender Teile über den Flächen-Median) — nutzt `threshold.js`/Otsu bewusst **nicht** mehr (siehe „Funktionsweise" oben) |
 | `src/storage.js` | Absturzschutz der laufenden Sitzung: sichert und lädt aus `localStorage`, verwirft beim Laden jeden in sich unstimmigen Zustand vollständig (siehe unten); `entry.rawText` ist wie `entry.codes` optional und wird bei Fehlen als leerer Rohtext wiederhergestellt |
-| `src/camera.js` | Kamerastart, Einzelbildaufnahme (herunterskaliert, für die Dateiauswahl), Rahmenausschnitt in voller Auflösung (`grabFrameRegion`, für die laufende Barcode-Suche **und** für „Modul scannen" in „Text erkennen"), Bilddatei-Ersatzweg |
+| `src/camera.js` | Kamerastart, Einzelbildaufnahme (herunterskaliert, für die Dateiauswahl), Rahmenausschnitt in voller Auflösung (`grabFrameRegion`, für die laufende Barcode-Suche, „Modul scannen" in „Text erkennen" **und** jedes der fünf Bilder einer Aufnahme in „Zählen"), Bilddatei-Ersatzweg |
 | `src/barcode.js` | Adapter zu `zxing-wasm`; `decodeBarcodes(imageData, formats)` bekommt die Codearten übergeben, ohne Angabe wie bisher (Code128 + DataMatrix) |
-| `src/ocr.js` | Bildaufbereitung (Otsu) und Adapter zu `tesseract.js`; Zeichen-Whitelist deckt Groß- und Kleinbuchstaben, Ziffern sowie übliche Etiketten-Sonderzeichen ab |
-| `src/ui/scan-view.js` | Scan-Ansicht: Kamera-Vorschau, antippbare Anzeige der gewählten Funktion (Wechsel), Scan-Knopf (nur in „Text erkennen" sichtbar), Stapel-Leiste, „Zuletzt"-Zeile, Ersatzweg-Schaltfläche bei fehlender Kamera |
-| `src/ui/mode-dialog.js` | Vollbild-Auswahl der Scan-Funktion vor dem Start und beim Wechsel: drei große Flächen, eine je Funktion aus `src/scan-modes.js` |
+| `src/ocr.js` | Bildaufbereitung (Otsu, über `threshold.js`) und Adapter zu `tesseract.js`; Zeichen-Whitelist deckt Groß- und Kleinbuchstaben, Ziffern sowie übliche Etiketten-Sonderzeichen ab |
+| `src/ui/scan-view.js` | Scan-Ansicht: Kamera-Vorschau, antippbare Anzeige der gewählten Funktion (Wechsel), eine gemeinsame Aufnahme-Schaltfläche für beide Knopfdruck-Funktionen (sichtbar in „Text erkennen" und „Zählen", Wortlaut je nach Funktion und Zustand über `setCaptureLabel`), große Zählanzeige samt Diagnosezeile (nur in „Zählen" sichtbar), Stapel-Leiste, „Zuletzt"-Zeile, Ersatzweg-Schaltfläche bei fehlender Kamera |
+| `src/ui/mode-dialog.js` | Vollbild-Auswahl der Scan-Funktion vor dem Start und beim Wechsel: vier große Flächen, eine je Funktion aus `src/scan-modes.js` |
 | `src/ui/result-overlay.js` | Treffer-Rückmeldung (grün/gelb): blendet sich in „Strichcode"/„QR-Code" nach kurzer Zeit selbst aus; in „Text erkennen" bleibt sie stehen, zeigt den vollen OCR-Rohtext und wartet auf eine Eingabe, bevor sie schließt |
 | `src/ui/ambiguous-dialog.js` | Rot-Dialog bei roter Konfidenz oder mehrdeutiger Stapelzuordnung |
 | `src/ui/resume-dialog.js` | Dialog beim Start: gesicherte Sitzung fortsetzen oder verwerfen — läuft vor der Funktionswahl |
@@ -312,10 +404,12 @@ worauf du bei der Veröffentlichung achten solltest.
 | `.vch/deploy.yaml` | Bau- und Startbefehl sowie Gesundheitspfad für die Hosting-Umgebung |
 
 `spec`, `pn-decoder`, `ocr-extract`, `session`, `pipeline`, `storage`,
-`scan-modes` und `scan-recognition` sind reine Funktionen ohne Browser-Zugriff
-(kein `window`, `document` oder `localStorage` direkt) und deshalb vollständig
-mit `node:test` prüfbar. `camera.js`, `barcode.js`, `ocr.js` und `src/ui/`
-brauchen einen echten Browser und werden nur manuell geprüft.
+`scan-modes`, `scan-recognition`, `threshold`, `count-objects` und
+`count-capture` sind reine Funktionen ohne Browser-Zugriff (kein `window`,
+`document` oder `localStorage` direkt) und deshalb vollständig mit
+`node:test` prüfbar.
+`camera.js`, `barcode.js`, `ocr.js` und `src/ui/` brauchen einen echten
+Browser und werden nur manuell geprüft.
 
 ### Sitzungssicherung im Detail
 
@@ -390,6 +484,43 @@ Eintrag und fließt in keine Stapel-Berechnung ein.
   Aufnahmen (Zeilenumbrüche, zusätzlich erkannte Wörter, Groß-/
   Kleinschreibung, …) und würde als Gruppierungsmerkmal für praktisch jedes
   Modul einen eigenen Stapel erzeugen.
+- **Funktion „Zählen" ist eine Schätzung, keine exakte Zählung** — sie wird
+  ungenau, wenn eine der folgenden Bedingungen zutrifft:
+  - **Der Untergrund muss sich abheben.** Das Verfahren erkennt Fundstücke
+    über den örtlichen Kontrast zu ihrer unmittelbaren Umgebung (siehe
+    „Funktionsweise" oben) — es braucht also eine Stelle, an der sich das
+    Fundstück *lokal* von dem unterscheidet, was um es herum liegt. Ein
+    Fundstück, das nahezu dieselbe Helligkeit wie der Tisch/das Leder
+    darunter hat, wird nicht zuverlässig gefunden.
+  - **Gleichmäßige Ausleuchtung hilft.** Der örtliche Hintergrund wird aus
+    einem Fenster um jeden Bildpunkt gebildet und fängt einseitigen
+    Lichteinfall dadurch besser ab als ein einzelner, fester Schwellwert
+    für das ganze Bild. Sehr harte Schlagschatten oder Reflexe können
+    trotzdem eigene, dem Fundstück ähnliche Kontrastflächen erzeugen (siehe
+    „mehrere gefundene Flächen" unten) und die Zählung verfälschen.
+  - **Auseinandergelegt zählt besser als aufgehäuft/berührend.** Mehrere
+    Teile, die sich berühren, bilden eine einzige zusammenhängende Fläche.
+    Die App rechnet diese über die typische Einzelteilgröße (Median der
+    gefundenen Flächen) auf ein Vielfaches hoch, aber je unregelmäßiger sich
+    die Teile überlappen (z. B. mehrere Schrauben, die sich gegenseitig
+    teilweise verdecken statt sich nur zu berühren), desto ungenauer wird
+    die hochgerechnete Fläche — und je dichter die Teile gedrängt liegen,
+    desto eher sieht das Umgebungsfenster (siehe oben) an ihrer eigenen
+    Stelle vor allem Nachbarteile statt echten Untergrund. Liegen Teile
+    übereinander gestapelt statt nebeneinander ausgelegt, sieht die Kamera
+    von oben nur die Fläche des obersten Teils — verdeckte Teile werden
+    nicht mitgezählt.
+  - **Stark unterschiedlich große Teile verfälschen die Hochrechnung.** Die
+    Hochrechnung setzt voraus, dass die meisten Fundstücke ungefähr gleich
+    groß sind (der Median dient als Maßstab für „ein Teil"). Liegen im
+    selben Rahmen sowohl deutlich größere als auch deutlich kleinere Teile
+    derselben Sorte (oder gar unterschiedliche Teile gemischt), kann die
+    Rauschschwelle ein tatsächliches kleines Teil verwerfen oder die
+    Hochrechnung ein einzelnes großes Teil als mehrere zählen.
+  - Details, die verwendeten Schwellenwerte, ihre Begründung und die
+    Messung am echten Foto (~20 Festplattenschrauben auf Leder, für das
+    das alte Otsu-basierte Verfahren 76712 statt rund zwanzig meldete)
+    stehen in `.superpowers/sdd/counting-rework-report.md`.
 
 ## Herstellertabellen erweitern
 
@@ -433,10 +564,11 @@ werden:
 - Datei-Auswahl als Ersatzweg (ohne Kamera) öffnet den nativen Dialog und
   hinterlässt keine leere Fläche im Layout.
 
-**Funktionswahl (neu)**
-- Erster Start ohne gesicherte Sitzung: Auswahl mit drei großen Flächen
-  („Strichcode", „QR-Code", „Text erkennen") erscheint, *bevor* die Kamera
-  startet — kein Kamerabild sichtbar, solange keine Funktion gewählt ist.
+**Funktionswahl**
+- Erster Start ohne gesicherte Sitzung: Auswahl mit vier großen Flächen
+  („Strichcode", „QR-Code", „Text erkennen", „Zählen") erscheint, *bevor* die
+  Kamera startet — kein Kamerabild sichtbar, solange keine Funktion gewählt
+  ist.
 - Erster Start *mit* gesicherter Sitzung: erst die Frage „Gesicherte Sitzung
   gefunden" (fortsetzen/verwerfen), erst danach die Funktionswahl.
 - „Strichcode" wählen: laufende Suche erkennt Code-128/Code-39/EAN/UPC/…,
@@ -488,6 +620,46 @@ werden:
   dass die Vorbereitung tatsächlich nur einmal läuft)? In Funktion „Text
   erkennen" darf dieses Laden dagegen gar nicht erst anlaufen, da dort nie
   `decodeBarcodes` aufgerufen wird.
+**Zählen (Aufnahme statt Dauerbetrieb)**
+- „Zählen" wählen, Kamera auf ausgelegte Kleinteile richten (z. B. silberne
+  Festplattenschrauben auf dunklem Untergrund): Es erscheint **keine**
+  Zahl und **keine** fortlaufende Aktualisierung, sondern eine gut
+  erreichbare Schaltfläche mit der Aufschrift „Zählen". Kein roter Dialog,
+  keine Treffer-Rückmeldung, keine Stapel-Zuweisung — der Zielrahmen bleibt
+  sichtbar und zeigt, was beim nächsten Antippen gezählt wird.
+- „Zählen" antippen: Für rund eine Sekunde zeigt die Statuszeile „zähle …“,
+  danach erscheint eine große Zahl im Bild und bleibt stehen — sie
+  aktualisiert sich **nicht** von selbst weiter. Die Schaltfläche trägt jetzt
+  die Aufschrift „Nochmal zählen".
+- Während der rund einen Sekunde Kamera und Teile ruhig halten (leichte
+  Bewegung zwischendurch simulieren) und danach prüfen, dass das Ergebnis
+  plausibel bleibt — die App nimmt in dieser Zeit fünf Bilder auf und zeigt
+  deren Median.
+- Die Zahl antippen: Diagnosezeile blendet sich ein und zeigt (in dieser
+  Reihenfolge) `Roh: …`, `Messungen: …` (die fünf Einzelmessungen dieser
+  Aufnahme, z. B. `17, 18, 19, 18, 20`), `Bild: …`, `Flächen: …`,
+  `Größte Fläche: …`, `Typische Größe: …`, `Art: …`, `Dauer: …`. Nochmaliges
+  Antippen blendet sie wieder aus. Prüfen, dass die fünf Messungen tatsächlich
+  eng beieinanderliegen, wenn die Teile ruhig lagen, und spürbar streuen,
+  wenn während der Aufnahme bewegt wurde.
+- „Nochmal zählen" antippen: neue Aufnahme, neues Ergebnis ersetzt das alte
+  vollständig (Zahl **und** Diagnosezeile).
+- Zur Funktionswahl wechseln und zurück zu „Zählen": Zahl und Diagnosezeile
+  sind zurückgesetzt (nichts angezeigt), Schaltfläche zeigt wieder „Zählen"
+  statt „Nochmal zählen". Dasselbe beim Wechsel zu einer anderen Funktion und
+  zurück.
+- Zugänge zur Sitzungsliste und zum Funktionswechsel bleiben auch in dieser
+  Funktion erreichbar (Anzeige der Funktion antippen, Stapel-Leiste antippen)
+  — außer während die rund einssekündige Aufnahme selbst läuft, genau wie bei
+  einem laufenden Scan in „Text erkennen".
+- Aufnahme antippen, bevor das Kamerabild bereit ist (z. B. gleich nach dem
+  Start): verständliche Meldung „Zählen nicht möglich — Kamerabild noch
+  nicht bereit" statt Absturz oder stiller Nichtreaktion.
+- Gegenprobe der Grenzen (siehe „Grenzen" oben): Teile eng aneinanderlegen
+  (Hochrechnung), Teile stapeln (nur oberste Schicht zählt), einseitige
+  Beleuchtung, geringer Kontrast zum Untergrund — beobachten, wo die Zahl
+  spürbar daneben liegt, bisher nur an synthetischen Testbildern geprüft, nie
+  an einem echten Foto.
 - Verbindung während des allerersten Scans einer Sitzung unterbrechen (WASM
   lädt per CDN), danach mit wiederhergestellter Verbindung erneut scannen:
   Das muss einen echten neuen Ladeversuch auslösen statt dauerhaft mit

src/count-capture.js

@@ -0,0 +1,39 @@
+// Bildet aus den Einzelmessungen einer Zaehl-Aufnahme (Funktion "Zählen",
+// siehe main.js) das anzuzeigende Endergebnis. main.js nimmt je Antippen der
+// Schaltflaeche "Zählen"/"Nochmal zählen" binnen rund einer Sekunde mehrere
+// Bilder aus dem Zielrahmen auf und zaehlt jedes einzeln (countObjects() in
+// count-objects.js, unveraendert) - ein einzelnes verwackeltes oder mitten in
+// eine Fokusregelung fallendes Bild soll das Ergebnis nicht verzerren. Frueher
+// glaettete ein gleitender Median ueber die letzten neun Durchlaeufe einer
+// Dauerzaehlung (siehe .superpowers/sdd/counting-capture-report.md); das ist
+// entfallen, weil eine Aufnahme mit mehreren Bildern dieselbe Robustheit
+// bereits in sich selbst leistet - zwei Glaettungen uebereinander waeren nur
+// zusaetzliche Traegheit ohne zusaetzlichen Nutzen.
+//
+// Der Median der Einzelmessungen ist robust gegen einen einzelnen groben
+// Ausreisser (anders als deren Mittelwert) - siehe median() in
+// count-objects.js fuer dieselbe Ueberlegung bei den dortigen
+// Flaechengroessen.
+//
+// Reines, browserfreies Modul wie count-objects.js - kennt weder Kamera noch
+// Bilddaten, nur die Zahlenreihe der Einzelmessungen selbst.
+import { median } from './count-objects.js';
+
+/**
+ * Bildet den Median der Einzelmessungen einer Aufnahme (siehe Moduldoku
+ * oben). Bleibt auch dann sinnvoll, wenn eine Aufnahme aus weniger als den
+ * vorgesehenen fuenf Bildern besteht (z. B. weil das Kamerabild waehrend
+ * eines Versuchs kurz nicht bereit war, siehe grabFrameRegion() in
+ * camera.js) - nur eine vollstaendig leere Aufnahme (kein einziges
+ * verwertbares Bild) ist kein regulaerer Ausgang und wirft; main.js prueft
+ * diesen Fall vorher selbst und ruft diese Funktion dann gar nicht erst auf.
+ * @param {number[]} counts Einzelmessungen dieser Aufnahme - nicht-leer.
+ * @returns {number}
+ * @throws {Error} wenn counts leer ist.
+ */
+export function combineCaptureCounts(counts) {
+  if (counts.length === 0) {
+    throw new Error('combineCaptureCounts: keine Messung vorhanden');
+  }
+  return median(counts);
+}

src/count-objects.js

@@ -0,0 +1,483 @@
+// 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.
+//
+// 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).
+
+// Zielbreite fuer die Normierung (Schritt 1). Schmalere Bilder bleiben
+// unveraendert.
+const TARGET_WIDTH = 800;
+
+// 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
+ * Teile) oder sehr kleine (Rauschen) Ausreisser, anders als der Mittelwert.
+ * Exportiert, weil dieselbe Robustheit die Diagnoseanzeige braucht, um aus
+ * den letzten Zaehlmessungen eine ruhigere Zahl zu bilden (siehe
+ * count-history.js) - ein einzelner Ausreisser (Bewegungsunschaerfe,
+ * nachregelnder Autofokus) soll dort ebenso wenig durchschlagen wie hier bei
+ * den Flaechengroessen.
+ * @param {number[]} values nicht-leer
+ * @returns {number}
+ */
+export function median(values) {
+  const sorted = [...values].sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0
+    ? (sorted[middle - 1] + sorted[middle]) / 2
+    : 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
+ * (und beide Polaritaeten) wiederverwendet.
+ * @param {number} startIndex
+ * @param {(index: number) => boolean} isObjectPixel
+ * @param {Uint8Array} visited
+ * @param {number} width
+ * @param {number} height
+ * @param {Int32Array} stack wiederverwendeter Arbeitsspeicher, mind. width*height gross
+ * @returns {number} Anzahl der zur Flaeche gehoerenden Bildpunkte
+ */
+function floodFill(startIndex, isObjectPixel, visited, width, height, stack) {
+  let top = 0;
+  stack[top] = startIndex;
+  top += 1;
+  visited[startIndex] = 1;
+  let area = 0;
+
+  while (top > 0) {
+    top -= 1;
+    const index = stack[top];
+    area += 1;
+
+    const x = index % width;
+    const y = (index - x) / width;
+
+    if (x > 0) {
+      const n = index - 1;
+      if (!visited[n] && isObjectPixel(n)) {
+        visited[n] = 1;
+        stack[top] = n;
+        top += 1;
+      }
+    }
+    if (x < width - 1) {
+      const n = index + 1;
+      if (!visited[n] && isObjectPixel(n)) {
+        visited[n] = 1;
+        stack[top] = n;
+        top += 1;
+      }
+    }
+    if (y > 0) {
+      const n = index - width;
+      if (!visited[n] && isObjectPixel(n)) {
+        visited[n] = 1;
+        stack[top] = n;
+        top += 1;
+      }
+    }
+    if (y < height - 1) {
+      const n = index + width;
+      if (!visited[n] && isObjectPixel(n)) {
+        visited[n] = 1;
+        stack[top] = n;
+        top += 1;
+      }
+    }
+  }
+
+  return area;
+}
+
+/**
+ * Fuehrt Schritte 6-10 (siehe Moduldoku oben) fuer eine Polaritaet aus
+ * (helle Objekte auf dunklerem Grund oder umgekehrt). Liefert - anders als
+ * die fruehere Fassung - nie `null`, sondern immer ein vollstaendig belegtes
+ * Ergebnis, auch wenn keine (oder keine signifikante) Flaeche uebrig bleibt:
+ * die Diagnoseanzeige muss gerade dann zeigen koennen, *woran* es gescheitert
+ * ist (gar nichts gefunden? nur Rauschen? nur zu kleine Flaechen?). An der
+ * eigentlichen Zaehlung (Schritte 6-10 selbst) aendert das nichts - `count`
+ * ist bei einer leeren `significantAreas`-Liste weiterhin 0, exakt wie beim
+ * frueheren `null`.
+ * @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, rawCount: number, filteredCount: number, significantCount: number, largestArea: number, typicalArea: number}}
+ */
+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));
+  }
+
+  // Schritt 7: grobes Rauschen (Staub, Kratzer, Lichtreflexe) verwerfen. Auf
+  // einer leeren rawAreas-Liste bleibt auch afterNoise leer - kein
+  // Sonderfall noetig.
+  const noiseThreshold = Math.max(8, 0.00002 * totalPixels);
+  const afterNoise = rawAreas.filter((area) => area >= noiseThreshold);
+
+  // Schritt 8: Massstab aus der groessten verbliebenen Flaeche ableiten -
+  // bewusst relativ (siehe Moduldoku), nicht als fester Bildpunktwert. Bleibt
+  // nach der Rauschfilterung nichts uebrig, gibt es auch keinen Massstab
+  // (largestArea 0) und folglich auch keine signifikanten Flaechen.
+  const largestArea = afterNoise.length > 0 ? Math.max(...afterNoise) : 0;
+  const scaleThreshold = largestArea * SCALE_FRACTION_OF_LARGEST;
+  const significantAreas = afterNoise.filter((area) => area >= scaleThreshold);
+
+  // Schritt 9: typische Einzelgroesse - nur bestimmbar, wenn ueberhaupt eine
+  // Flaeche beide Filter uebersteht (median() verlangt eine nicht-leere Liste).
+  const typicalArea = significantAreas.length > 0 ? median(significantAreas) : 0;
+
+  // Schritt 10: zaehlen, dabei rundet auf statt abzuschneiden (siehe alte
+  // Fassung: ein nur leicht groesseres Einzelteil soll nicht faelschlich als
+  // zwei zaehlen). Bleibt keine Flaeche uebrig, durchlaeuft die Schleife kein
+  // einziges Mal - count und totalArea bleiben bei 0.
+  let count = 0;
+  let totalArea = 0;
+  for (const area of significantAreas) {
+    count += Math.max(1, Math.round(area / typicalArea));
+    totalArea += area;
+  }
+
+  return {
+    count,
+    totalArea,
+    rawCount: rawAreas.length,
+    filteredCount: afterNoise.length,
+    significantCount: significantAreas.length,
+    largestArea,
+    typicalArea,
+  };
+}
+
+/**
+ * Waehlt die gewinnende Polaritaet (siehe ausfuehrliche Begruendung im
+ * Kommentar in countObjects() unten). Massgeblich ist, welche Polaritaet
+ * mehr signifikante (Rausch- und Groessenfilter ueberstehende) Flaechen
+ * behalten hat; bei Gleichstand entscheidet die kleinere Gesamtflaeche.
+ * Haben beide Polaritaeten keine einzige signifikante Flaeche behalten (die
+ * Zaehlung ergibt in jedem Fall 0), entscheidet ersatzweise, welche
+ * ueberhaupt mehr Struktur gefunden hat (erst nach, dann vor der
+ * Rauschfilterung) - das aendert nichts mehr am Ergebnis (0), belegt aber
+ * die Diagnosewerte weiterhin sinnvoll statt mit einer willkuerlichen Wahl.
+ * @param {ReturnType<typeof analyzePolarity>} bright
+ * @param {ReturnType<typeof analyzePolarity>} dark
+ * @returns {ReturnType<typeof analyzePolarity> & {polarity: 'hell' | 'dunkel'}}
+ */
+function pickWinner(bright, dark) {
+  if (bright.significantCount === 0 && dark.significantCount === 0) {
+    if (dark.filteredCount > bright.filteredCount) return { ...dark, polarity: 'dunkel' };
+    if (dark.filteredCount === bright.filteredCount && dark.rawCount > bright.rawCount) {
+      return { ...dark, polarity: 'dunkel' };
+    }
+    return { ...bright, polarity: 'hell' };
+  }
+  if (dark.significantCount === 0) return { ...bright, polarity: 'hell' };
+  if (bright.significantCount === 0) return { ...dark, polarity: 'dunkel' };
+  if (bright.significantCount !== dark.significantCount) {
+    return bright.significantCount > dark.significantCount
+      ? { ...bright, polarity: 'hell' }
+      : { ...dark, polarity: 'dunkel' };
+  }
+  return bright.totalArea <= dark.totalArea
+    ? { ...bright, polarity: 'hell' }
+    : { ...dark, polarity: 'dunkel' };
+}
+
+/**
+ * Zaehlt die Fundstuecke (z. B. ausgelegte Schrauben) in einem
+ * Kamera-Ausschnitt anhand oertlichen Kontrasts. Reine Anzeigefunktion -
+ * erzeugt keinen Zustand, bucht nichts, veraendert keine Sitzung.
+ *
+ * Die Rueckgabe traegt neben der Anzahl selbst (unveraendert in Bedeutung)
+ * additiv die Zwischenwerte, die eine Diagnoseanzeige braucht, um am
+ * Nutzergeraet zu erkennen, *woran* eine abweichende Zaehlung liegt (siehe
+ * ui/scan-view.js und main.js) - allesamt auch dann sinnvoll belegt, wenn
+ * count 0 ergibt.
+ * @param {{width: number, height: number, data: Uint8ClampedArray}} imageData
+ * @returns {{
+ *   count: number,
+ *   width: number,
+ *   height: number,
+ *   regionsFound: number,
+ *   regionsKept: number,
+ *   largestArea: number,
+ *   typicalArea: number,
+ *   polarity: 'hell' | 'dunkel' | null,
+ * }}
+ *   count: ermittelte, bereits gerundete Anzahl - 0, wenn keine
+ *     Objektflaeche gefunden wurde (leerer Ausschnitt, reiner Untergrund
+ *     ohne Kontrast oder ein Ausschnitt ohne Bildpunkte).
+ *   width, height: Groesse des tatsaechlich ausgewerteten Bildes, also nach
+ *     der Normierung auf feste Breite (Schritt 1) - 0/0, wenn der
+ *     Ausschnitt selbst schon keine Bildpunkte hatte (dann fand keine
+ *     Normierung statt).
+ *   regionsFound: Anzahl zusammenhaengender Flaechen der gewinnenden
+ *     Polaritaet vor jeder Filterung (Schritt 6, vor Schritt 7).
+ *   regionsKept: Anzahl der Flaechen, die nach vollstaendiger Filterung
+ *     (Rauschen Schritt 7, Groesse Schritt 8) uebrig bleiben.
+ *   largestArea: Groesse der groessten verbliebenen Flaeche in Bildpunkten.
+ *   typicalArea: als typisch bestimmte Einzelgroesse (Median, Schritt 9) in
+ *     Bildpunkten - 0, wenn keine Flaeche uebrig blieb.
+ *   polarity: welche Polaritaet gewonnen hat ('hell': helle Objekte auf
+ *     dunklerem Grund, 'dunkel': umgekehrt) - null nur, wenn der Ausschnitt
+ *     selbst schon keine Bildpunkte hatte und daher gar keine Polaritaet
+ *     berechnet wurde.
+ */
+export function countObjects(imageData) {
+  if (imageData.width * imageData.height === 0) {
+    return {
+      count: 0,
+      width: 0,
+      height: 0,
+      regionsFound: 0,
+      regionsKept: 0,
+      largestArea: 0,
+      typicalArea: 0,
+      polarity: null,
+    };
+  }
+
+  // Schritt 1: auf feste Breite normieren.
+  const resized = resizeToWidth(imageData, TARGET_WIDTH);
+  const { width, height } = resized;
+  const totalPixels = width * height;
+
+  // 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);
+
+  // 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);
+
+  // ... 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);
+
+  // Eine Polaritaet muss gewinnen (siehe pickWinner() oben fuer den
+  // Sonderfall "beide leer"). 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.
+  const winner = pickWinner(bright, dark);
+
+  return {
+    count: winner.count,
+    width,
+    height,
+    regionsFound: winner.rawCount,
+    regionsKept: winner.significantCount,
+    largestArea: winner.largestArea,
+    typicalArea: winner.typicalArea,
+    polarity: winner.polarity,
+  };
+}

src/main.js

@@ -3,6 +3,8 @@
 import { startCamera, grabFrameRegion, imageDataFromFile } from './camera.js';
 import { decodeBarcodes } from './barcode.js';
 import { runOcr, isOcrAvailable } from './ocr.js';
+import { countObjects } from './count-objects.js';
+import { combineCaptureCounts } from './count-capture.js';
 import { recognize } from './pipeline.js';
 import { normalizeToken } from './spec.js';
 import { getScanMode } from './scan-modes.js';
@@ -49,14 +51,33 @@ let cameraUnavailableMessage = null;
 // ohnehin unerreichbar.
 let currentModeId = null;
 
+// Ob die aktuelle Sitzung in Funktion "Zählen" bereits eine Aufnahme gemacht
+// hat - traegt die Beschriftung der Aufnahme-Schaltflaeche ("Zählen" vor der
+// ersten Aufnahme seit Betreten der Funktion, "Nochmal zählen" danach, siehe
+// updateCountCaptureLabel() unten). Wird bei jedem Aufruf von applyMode()
+// zurueckgesetzt: sowohl ein Wechsel weg von "Zählen" als auch ein (erneuter)
+// Eintritt in die Funktion beginnt wieder bei "Zählen" - siehe auch
+// view.setCountVisible() (loescht das stehende Ergebnis samt Diagnose beim
+// Verlassen).
+let hasCountResult = false;
+
 const view = renderScanView(app, {
-  // "Modul scannen" ist nur in Funktion 3 ("Text erkennen") sichtbar (siehe
-  // applyMode()/setCaptureVisible) - der Zielrahmen suggeriert dem Nutzer dort
-  // einen Ausschnitt, den grabFrame() (Vollbild, herunterskaliert) bisher gar
-  // nicht einloeste. grabFrameRegion() liest genau den Rahmenausschnitt, in
-  // voller Aufloesung - derselbe Ausschnitt, den auch die Barcode-Dauersuche
+  // Eine gemeinsame Schaltflaeche fuer beide Knopfdruck-Funktionen (siehe
+  // scan-view.js/setCaptureLabel()): in Funktion "Text erkennen" loest sie
+  // processCapture() aus (Erkennung + Buchung), in Funktion "Zählen"
+  // stattdessen runCountCapture() (Aufnahme mehrerer Bilder, keine Buchung).
+  // Der Zielrahmen suggeriert dem Nutzer in beiden Faellen einen Ausschnitt,
+  // den grabFrame() (Vollbild, herunterskaliert) nicht einloeste -
+  // grabFrameRegion() liest genau den Rahmenausschnitt, in voller
+  // Aufloesung - derselbe Ausschnitt, den auch die Barcode-Dauersuche
   // benutzt (siehe runSearchAttempt() weiter unten).
-  onCapture: () => processCapture(() => grabFrameRegion(view.video)),
+  onCapture: () => {
+    if (currentModeId === 'count') {
+      runCountCapture();
+    } else {
+      processCapture(() => grabFrameRegion(view.video));
+    }
+  },
   onUndo: () => {
     // Waehrend eine Erkennung laeuft, darf kein Eintrag zurueckgenommen
     // werden - sonst koennte die Rueckgaengig-Flaeche einen Eintrag treffen,
@@ -82,22 +103,38 @@ const view = renderScanView(app, {
 });
 
 /**
- * Uebernimmt eine (neu gewaehlte) Scan-Funktion: Anzeige, Sichtbarkeit von
- * "Modul scannen" und - bei einem Wechsel weg von laufender Codesuche - der
- * Zielrahmen wird sofort zurueckgesetzt, statt auf den naechsten Durchlauf
- * der Dauersuche zu warten.
+ * Uebernimmt eine (neu gewaehlte) Scan-Funktion: Anzeige, Sichtbarkeit und
+ * Beschriftung der Aufnahme-Schaltflaeche und - bei einem Wechsel weg von
+ * laufender Codesuche - der Zielrahmen wird sofort zurueckgesetzt, statt auf
+ * den naechsten Durchlauf der Dauersuche zu warten.
  * @param {string} modeId
  */
 function applyMode(modeId) {
   currentModeId = modeId;
   const mode = getScanMode(modeId);
   view.setMode(mode.label);
-  // "Modul scannen" hat nur dort etwas zu tun, wo es keine laufende Suche
-  // gibt (Funktion 3) - siehe Kommentar in scan-view.js/setCaptureVisible.
+  // Die Aufnahme-Schaltflaeche hat nur dort etwas zu tun, wo es keine
+  // laufende Codesuche gibt (Funktion 3 "Text erkennen" und Funktion 4
+  // "Zählen") - siehe Kommentar in scan-view.js/setCaptureVisible.
   view.setCaptureVisible(!mode.continuousSearch);
   if (!mode.continuousSearch) {
     view.setFrameDetected(false);
   }
+  // "Zählen" beginnt bei jedem (erneuten) Betreten wieder bei der
+  // Beschriftung "Zählen" statt "Nochmal zählen" - ein Wechsel weg von der
+  // Funktion soll das ebenso wenig ueberleben wie ein erneuter Eintritt mit
+  // altem Zustand (siehe Deklaration von hasCountResult oben).
+  hasCountResult = false;
+  if (mode.id === 'count') {
+    updateCountCaptureLabel();
+  } else {
+    view.setCaptureLabel(mode.useOcr ? 'Modul scannen' : '');
+  }
+  // Die grosse Zaehlanzeige gehoert ausschliesslich zu Funktion "Zählen" -
+  // beim Verlassen sofort ausblenden (loescht dabei auch ein stehendes
+  // Ergebnis samt Diagnose, siehe scan-view.js/setCountVisible), statt auf
+  // die naechste Aufnahme zu warten.
+  view.setCountVisible(mode.id === 'count');
 }
 
 /**
@@ -122,6 +159,25 @@ function describeEntry(spec, stackId) {
   return `${describeSpec(spec)} → Stapel ${stackId}`;
 }
 
+/**
+ * Stellt die Statuszeile nach einem erfolgreich abgeschlossenen Durchlauf
+ * (Erkennung wie Zaehl-Aufnahme) wieder her - von processCapture() und
+ * runCountCapture() gemeinsam genutzt, statt denselben Vorrang zweimal
+ * hinzuschreiben. Der Hinweis auf eine nicht verfuegbare Kamera hat Vorrang
+ * vor der OCR-Verfuegbarkeitsanzeige und bleibt dauerhaft stehen.
+ */
+function restoreIdleStatus() {
+  if (cameraUnavailableMessage) {
+    view.setStatus(cameraUnavailableMessage, true);
+  } else {
+    const available = isOcrAvailable();
+    view.setStatus(
+      available ? '' : 'Texterkennung nicht verfuegbar — nur Barcodes werden gelesen',
+      !available,
+    );
+  }
+}
+
 /**
  * Ein Scan-Durchlauf: Bild beschaffen, erkennen, bei unsicherer Erkennung
  * nachfragen, buchen, kurz rueckmelden. Laeuft ohne Bestaetigung durch,
@@ -220,19 +276,8 @@ async function processCapture(getFrame) {
   } finally {
     busy = false;
     // Die OCR-Verfuegbarkeitsanzeige darf eine Fehlermeldung, die der Nutzer
-    // noch lesen muss, nicht ueberschreiben. Der Hinweis auf eine nicht
-    // verfuegbare Kamera hat Vorrang vor beidem und bleibt dauerhaft stehen.
-    if (!failed) {
-      if (cameraUnavailableMessage) {
-        view.setStatus(cameraUnavailableMessage, true);
-      } else {
-        const available = isOcrAvailable();
-        view.setStatus(
-          available ? '' : 'Texterkennung nicht verfuegbar — nur Barcodes werden gelesen',
-          !available,
-        );
-      }
-    }
+    // noch lesen muss, nicht ueberschreiben.
+    if (!failed) restoreIdleStatus();
   }
 }
 
@@ -351,9 +396,153 @@ async function runSearchAttempt() {
   await processCapture(() => Promise.resolve(region));
 }
 
+/** Kurzbezeichnung der Polaritaet (siehe count-objects.js) fuer die Diagnosezeile. */
+function describePolarity(polarity) {
+  if (polarity === 'hell') return 'hell auf dunkel';
+  if (polarity === 'dunkel') return 'dunkel auf hell';
+  return '–';
+}
+
+/**
+ * Baut den Wortlaut der Diagnosezeile unter der grossen Zahl (siehe
+ * ui/scan-view.js/setCountDiagnostics()). Kurze, unfachliche Bezeichnungen
+ * in eigenen Zeilen statt einer einzigen langen Zeile - der Nutzer soll sie
+ * bei Bedarf jemandem am Telefon vorlesen koennen, ohne sich zu verhaspeln.
+ * Enthaelt zusaetzlich zu den schon vorhandenen Werten die fuenf
+ * Einzelmessungen dieser Aufnahme (`counts`) - daran erkennen Nutzer und
+ * Entwickler sofort, ob das Ergebnis belastbar ist (fuenf Messungen von 17
+ * bis 19 bedeuten etwas anderes als fuenf Messungen von 4 bis 50). Die
+ * uebrigen Werte (`last`) beziehen sich weiterhin auf die *letzte* der
+ * fuenf Einzelmessungen - der gleitende Median ueber mehrere Durchlaeufe
+ * (frueher: count-history.js) entfaellt, die Aufnahme mit ihren fuenf
+ * Bildern leistet die noetige Beruhigung bereits selbst (siehe
+ * count-capture.js).
+ * @param {number[]} counts die (bis zu fuenf) Einzelmessungen dieser Aufnahme
+ * @param {ReturnType<typeof countObjects>} last Ergebnis der letzten der
+ *   fuenf Einzelmessungen
+ * @param {number} durationMs Zeitbedarf der letzten Einzelmessung
+ */
+function describeCountDiagnostics(counts, last, durationMs) {
+  return [
+    `Roh: ${last.count}`,
+    `Messungen: ${counts.join(', ')}`,
+    `Bild: ${last.width}×${last.height}`,
+    `Flächen: ${last.regionsFound} → ${last.regionsKept}`,
+    `Größte Fläche: ${last.largestArea} Bildpunkte`,
+    `Typische Größe: ${last.typicalArea} Bildpunkte`,
+    `Art: ${describePolarity(last.polarity)}`,
+    `Dauer: ${durationMs.toFixed(0)} ms`,
+  ].join('\n');
+}
+
+// Anzahl der Bilder je Zaehl-Aufnahme (siehe runCountCapture() unten): ein
+// einzelnes Videobild kann verwackelt sein oder mitten in eine
+// Fokusregelung fallen - fuenf einzeln gezaehlte Bilder, zusammengefasst
+// ueber ihren Median (count-capture.js), sind robuster als eines allein.
+const CAPTURE_SAMPLE_SIZE = 5;
+
+// Zeitspanne, ueber die die CAPTURE_SAMPLE_SIZE Bilder einer Aufnahme verteilt
+// aufgenommen werden - kurz genug, dass der Nutzer die Kamera dafuer ohne
+// Muehe ruhig haelt, lang genug, dass aufeinanderfolgende Bilder sich
+// tatsaechlich unterscheiden (statt praktisch identische Wiederholungen
+// desselben Videobilds zu zaehlen).
+const CAPTURE_DURATION_MS = 1000;
+
+/**
+ * Setzt die Beschriftung der Aufnahme-Schaltflaeche in Funktion "Zählen"
+ * anhand von hasCountResult (siehe Deklaration oben): "Zählen" vor der
+ * ersten Aufnahme seit Betreten der Funktion, "Nochmal zählen" danach.
+ */
+function updateCountCaptureLabel() {
+  view.setCaptureLabel(hasCountResult ? 'Nochmal zählen' : 'Zählen');
+}
+
+/**
+ * Eine Aufnahme der Funktion "Zählen" (ausgeloest durch die Schaltflaeche
+ * "Zählen"/"Nochmal zählen"): nimmt binnen rund CAPTURE_DURATION_MS
+ * insgesamt CAPTURE_SAMPLE_SIZE Bilder aus dem Zielrahmen des laufenden
+ * Videobilds auf (`grabFrameRegion`, derselbe Ausschnitt wie ueberall sonst
+ * - bewusst *nicht* die native Fotoaufnahme des Geraets, deren
+ * Bildausschnitt von der Vorschau abweichen kann), zaehlt jedes einzeln
+ * (`countObjects`, unveraendert) und zeigt als Ergebnis deren Median
+ * (`combineCaptureCounts`, count-capture.js) - robust gegen ein einzelnes
+ * verwackeltes oder unscharfes Bild. Waehrend der Aufnahme zeigt die
+ * Statuszeile "zähle …" (dasselbe Muster wie "erkenne …" in
+ * processCapture()), damit der Nutzer das Handy ruhig haelt und den
+ * Knopfdruck nicht fuer wirkungslos haelt.
+ *
+ * Anders als frueher (Dauerzaehlung) bleibt das Ergebnis danach stehen, bis
+ * der Nutzer erneut antippt - eine Zaehlung ist eine Schaetzung, die durch
+ * staendiges Neuanzeigen nicht praeziser wird, nur unruhig. Bucht nichts in
+ * die Sitzung, sperrt aber wie processCapture() ueber `busy` waehrend sie
+ * laeuft (Undo, Sitzungsliste, Funktionswechsel bleiben so lange
+ * unerreichbar - dieselbe kurze, unproblematische Sperre wie bei jedem
+ * anderen Scan-Durchlauf).
+ */
+async function runCountCapture() {
+  if (busy) return;
+  busy = true;
+  view.setStatus('zähle …');
+  let failed = false;
+
+  try {
+    const counts = [];
+    let last = null;
+
+    for (let i = 0; i < CAPTURE_SAMPLE_SIZE; i += 1) {
+      if (i > 0) {
+        await sleep(CAPTURE_DURATION_MS / (CAPTURE_SAMPLE_SIZE - 1));
+      }
+
+      let region;
+      try {
+        region = grabFrameRegion(view.video);
+      } catch {
+        // Kamerabild in diesem Augenblick nicht bereit - dieses Einzelbild
+        // faellt aus, die Aufnahme laeuft mit den uebrigen weiter (siehe
+        // combineCaptureCounts() fuer den Fall weniger als fuenf Bilder).
+        continue;
+      }
+
+      const start = performance.now();
+      const result = countObjects(region);
+      const durationMs = performance.now() - start;
+      counts.push(result.count);
+      last = { result, durationMs };
+    }
+
+    if (last === null) {
+      // Kein einziges Bild dieser Aufnahme war verwertbar - kein regulaeres
+      // Ergebnis, siehe combineCaptureCounts() (count-capture.js). Bleibt
+      // wie ein Fehlschlag stehen, statt sofort von restoreIdleStatus()
+      // ueberschrieben zu werden.
+      failed = true;
+      view.setStatus('Zählen nicht möglich — Kamerabild noch nicht bereit', true);
+      return;
+    }
+
+    const finalCount = combineCaptureCounts(counts);
+    view.setCount(Math.round(finalCount));
+    view.setCountDiagnostics(describeCountDiagnostics(counts, last.result, last.durationMs));
+    hasCountResult = true;
+    updateCountCaptureLabel();
+  } catch (error) {
+    failed = true;
+    view.setStatus(`Fehler: ${error.message}`, true);
+  } finally {
+    busy = false;
+    if (!failed) restoreIdleStatus();
+  }
+}
+
 /**
  * Laeuft, solange die Kamera aktiv ist. Ein neuer Versuch beginnt erst, wenn
- * der vorherige vollstaendig fertig ist - nie ueberlappend.
+ * der vorherige vollstaendig fertig ist - nie ueberlappend. Fuehrt pro
+ * Durchlauf die Barcode-Dauersuche aus; sie bricht selbst sofort ab, wenn
+ * die gewaehlte Funktion keine laufende Suche vorsieht (siehe
+ * runSearchAttempt()). Funktion "Zählen" laeuft seit dem Umbau auf
+ * Aufnahmen statt Dauerbetrieb (siehe runCountCapture()) und braucht hier
+ * deshalb keinen eigenen Aufruf mehr.
  */
 async function continuousSearchLoop() {
   for (;;) {

src/ocr.js

@@ -1,4 +1,5 @@
 import { createWorker } from 'tesseract.js';
+import { computeOtsuThreshold } from './threshold.js';
 
 // Der einmal erzeugte Erkennungs-Arbeiter wird als Versprechen zwischen-
 // gespeichert, damit sich auch mehrere schnell hintereinander gestartete
@@ -16,65 +17,15 @@ let workerPromise = null;
 // Oberflaeche verschwinden lassen - siehe Bericht, Abschnitt Selbstpruefung.
 let available = true;
 
-/**
- * Bestimmt den Otsu-Schwellwert aus einem Histogramm der 256 Helligkeits-
- * stufen. Otsu sucht den Schwellwert, der die Pixel in zwei Gruppen teilt
- * (dunkler / heller) und dabei die Streuung innerhalb jeder Gruppe minimiert
- * bzw. die Streuung zwischen den Gruppen maximiert - beides ist aequivalent
- * und wird hier ueber die Zwischen-Klassen-Varianz berechnet.
- * Da der Schwellwert aus der gesamten Verteilung stammt, verschiebt ein
- * einzelnes Ausreisserpixel (z. B. ein Lichtreflex) das Histogramm kaum und
- * damit auch den Schwellwert kaum - anders als eine Min/Max-Spreizung, die
- * von genau diesem einen Pixel dominiert wird.
- * @param {Uint32Array | number[]} histogram 256 Eintraege, einer je Helligkeitsstufe
- * @param {number} totalPixels Anzahl der Pixel, aus denen das Histogramm stammt
- * @returns {number} Schwellwert (0-255): Helligkeit darunter wird schwarz, ab hier weiss
- */
-function otsuThreshold(histogram, totalPixels) {
-  if (totalPixels === 0) return 128;
-
-  let sumAll = 0;
-  for (let level = 0; level < 256; level += 1) {
-    sumAll += level * histogram[level];
-  }
-
-  let sumBackground = 0;
-  let weightBackground = 0;
-  let bestVariance = -1;
-  let bestThreshold = 128;
-
-  for (let level = 0; level < 256; level += 1) {
-    weightBackground += histogram[level];
-    if (weightBackground === 0) continue;
-
-    const weightForeground = totalPixels - weightBackground;
-    if (weightForeground === 0) break;
-
-    sumBackground += level * histogram[level];
-
-    const meanBackground = sumBackground / weightBackground;
-    const meanForeground = (sumAll - sumBackground) / weightForeground;
-    const meanDiff = meanBackground - meanForeground;
-    const betweenClassVariance = weightBackground * weightForeground * meanDiff * meanDiff;
-
-    if (betweenClassVariance > bestVariance) {
-      bestVariance = betweenClassVariance;
-      bestThreshold = level + 1;
-    }
-  }
-
-  return bestThreshold;
-}
-
 /**
  * Graustufen, Otsu-Schwellwert.
  * Glaenzende Metalletiketten liefern flaue, kontrastarme Bilder mit
  * Lichtreflexen als Normalfall; ohne diese Aufbereitung liest Tesseract dort
  * kaum etwas Brauchbares. Der Schwellwert wird aus der Helligkeitsverteilung
- * des Bildes selbst bestimmt (Otsu), statt aus einer Kontrastspreizung
- * zwischen dunkelstem und hellstem Pixel - ein einzelner Reflex kann so
- * nicht mehr Schrift und Untergrund gemeinsam auf dieselbe Seite eines
- * festen Schwellwerts ziehen.
+ * des Bildes selbst bestimmt (Otsu, siehe threshold.js), statt aus einer
+ * Kontrastspreizung zwischen dunkelstem und hellstem Pixel - ein einzelner
+ * Reflex kann so nicht mehr Schrift und Untergrund gemeinsam auf dieselbe
+ * Seite eines festen Schwellwerts ziehen.
  * Rein rechnend - erzeugt kein Canvas, fasst kein DOM an und ist damit
  * ohne Browser testbar.
  * @param {{width: number, height: number, data: Uint8ClampedArray}} imageData
@@ -82,16 +33,7 @@ function otsuThreshold(histogram, totalPixels) {
  */
 export function preprocess(imageData) {
   const { width, height, data } = imageData;
-  const gray = new Uint8ClampedArray(width * height);
-  const histogram = new Uint32Array(256);
-
-  for (let i = 0, p = 0; i < data.length; i += 4, p += 1) {
-    const value = Math.round(0.299 * data[i] + 0.587 * data[i + 1] + 0.114 * data[i + 2]);
-    gray[p] = value;
-    histogram[value] += 1;
-  }
-
-  const threshold = otsuThreshold(histogram, gray.length);
+  const { gray, threshold } = computeOtsuThreshold(imageData);
   const out = new Uint8ClampedArray(data.length);
   for (let p = 0; p < gray.length; p += 1) {
     const value = gray[p] >= threshold ? 255 : 0;

src/scan-modes.js

@@ -1,4 +1,4 @@
-// Die drei Scan-Funktionen, die der Nutzer vor dem Scannen waehlt. Reines
+// Die vier Scan-Funktionen, die der Nutzer vor dem Scannen waehlt. Reines
 // Modul ohne Browser-Zugriff (kein window/document/navigator) - einzige
 // Quelle fuer Kennung, Beschriftung, Codearten und Verhalten je Funktion.
 // Sowohl die Auswahl-Oberflaeche als auch main.js lesen ausschliesslich von
@@ -11,6 +11,16 @@
 // RAM-Etiketten sind DataMatrix, nicht QR - eine auf QR beschraenkte Funktion
 // faende auf dieser Ware nichts. Die Kennung heisst weiterhin `qrcode`, siehe
 // Kommentar dort.
+//
+// Funktion 4 ("Zaehlen") ist reine Anzeige: Sie liest weder Codes noch Text
+// und bucht nichts in die Sitzung - deshalb `continuousSearch: false` und
+// `useOcr: false`. Anders als frueher laeuft sie nicht mehr fortwaehrend,
+// solange die Kamera aktiv ist, sondern - wie Funktion 3 ("Text erkennen") -
+// auf Knopfdruck: eine Zaehlung ist eine Schaetzung, die durch staendiges
+// Neuanzeigen nicht praeziser wird, nur unruhig. Ein eigenes Merkmal dafuer
+// braucht es nicht mehr - `continuousSearch: false` allein genuegt bereits,
+// um main.js (siehe applyMode()) und scan-recognition.js dieselbe
+// Knopfdruck-Behandlung wie bei Funktion 3 zukommen zu lassen.
 
 /**
  * @typedef {object} ScanMode
@@ -20,7 +30,10 @@
  *   Codearten (zxing-wasm-Formatnamen). Leer, wenn die Funktion keine
  *   Barcode-Dekodierung nutzt.
  * @property {boolean} continuousSearch Ob waehrend die Kamera laeuft
- *   fortwaehrend nach Codes gesucht wird (statt nur auf Knopfdruck).
+ *   fortwaehrend nach Codes gesucht wird (statt nur auf Knopfdruck). Bei
+ *   Funktion "Zaehlen" ebenso `false` wie bei "Text erkennen" - siehe
+ *   count-objects.js fuer das Zaehlverfahren selbst und main.js
+ *   (runCountCapture()) fuer den Knopfdruck-Ablauf.
  * @property {boolean} useOcr Ob die Texterkennung (Tesseract) genutzt wird.
  */
 
@@ -56,6 +69,16 @@ export const SCAN_MODES = [
     continuousSearch: false,
     useOcr: true,
   },
+  {
+    id: 'count',
+    label: 'Zählen',
+    // Keine Codes, keine Texterkennung - reine Bildauswertung (siehe
+    // count-objects.js), die nichts bucht. Auf Knopfdruck wie Funktion 3,
+    // siehe Moduldoku oben.
+    barcodeFormats: [],
+    continuousSearch: false,
+    useOcr: false,
+  },
 ];
 
 /**

src/scan-recognition.js

@@ -10,6 +10,18 @@
 // Funktion 3 (Text erkennen): echte Texterkennung; die Barcode-Dekodierung
 // liefert sofort eine leere Liste, ohne dass decodeBarcodes ueberhaupt
 // aufgerufen wird.
+// Funktion 4 (Zaehlen): weder Barcode-Dekodierung noch Texterkennung -
+// recognize() (pipeline.js) wird im normalen Ablauf fuer diese Funktion gar
+// nicht aufgerufen (siehe main.js: die Schaltflaeche "Zählen"/"Nochmal
+// zählen" ruft stattdessen runCountCapture(), das direkt countObjects()
+// verwendet); dieselbe leere Ruecklieferung wie in Funktion 3 dient hier nur
+// als Absicherung fuer den seltenen Fall, dass der Ersatzweg ohne Kamera
+// (Dateiauswahl) waehrend gewaehlter Funktion "Zaehlen" ausgeloest wird.
+//
+// Sowohl Funktion 3 als auch Funktion 4 haben `barcodeFormats: []` (siehe
+// scan-modes.js) - eine leere Codeartenliste ist deshalb das gemeinsame,
+// einzige Merkmal, an dem sich "keine Barcode-Dekodierung noetig" ablesen
+// laesst, statt je Funktion einzeln nachzufragen.
 
 import { getScanMode } from './scan-modes.js';
 
@@ -24,7 +36,7 @@ export function buildRecognitionAdapters(modeId, adapters) {
   const mode = getScanMode(modeId);
 
   return {
-    decodeBarcodes: mode.useOcr
+    decodeBarcodes: mode.barcodeFormats.length === 0
       ? async () => []
       : (imageData) => adapters.decodeBarcodes(imageData, mode.barcodeFormats),
     runOcr: mode.useOcr

src/styles.css

@@ -52,6 +52,63 @@ body {
   border-color: var(--green);
 }
 
+/* Grosse Zaehlanzeige der Funktion "Zählen" (siehe count-objects.js) - liegt
+   ueber dem Kamerabild, aber unterhalb des Zielrahmens optisch zentriert.
+   Der Container selbst blockiert keine Beruehrungen (pointer-events: none);
+   die grosse Zahl darunter (.count-number) ist die einzige antippbare
+   Flaeche darin - sie deckt den ganzen Container ab, ist also weit ueber
+   den geforderten 56 Bildpunkten Mindestgroesse. */
+.count-display {
+  position: absolute;
+  inset: 0;
+  pointer-events: none;
+}
+
+/* Die Zahl selbst: riesige Schriftgroesse mit Schlagschatten statt
+   Kontrastfarbe, damit sie auf jedem Untergrund (hell wie dunkel) aus
+   Armlaenge lesbar bleibt. Als eigene, absolut positionierte Flaeche (statt
+   als Flex-Kind neben der Diagnosezeile) bleibt sie beim Ein-/Ausblenden der
+   Diagnosezeile darunter exakt an derselben Stelle stehen - sie "verrutscht"
+   beim Antippen nicht, auch wenn der Nutzer dabei nur eine Hand frei hat. */
+.count-number {
+  position: absolute;
+  inset: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 100%;
+  border: none;
+  padding: 0;
+  background: none;
+  font-size: min(35vw, 220px);
+  font-weight: 800;
+  color: #fff;
+  text-shadow: 0 0 12px rgba(0, 0, 0, 0.9), 0 0 3px rgba(0, 0, 0, 0.9);
+  pointer-events: auto;
+}
+
+/* Diagnosezeile (siehe main.js fuer den Wortlaut) - anfangs verborgen,
+   erscheint per Antippen der grossen Zahl. Am unteren Rand des
+   Kamerabilds verankert statt im Fluss neben der Zahl, damit sie beim
+   Ein-/Ausblenden nicht die Zahl selbst verschiebt (siehe .count-number
+   oben). Klein und unaufdringlich, aber mit demselben Schlagschatten-Trick
+   auf jedem Untergrund lesbar; white-space: pre-line setzt die einzelnen,
+   mit "\n" getrennten Werte (main.js) als eigene, kurze Zeilen. */
+.count-diagnostics {
+  position: absolute;
+  left: 0;
+  right: 0;
+  bottom: 6%;
+  padding: 0 16px;
+  text-align: center;
+  font-size: 14px;
+  line-height: 1.6;
+  color: #fff;
+  text-shadow: 0 0 8px rgba(0, 0, 0, 0.9), 0 0 3px rgba(0, 0, 0, 0.9);
+  white-space: pre-line;
+  pointer-events: none;
+}
+
 .stacks {
   display: flex;
   gap: 8px;

src/threshold.js

@@ -0,0 +1,91 @@
+// Otsu-Schwellwertbestimmung: reines Modul ohne jeden Browser-Zugriff (kein
+// window/document/canvas). Vorher steckte das ausschließlich in `preprocess`
+// in ocr.js - das aber tesseract.js einbindet und damit nichts mit reiner
+// Bildauswertung zu tun hat. Sowohl `preprocess` (ocr.js, für die
+// Texterkennung) als auch `countObjects` (count-objects.js, für die
+// Zähl-Funktion) brauchen denselben ersten Schritt - Graustufen bilden und
+// die Helligkeitsverteilung in zwei Klassen teilen - und lesen ihn deshalb
+// beide von hier.
+
+/**
+ * Bestimmt den Otsu-Schwellwert aus einem Histogramm der 256 Helligkeits-
+ * stufen. Otsu sucht den Schwellwert, der die Pixel in zwei Gruppen teilt
+ * (dunkler / heller) und dabei die Streuung innerhalb jeder Gruppe minimiert
+ * bzw. die Streuung zwischen den Gruppen maximiert - beides ist aequivalent
+ * und wird hier ueber die Zwischen-Klassen-Varianz berechnet.
+ * Da der Schwellwert aus der gesamten Verteilung stammt, verschiebt ein
+ * einzelnes Ausreisserpixel (z. B. ein Lichtreflex) das Histogramm kaum und
+ * damit auch den Schwellwert kaum - anders als eine Min/Max-Spreizung, die
+ * von genau diesem einen Pixel dominiert wird.
+ * @param {Uint32Array | number[]} histogram 256 Eintraege, einer je Helligkeitsstufe
+ * @param {number} totalPixels Anzahl der Pixel, aus denen das Histogramm stammt
+ * @returns {number} Schwellwert (0-255): Helligkeit darunter wird schwarz, ab hier weiss
+ */
+export function otsuThreshold(histogram, totalPixels) {
+  if (totalPixels === 0) return 128;
+
+  let sumAll = 0;
+  for (let level = 0; level < 256; level += 1) {
+    sumAll += level * histogram[level];
+  }
+
+  let sumBackground = 0;
+  let weightBackground = 0;
+  let bestVariance = -1;
+  let bestThreshold = 128;
+
+  for (let level = 0; level < 256; level += 1) {
+    weightBackground += histogram[level];
+    if (weightBackground === 0) continue;
+
+    const weightForeground = totalPixels - weightBackground;
+    if (weightForeground === 0) break;
+
+    sumBackground += level * histogram[level];
+
+    const meanBackground = sumBackground / weightBackground;
+    const meanForeground = (sumAll - sumBackground) / weightForeground;
+    const meanDiff = meanBackground - meanForeground;
+    const betweenClassVariance = weightBackground * weightForeground * meanDiff * meanDiff;
+
+    if (betweenClassVariance > bestVariance) {
+      bestVariance = betweenClassVariance;
+      bestThreshold = level + 1;
+    }
+  }
+
+  return bestThreshold;
+}
+
+/**
+ * Graustufen (gewichtetes RGB, wie menschliche Helligkeitswahrnehmung) und
+ * das zugehörige 256-stufige Helligkeitshistogramm - der gemeinsame erste
+ * Schritt für `preprocess` (ocr.js) und `countObjects` (count-objects.js).
+ * @param {{width: number, height: number, data: Uint8ClampedArray}} imageData
+ * @returns {{gray: Uint8ClampedArray, histogram: Uint32Array}}
+ */
+export function grayscaleHistogram(imageData) {
+  const { data } = imageData;
+  const gray = new Uint8ClampedArray(data.length / 4);
+  const histogram = new Uint32Array(256);
+
+  for (let i = 0, p = 0; i < data.length; i += 4, p += 1) {
+    const value = Math.round(0.299 * data[i] + 0.587 * data[i + 1] + 0.114 * data[i + 2]);
+    gray[p] = value;
+    histogram[value] += 1;
+  }
+
+  return { gray, histogram };
+}
+
+/**
+ * Graustufen und Otsu-Schwellwert in einem Schritt - der gemeinsame
+ * Ausgangspunkt für `preprocess` und `countObjects`.
+ * @param {{width: number, height: number, data: Uint8ClampedArray}} imageData
+ * @returns {{gray: Uint8ClampedArray, threshold: number}}
+ */
+export function computeOtsuThreshold(imageData) {
+  const { gray, histogram } = grayscaleHistogram(imageData);
+  const threshold = otsuThreshold(histogram, gray.length);
+  return { gray, threshold };
+}

src/ui/mode-dialog.js

@@ -5,7 +5,11 @@ import { SCAN_MODES } from '../scan-modes.js';
  * scan-modes.js) - keine zweite Stelle mit eigenem Text je Funktion.
  */
 function describeMode(mode) {
-  if (mode.useOcr) return 'Auf Knopfdruck';
+  // "Text erkennen" und "Zählen" laufen beide auf Knopfdruck (siehe
+  // scan-modes.js) - `continuousSearch: false` ist bei beiden das
+  // gemeinsame Merkmal dafuer, eine Fallunterscheidung je Funktion braucht
+  // es hier nicht.
+  if (!mode.continuousSearch) return 'Auf Knopfdruck';
   return 'Läuft von selbst, sobald ein Code im Bild ist';
 }
 

src/ui/scan-view.js

@@ -10,9 +10,14 @@ export function renderScanView(root, { onCapture, onUndo, onOpenList, onPickFile
     <div class="camera">
       <video id="preview" playsinline muted></video>
       <div class="frame"></div>
+      <div class="count-display" id="count-display" hidden>
+        <button class="count-number" id="count-number" type="button" aria-live="polite"
+          aria-label="Messwerte zur Zaehlung ein- oder ausblenden"></button>
+        <div class="count-diagnostics" id="count-diagnostics" hidden aria-live="polite"></div>
+      </div>
     </div>
     <div class="status" id="status"></div>
-    <button class="action capture" id="capture" hidden>Modul scannen</button>
+    <button class="action capture" id="capture" hidden></button>
     <button class="action secondary" id="pick-file-button" hidden>Bild auswählen</button>
     <div class="stacks" id="stacks"></div>
     <div class="last">
@@ -30,6 +35,15 @@ export function renderScanView(root, { onCapture, onUndo, onOpenList, onPickFile
   const frameEl = root.querySelector('.frame');
   const captureEl = root.querySelector('#capture');
   const modeButtonEl = root.querySelector('#mode-button');
+  const countDisplayEl = root.querySelector('#count-display');
+  const countNumberEl = root.querySelector('#count-number');
+  const countDiagnosticsEl = root.querySelector('#count-diagnostics');
+
+  // Ob die Diagnosezeile unter der grossen Zahl gerade eingeblendet ist -
+  // rein lokaler Anzeigezustand dieser Ansicht, siehe setCountVisible()
+  // (Zuruecksetzen beim Verlassen der Funktion "Zählen") und den Klick-
+  // Handler auf die grosse Zahl unten (Umschalten).
+  let countDiagnosticsVisible = false;
 
   // FRAME_INSET (camera.js) ist die einzige Quelle der Rahmenmasse - sowohl
   // fuer diesen sichtbaren Rahmen als auch fuer den nativen Ausschnitt
@@ -50,6 +64,16 @@ export function renderScanView(root, { onCapture, onUndo, onOpenList, onPickFile
     if (fileEl.files[0]) onPickFile(fileEl.files[0]);
     fileEl.value = '';
   });
+  // Antippen der grossen Zahl blendet die Diagnosezeile ein, nochmaliges
+  // Antippen wieder aus (siehe Moduldoku zu setCount()/setCountDiagnostics()
+  // unten) - reiner Anzeigezustand dieser Ansicht, main.js muss davon
+  // nichts wissen. Die grosse Zahl selbst bleibt dabei an derselben Stelle
+  // stehen: die Diagnosezeile ist eigenstaendig positioniert (siehe
+  // styles.css), ihr Ein-/Ausblenden nimmt der Zahl nicht den Platz weg.
+  countNumberEl.addEventListener('click', () => {
+    countDiagnosticsVisible = !countDiagnosticsVisible;
+    countDiagnosticsEl.hidden = !countDiagnosticsVisible;
+  });
 
   return {
     video: root.querySelector('#preview'),
@@ -91,15 +115,30 @@ export function renderScanView(root, { onCapture, onUndo, onOpenList, onPickFile
     },
 
     /**
-     * "Modul scannen" hat nur in Funktionen mit Texterkennung auf Knopfdruck
-     * etwas zu tun (Funktion 3) - in Funktionen mit laufender Codesuche sucht
-     * die App ohnehin durchgehend, ein Knopf dafuer waere wirkungslos.
+     * Diese eine Schaltflaeche bedient beide Knopfdruck-Funktionen ("Modul
+     * scannen" in Funktion 3 "Text erkennen", "Zählen"/"Nochmal zählen" in
+     * Funktion 4 "Zählen") - nur ihr Wortlaut und ihr Rueckruf unterscheiden
+     * sich, siehe setCaptureLabel() unten und main.js/applyMode(). In
+     * Funktionen mit laufender Codesuche sucht die App ohnehin durchgehend,
+     * ein Knopf dafuer waere wirkungslos.
      * @param {boolean} visible
      */
     setCaptureVisible(visible) {
       captureEl.hidden = !visible;
     },
 
+    /**
+     * Setzt den Wortlaut der Aufnahme-Schaltflaeche - siehe setCaptureVisible()
+     * oben fuer den Grund, warum es dafuer nur eine gemeinsame Flaeche statt
+     * einer zweiten daneben gibt. main.js setzt hier "Modul scannen" (Funktion
+     * "Text erkennen"), "Zählen" (Funktion "Zählen", vor der ersten Aufnahme
+     * seit Betreten der Funktion) bzw. "Nochmal zählen" (danach).
+     * @param {string} text
+     */
+    setCaptureLabel(text) {
+      captureEl.textContent = text;
+    },
+
     /** @param {string} text @param {boolean} warn */
     setStatus(text, warn = false) {
       statusEl.textContent = text;
@@ -129,5 +168,55 @@ export function renderScanView(root, { onCapture, onUndo, onOpenList, onPickFile
     setFrameDetected(detected) {
       frameEl.classList.toggle('detected', detected);
     },
+
+    /**
+     * Blendet die grosse Zaehlanzeige ein oder aus (nur in Funktion
+     * "Zählen" sichtbar, siehe applyMode() in main.js). Beim Ausblenden wird
+     * die zuletzt angezeigte Zahl geloescht, damit beim naechsten Wechsel in
+     * diese Funktion nicht kurz eine veraltete Zahl aufblitzt - ebenso die
+     * Diagnosezeile: sie faellt dabei wieder in ihren Ausgangszustand
+     * (verborgen, leer) zurueck, damit sie nach einem Funktionswechsel nicht
+     * ungefragt (weil sie beim letzten Mal offen war) oder mit veralteten
+     * Werten wieder auftaucht. Das gilt sowohl beim Verlassen der Funktion
+     * "Zählen" als auch beim erneuten Betreten - ein stehendes Ergebnis
+     * einer frueheren Aufnahme (andere Teile, andere Stelle) darf nicht
+     * hinueberwirken (siehe main.js/applyMode()).
+     * @param {boolean} visible
+     */
+    setCountVisible(visible) {
+      countDisplayEl.hidden = !visible;
+      if (!visible) {
+        countNumberEl.textContent = '';
+        countDiagnosticsEl.textContent = '';
+        countDiagnosticsVisible = false;
+        countDiagnosticsEl.hidden = true;
+      }
+    },
+
+    /**
+     * Zeigt das Ergebnis der zuletzt angetippten Zaehl-Aufnahme (Median der
+     * fuenf Einzelmessungen dieser Aufnahme, siehe count-capture.js und
+     * runCountCapture() in main.js) - gross und aus Armlaenge lesbar. Bleibt
+     * unveraendert stehen, bis der Nutzer erneut auf die Schaltflaeche
+     * "Nochmal zählen" tippt (keine fortlaufende Aktualisierung mehr). Ein
+     * Antippen der Zahl selbst blendet die Diagnosezeile darunter ein oder
+     * aus (siehe Klick-Handler oben).
+     * @param {number} count
+     */
+    setCount(count) {
+      countNumberEl.textContent = String(count);
+    },
+
+    /**
+     * Setzt den Text der kleinen Diagnosezeile unter der grossen Zahl (siehe
+     * main.js fuer den genauen Wortlaut, u. a. die fuenf Einzelmessungen der
+     * zuletzt angetippten Aufnahme) - unabhaengig davon, ob sie gerade
+     * eingeblendet ist. Reine Textaktualisierung, die Sichtbarkeit steuert
+     * ausschliesslich der Klick auf die grosse Zahl (siehe oben).
+     * @param {string} text
+     */
+    setCountDiagnostics(text) {
+      countDiagnosticsEl.textContent = text;
+    },
   };
 }

test/count-capture.test.js

@@ -0,0 +1,44 @@
+// Reine Rechenlogik der Zaehl-Aufnahme (Funktion "Zählen", siehe main.js):
+// aus den (bis zu fuenf) Einzelmessungen einer Aufnahme wird deren Median
+// gebildet. Siehe count-capture.js fuer die Begruendung (robust gegen einen
+// einzelnen Ausreisser, ohne wie eine fortlaufende Glaettung traege zu sein).
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { combineCaptureCounts } from '../src/count-capture.js';
+
+test('fuenf gleiche Messungen liefern diese Zahl', () => {
+  assert.equal(combineCaptureCounts([18, 18, 18, 18, 18]), 18);
+});
+
+test('fuenf verschiedene Messungen liefern deren Median (ungerade Anzahl)', () => {
+  assert.equal(combineCaptureCounts([17, 19, 18, 20, 18]), 18);
+});
+
+test('ein einzelner grober Ausreisser unter fuenf Messungen schlaegt nicht durch', () => {
+  // Vier stabile Messungen um 18 herum, eine grob daneben (z. B.
+  // Bewegungsunschaerfe oder Autofokus mitten in der Aufnahme) - der Median
+  // bleibt bei 18, ein Mittelwert waere durch den Ausreisser spuerbar verzerrt.
+  assert.equal(combineCaptureCounts([18, 18, 3, 18, 60]), 18);
+});
+
+test('weniger als fuenf Messungen (eine Kameraaufnahme scheiterte) liefern trotzdem ein Ergebnis', () => {
+  // Gerade Anzahl (vier statt fuenf) - Median ist der Mittelwert der beiden
+  // mittleren Werte.
+  const result = combineCaptureCounts([17, 18, 18, 19]);
+  assert.equal(result, 18);
+});
+
+test('nur eine einzige verwertbare Messung ist ihr eigener Median', () => {
+  assert.equal(combineCaptureCounts([21]), 21);
+});
+
+test('eine leere Messreihe wirft, statt stillschweigend ein sinnloses Ergebnis (NaN) zu liefern', () => {
+  assert.throws(() => combineCaptureCounts([]));
+});
+
+test('combineCaptureCounts veraendert die uebergebene Liste nicht (reine Funktion)', () => {
+  const counts = [5, 1, 3];
+  const untouched = [...counts];
+  combineCaptureCounts(counts);
+  assert.deepEqual(counts, untouched);
+});

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`);
+});

test/count-objects.test.js

@@ -0,0 +1,240 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { countObjects } from '../src/count-objects.js';
+
+/**
+ * Baut ein ImageData-artiges Objekt aus einem Raster von Graustufenwerten
+ * (0-255 je Zelle) - derselbe minimale Ersatz wie in ocr-preprocess.test.js,
+ * hier zweidimensional, weil countObjects() auf zusammenhaengende Flaechen
+ * angewiesen ist.
+ * @param {number[][]} rows gleich lange Zeilen von Graustufenwerten
+ */
+function image(rows) {
+  const height = rows.length;
+  const width = height > 0 ? rows[0].length : 0;
+  const data = new Uint8ClampedArray(width * height * 4);
+  let i = 0;
+  for (const row of rows) {
+    for (const value of row) {
+      data[i] = value;
+      data[i + 1] = value;
+      data[i + 2] = value;
+      data[i + 3] = 255;
+      i += 4;
+    }
+  }
+  return { width, height, data };
+}
+
+/** Erzeugt ein width x height grosses Raster, komplett mit `background` gefuellt. */
+function grid(width, height, background) {
+  return Array.from({ length: height }, () => new Array(width).fill(background));
+}
+
+/** Malt ein width x height grosses Quadrat/Rechteck an Position (x, y) mit `value`. */
+function paint(rows, x, y, width, height, value) {
+  for (let row = y; row < y + height; row += 1) {
+    for (let col = x; col < x + width; col += 1) {
+      rows[row][col] = value;
+    }
+  }
+}
+
+// Das neue Verfahren (siehe count-objects.js) braucht oertlichen Kontrast:
+// jeder Bildpunkt wird gegen den Mittelwert seiner Umgebung verglichen
+// (Fensterradius max(Breite, Hoehe) / 12). Damit dieses Fenster an jeder
+// Objektstelle noch echten Untergrund sieht (statt nur das Objekt selbst
+// nochmal zu mitteln), muss der Untergrund eine deutlich groessere Flaeche
+// einnehmen als jedes einzelne Fundstueck - anders als beim alten,
+// Otsu-basierten Verfahren, wo ein 40x40- oder 80x80-Bild mit 10x10-
+// Quadraten genuegte. Die Testbilder hier sind deshalb groesser (300x300
+// bzw. 600x600) im Verhaeltnis zu den gemalten Flaechen.
+
+test('leeres Bild (kein Objekt, gleichmaessiger Untergrund) ergibt null', () => {
+  const rows = grid(300, 300, 60);
+  const result = countObjects(image(rows));
+  assert.equal(result.count, 0);
+});
+
+test('eine einzelne Flaeche ergibt eins', () => {
+  const rows = grid(300, 300, 30);
+  paint(rows, 140, 140, 20, 20, 220);
+  const result = countObjects(image(rows));
+  assert.equal(result.count, 1);
+});
+
+test('mehrere getrennte, gleich grosse Flaechen ergeben ihre Anzahl', () => {
+  const rows = grid(300, 300, 30);
+  paint(rows, 40, 40, 20, 20, 220);
+  paint(rows, 200, 40, 20, 20, 220);
+  paint(rows, 40, 200, 20, 20, 220);
+  paint(rows, 200, 200, 20, 20, 220);
+  const result = countObjects(image(rows));
+  assert.equal(result.count, 4);
+});
+
+test('winzige Stoerflaechen (Staub, Reflexe) werden nicht mitgezaehlt', () => {
+  const rows = grid(300, 300, 30);
+  paint(rows, 40, 40, 20, 20, 220);
+  paint(rows, 200, 40, 20, 20, 220);
+  paint(rows, 40, 200, 20, 20, 220);
+  paint(rows, 200, 200, 20, 20, 220);
+  // Einzelpixel- bis Doppelpixel-Stoerflaechen, weit entfernt von den
+  // echten Flaechen und voneinander - weit unter der Rauschschwelle
+  // (max(8, 0.00002 * Bildpunktzahl), hier 8 Bildpunkte).
+  rows[150][150] = 220;
+  rows[160][160] = 220;
+  rows[160][161] = 220;
+  const result = countObjects(image(rows));
+  assert.equal(result.count, 4, 'Stoerflaechen duerfen die Anzahl nicht erhoehen');
+});
+
+test('eine Flaeche von etwa vierfacher Einzelgroesse wird als vier gezaehlt', () => {
+  // Groessere Quadrate und ein groesseres Bild als beim Rauschtest: die
+  // Glaettung (Schritt 3) dehnt jede Flaeche an ihrem Rand etwas auf - bei
+  // sehr kleinen Quadraten faellt diese Randzugabe relativ zur Flaeche viel
+  // staerker ins Gewicht als bei groesseren und wuerde das exakte
+  // Vierfache verzerren.
+  const rows = grid(600, 600, 30);
+  paint(rows, 60, 60, 40, 40, 220); // typische Groesse
+  paint(rows, 400, 60, 40, 40, 220);
+  paint(rows, 60, 400, 40, 40, 220);
+  // Verschmolzene Flaeche mehrerer beruehrender Teile: 80x80 = 4x 40x40.
+  paint(rows, 400, 400, 80, 80, 220);
+  const result = countObjects(image(rows));
+  assert.equal(result.count, 7, '3 Einzelflaechen (je 1) + hochgerechnete Flaeche (4)');
+});
+
+test('ein einzelnes, nur leicht groesseres Teil wird nicht als zwei gezaehlt', () => {
+  const rows = grid(600, 600, 30);
+  paint(rows, 60, 60, 40, 40, 220);
+  paint(rows, 400, 60, 40, 40, 220);
+  paint(rows, 60, 400, 40, 40, 220);
+  // Rund 30% groesser als die anderen (44x48=2112 statt 1600) - haeufiger
+  // Fall, wenn ein Teil im Bild etwas naeher an der Kamera liegt.
+  paint(rows, 400, 400, 44, 48, 220);
+  const result = countObjects(image(rows));
+  assert.equal(result.count, 4, 'leicht groessere Einzelflaeche zaehlt weiterhin als eins');
+});
+
+test('dunkle Objekte auf hellem Grund werden genauso gezaehlt wie helle auf dunklem', () => {
+  const darkOnLight = grid(300, 300, 220);
+  paint(darkOnLight, 40, 40, 20, 20, 30);
+  paint(darkOnLight, 200, 40, 20, 20, 30);
+  paint(darkOnLight, 40, 200, 20, 20, 30);
+  paint(darkOnLight, 200, 200, 20, 20, 30);
+
+  const lightOnDark = grid(300, 300, 30);
+  paint(lightOnDark, 40, 40, 20, 20, 220);
+  paint(lightOnDark, 200, 40, 20, 20, 220);
+  paint(lightOnDark, 40, 200, 20, 20, 220);
+  paint(lightOnDark, 200, 200, 20, 20, 220);
+
+  const darkResult = countObjects(image(darkOnLight));
+  const lightResult = countObjects(image(lightOnDark));
+  assert.equal(darkResult.count, 4);
+  assert.equal(lightResult.count, 4);
+});
+
+test('ein Bild ohne Bildpunkte stuerzt nicht ab', () => {
+  assert.doesNotThrow(() => {
+    const result = countObjects({ width: 0, height: 0, data: new Uint8ClampedArray(0) });
+    assert.equal(result.count, 0);
+  });
+});
+
+test('zwei nahe, aber nur diagonal benachbarte Flaechen zaehlen getrennt (4er-Nachbarschaft)', () => {
+  const rows = grid(300, 300, 30);
+  // Zwei 15x15-Quadrate an ihrer naechsten Ecke durch eine 3 Bildpunkte
+  // breite Luecke getrennt - nah genug, um wie ein einziges, diagonal
+  // ausgerichtetes Fundstueckpaar auszusehen, aber tatsaechlich getrennt.
+  // Die Luecke ist bewusst breiter als beim alten, Otsu-basierten Test
+  // (dort genuegte ein einzelnes gemeinsames Eckpixel): Die Glaettung
+  // (Schritt 3) dehnt jede Flaeche an ihrem Rand um ein bis zwei Bildpunkte
+  // auf, ein einzelnes gemeinsames Eckpixel wuerde die beiden Flaechen nach
+  // der Glaettung faelschlich zu einer verschmelzen lassen.
+  paint(rows, 130, 130, 15, 15, 220);
+  paint(rows, 148, 148, 15, 15, 220);
+  const result = countObjects(image(rows));
+  assert.equal(result.count, 2, 'nur diagonal benachbarte Flaechen bleiben getrennt');
+});
+
+// --- Diagnosewerte (siehe Modul-Doku von countObjects()) ----------------
+//
+// Die Diagnoseanzeige (ui/scan-view.js, verdrahtet in main.js) liest diese
+// Zwischenwerte vom Bildschirm ab, wenn beim Nutzer die Zaehlung schwankt -
+// sie muessen deshalb auch dann sinnvoll belegt sein, wenn nichts gefunden
+// wurde (count === 0), sonst zeigt die Anzeige in genau dem Fall nichts, in
+// dem sie am dringendsten gebraucht wird.
+
+test('ein Bild ohne Bildpunkte belegt alle Diagnosewerte mit 0/null', () => {
+  const result = countObjects({ width: 0, height: 0, data: new Uint8ClampedArray(0) });
+  assert.equal(result.count, 0);
+  assert.equal(result.width, 0);
+  assert.equal(result.height, 0);
+  assert.equal(result.regionsFound, 0);
+  assert.equal(result.regionsKept, 0);
+  assert.equal(result.largestArea, 0);
+  assert.equal(result.typicalArea, 0);
+  assert.equal(result.polarity, null);
+});
+
+test('leeres Bild (kein Objekt) belegt die Diagnosewerte trotzdem sinnvoll', () => {
+  const rows = grid(300, 300, 60);
+  const result = countObjects(image(rows));
+  assert.equal(result.count, 0);
+  // Kleiner als TARGET_WIDTH (800) - bleibt bei der Normierung unveraendert.
+  assert.equal(result.width, 300);
+  assert.equal(result.height, 300);
+  assert.equal(result.regionsFound, 0);
+  assert.equal(result.regionsKept, 0);
+  assert.equal(result.largestArea, 0);
+  assert.equal(result.typicalArea, 0);
+  // Keine Flaeche gefunden - trotzdem muss eine der beiden Polaritaeten als
+  // Diagnosewert benannt sein, nicht null (das bleibt dem Fall "gar kein
+  // Bildpunkt" vorbehalten, siehe Test oben).
+  assert.ok(result.polarity === 'hell' || result.polarity === 'dunkel');
+});
+
+test('eine einzelne Flaeche liefert plausible Diagnosewerte und die richtige Polaritaet', () => {
+  const rows = grid(300, 300, 30);
+  paint(rows, 140, 140, 20, 20, 220); // heller als der Untergrund
+  const result = countObjects(image(rows));
+  assert.equal(result.count, 1);
+  assert.equal(result.width, 300);
+  assert.equal(result.height, 300);
+  assert.equal(result.polarity, 'hell', 'helle Flaeche auf dunklerem Grund');
+  assert.equal(result.regionsFound, 1);
+  assert.equal(result.regionsKept, 1);
+  assert.ok(result.largestArea > 0);
+  // Bei genau einer signifikanten Flaeche ist der Median (die typische
+  // Groesse) exakt diese eine Flaeche.
+  assert.equal(result.typicalArea, result.largestArea);
+});
+
+test('dunkle Flaeche auf hellem Grund meldet die Polaritaet "dunkel"', () => {
+  const rows = grid(300, 300, 220);
+  paint(rows, 140, 140, 20, 20, 30);
+  const result = countObjects(image(rows));
+  assert.equal(result.count, 1);
+  assert.equal(result.polarity, 'dunkel');
+});
+
+test('regionsKept zaehlt Flaechen, nicht die hochgerechneten Fundstuecke', () => {
+  // Wie der Test "eine Flaeche von etwa vierfacher Einzelgroesse wird als
+  // vier gezaehlt" oben: drei Einzelflaechen + eine verschmolzene Flaeche
+  // vierfacher Groesse. count rechnet die verschmolzene Flaeche auf vier
+  // Fundstuecke hoch (macht 7 insgesamt) - regionsKept zaehlt aber die
+  // tatsaechlich gefundenen, zusammenhaengenden Flaechen (4), nicht die
+  // hochgerechneten Fundstuecke.
+  const rows = grid(600, 600, 30);
+  paint(rows, 60, 60, 40, 40, 220);
+  paint(rows, 400, 60, 40, 40, 220);
+  paint(rows, 60, 400, 40, 40, 220);
+  paint(rows, 400, 400, 80, 80, 220);
+  const result = countObjects(image(rows));
+  assert.equal(result.count, 7);
+  assert.equal(result.regionsFound, 4);
+  assert.equal(result.regionsKept, 4);
+  assert.ok(result.largestArea > result.typicalArea, 'die verschmolzene Flaeche ist die groesste');
+});

test/scan-modes.test.js

@@ -2,9 +2,9 @@ import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { SCAN_MODES, getScanMode } from '../src/scan-modes.js';
 
-test('genau drei Funktionen in fester Reihenfolge', () => {
-  assert.equal(SCAN_MODES.length, 3);
-  assert.deepEqual(SCAN_MODES.map((mode) => mode.id), ['barcode', 'qrcode', 'ocr']);
+test('genau vier Funktionen in fester Reihenfolge', () => {
+  assert.equal(SCAN_MODES.length, 4);
+  assert.deepEqual(SCAN_MODES.map((mode) => mode.id), ['barcode', 'qrcode', 'ocr', 'count']);
 });
 
 test('Funktion 1 (Strichcode): eindimensionale Codearten, laufende Suche, keine Texterkennung', () => {
@@ -28,7 +28,7 @@ test('Funktion 2 (QR-Code): QR-Varianten und DataMatrix, Aztec, PDF417', () => {
   assert.equal(mode.useOcr, false);
 });
 
-test('die drei Funktionen haben paarweise verschiedene Kennungen und Beschriftungen', () => {
+test('die vier Funktionen haben paarweise verschiedene Kennungen und Beschriftungen', () => {
   const ids = SCAN_MODES.map((mode) => mode.id);
   const labels = SCAN_MODES.map((mode) => mode.label);
   assert.equal(new Set(ids).size, ids.length, 'Kennungen muessen paarweise verschieden sein');
@@ -43,6 +43,14 @@ test('Funktion 3 (Text erkennen): keine Codearten, keine laufende Suche, Texterk
   assert.equal(mode.useOcr, true);
 });
 
+test('Funktion 4 (Zählen): keine Codearten, keine laufende Codesuche, keine Texterkennung - auf Knopfdruck wie Funktion 3', () => {
+  const mode = getScanMode('count');
+  assert.equal(mode.label, 'Zählen');
+  assert.deepEqual(mode.barcodeFormats, []);
+  assert.equal(mode.continuousSearch, false);
+  assert.equal(mode.useOcr, false);
+});
+
 test('unbekannte Kennung wirft statt undefined zurueckzugeben', () => {
   assert.throws(() => getScanMode('unbekannt'));
 });

test/scan-recognition.test.js

@@ -67,6 +67,19 @@ test('decodeBarcodes bekommt die Codearten der jeweiligen Funktion uebergeben',
   assert.deepEqual(receivedFormats, ['QRCode', 'MicroQRCode', 'RMQRCode', 'DataMatrix', 'Aztec', 'PDF417']);
 });
 
+test('Funktion 4 (Zaehlen): weder Barcode-Dekodierung noch Texterkennung werden aufgerufen', async () => {
+  let barcodeCalled = false;
+  let ocrCalled = false;
+  const adapters = buildRecognitionAdapters('count', {
+    decodeBarcodes: async () => { barcodeCalled = true; return []; },
+    runOcr: async () => { ocrCalled = true; return 'irgendein Text'; },
+  });
+  const result = await recognize({}, adapters);
+  assert.equal(barcodeCalled, false, 'decodeBarcodes darf in Funktion 4 nie aufgerufen werden');
+  assert.equal(ocrCalled, false, 'runOcr darf in Funktion 4 nie aufgerufen werden');
+  assert.equal(result.confidence, 'red');
+});
+
 test('Funktion 3 uebergibt keine Codearten, weil decodeBarcodes gar nicht aufgerufen wird', async () => {
   let called = false;
   const adapters = buildRecognitionAdapters('ocr', {