Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 sysopsandClaude Sonnet 5
|
1a246abdb3 | ||
|
sysopsandClaude Sonnet 5
|
bd37de529f |
@@ -0,0 +1,69 @@
|
||||
# SRC-07 – Prüfprotokoll: OCR für Anhänge
|
||||
|
||||
Voraussetzung ARC-01, ARC-03 (beide Fertig). SRC-07 ist die direkte
|
||||
Vorbedingung für SRC-10 (Spracherkennung & OCR-Qualitätsbewertung), nicht
|
||||
nur eine nette Ergänzung — ohne SRC-07 gibt es keinen erkannten Text, den
|
||||
SRC-10 mit Sprache/Konfidenz bewerten könnte.
|
||||
|
||||
## Umsetzung
|
||||
|
||||
- `mail/internal/ocr/ocr.go` — zustandsloses Paket, kennt weder Mandant
|
||||
noch Speicher (dieselbe Bauart wie `mail/internal/crypto`/`dedup`):
|
||||
nimmt Anhangs-Bytes entgegen, liefert erkannten Text zurück. Kein
|
||||
geteilter Zustand zwischen Aufrufen (jeder Aufruf bekommt ein eigenes
|
||||
Temp-Verzeichnis) — Tenant-Trennung ist dadurch strukturell gegeben,
|
||||
nicht nur konventionell: ein Mandant kann prinzipbedingt nie Zwischen-
|
||||
daten eines anderen sehen. Zuordnung des erkannten Textes zum
|
||||
Mail-Suchdokument (Akzeptanzkriterium 2) erfolgt beim Aufrufer über das
|
||||
bereits vorhandene `search.Document.AttachmentText`-Feld (SRC-01) — kein
|
||||
neues Feld nötig.
|
||||
- `ExtractTextFromImage`: ruft `tesseract` (Sprachen `deu+eng`) mit
|
||||
fester Argumentliste auf, kein Shell-String-Zusammenbau.
|
||||
- `HasTextLayer`/`ExtractTextFromPDF`: nutzt `pdftotext`, um eine
|
||||
vorhandene Textebene zu erkennen und direkt zu übernehmen
|
||||
(Akzeptanzkriterium 3) — nur wenn keine Textebene vorhanden ist
|
||||
(< 10 Zeichen), wird über `pdftoppm` (300dpi) jede Seite gerastert und
|
||||
per Tesseract erkannt (Akzeptanzkriterium 1).
|
||||
- Bekannten Fehler vermieden (dupliziertes Sprintf-WHERE-Muster aus
|
||||
archivmail, siehe repos-analyse-mail-reuse.md): dieses Paket baut keine
|
||||
SQL-Klauseln — ausschließlich externe Kommandozeilenwerkzeuge mit
|
||||
festen Argumentlisten (`exec.CommandContext`, keine Shell).
|
||||
- Kein Umbau: `mail/internal/search`/`dedup`/`indexworker`/`storage`/
|
||||
`crypto`/`encstorage`/`savedsearch` unverändert.
|
||||
|
||||
## Prüfungen
|
||||
|
||||
| # | Prüfung | Ergebnis |
|
||||
|---|---|---|
|
||||
| 1 | Test: Bildanhang mit bekanntem Text liefert erwartete Texterkennung | **bestanden** – `TestExtractTextFromImage_KnownTextRecognized`: reales, über `pdftoppm` gerastertes Bild mit dem Text "Rechnungsnummer 4711", `ExtractTextFromImage` erkennt real beide Wortbestandteile |
|
||||
| 2 | Test: PDF mit vorhandener Textebene wird korrekt übersprungen | **bestanden** – `TestExtractTextFromPDF_SkipsOCRWhenTextLayerPresent`: real erzeugtes Vektor-Text-PDF (echte PDF-Textebene, kein Bild), `ExtractTextFromPDF` liefert `OCRPerformed=false` und den Text direkt aus der Textebene |
|
||||
| 3 | Durchsatztest bestätigt akzeptable Verarbeitungszeit je Anhang | **bestanden** – `TestExtractTextFromPDF_ThroughputIsAcceptable`: 3 reale Anhänge (Rasterung 300dpi + OCR) in durchschnittlich 3,48s/Anhang (Ziel 8s/Anhang) |
|
||||
|
||||
Zusätzlich (Akzeptanzkriterium 1, gescannte PDFs end-zu-Ende):
|
||||
`TestExtractTextFromPDF_PerformsOCRWhenNoTextLayer` — ein reales,
|
||||
ausschließlich rasterbildbasiertes PDF (kein Textelement, JPEG-Bild via
|
||||
`/DCTDecode` eingebettet) wird real per OCR erkannt, `OCRPerformed=true`.
|
||||
|
||||
Testfixtures (`testpdf_test.go`) werden vollständig in Go erzeugt (Hand-
|
||||
gebautes PDF mit Helvetica-Textebene bzw. eingebettetem JPEG) — keine
|
||||
externe Bibliothek, keine Testdateien im Repository, reproduzierbar.
|
||||
|
||||
## Build/Test-Ergebnis (192.168.1.131)
|
||||
|
||||
```
|
||||
go build ./... -> clean
|
||||
go vet ./... -> clean
|
||||
golangci-lint run ./... -> 0 issues
|
||||
go test ./internal/ocr/... -v -> 4/4 bestanden (14,99s gesamt)
|
||||
TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
|
||||
-> alle Pakete bestanden, keine Regression
|
||||
```
|
||||
|
||||
Werkzeugversionen auf 192.168.1.131: `tesseract 5.5.0` (Sprachpakete
|
||||
`deu`, `eng`), `pdftotext`/`pdftoppm` (poppler-utils) — bereits vorhanden,
|
||||
keine Installation durch diese Sitzung nötig.
|
||||
|
||||
## Gesamtergebnis
|
||||
|
||||
**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
|
||||
real erfüllt. Entsperrt SRC-10.
|
||||
@@ -0,0 +1,57 @@
|
||||
# SRC-10 – Prüfprotokoll: Spracherkennung & OCR-Qualitätsbewertung
|
||||
|
||||
Voraussetzung SRC-07 (Fertig).
|
||||
|
||||
## Umsetzung
|
||||
|
||||
- `mail/internal/ocr/language.go` — `RecognizeWithLanguageAndConfidence`:
|
||||
Tesseract erkennt bei kombinierten Sprachpaketen (`deu+eng`) nicht,
|
||||
WELCHE Sprache vorlag — daher wird das Bild bewusst EINZELN mit jedem
|
||||
Kandidaten (`deu`, `eng`) im TSV-Ausgabemodus erkannt; die Sprache mit
|
||||
dem höheren durchschnittlichen Worterkennungs-Konfidenzwert gewinnt
|
||||
(Akzeptanzkriterium 1). Derselbe Tesseract-TSV-Lauf liefert den
|
||||
Konfidenzwert direkt mit (Akzeptanzkriterium 2, 0–100, Mittelwert über
|
||||
alle erkannten Wörter) — keine zweite externe Bibliothek nötig.
|
||||
- `mail/internal/search`: neue Felder `ocr_language`/`ocr_confidence`
|
||||
(Migrationen 0006/0007, gleiches ALTER-Muster wie SRC-05), in
|
||||
`Document`/`Result` gespiegelt (Akzeptanzkriterium 1: für Anzeige
|
||||
nutzbar). Neue Methode `Client.AttachmentsBelowConfidence(ctx,
|
||||
tenantSlug, threshold)` (Akzeptanzkriterium 3: gezielt für manuelle
|
||||
Nachbearbeitung auffindbar) — filtert `ocr_confidence < threshold`,
|
||||
schließt Dokumente ohne OCR-Anhang (`ocr_confidence` bleibt 0) explizit
|
||||
aus.
|
||||
- Echten Regressionsbug beim eigenen Testlauf gefunden und behoben:
|
||||
`reindex.go`s `buildCreateTableSQL` (SRC-09) kannte die neuen
|
||||
OCR-Spalten nicht — ein Reindex nach dieser Kachel wäre mit "unknown
|
||||
column" fehlgeschlagen. Jetzt ergänzt, mit Wartungshinweis im
|
||||
Quelltext für künftige Schema-Erweiterungen.
|
||||
- Kein Umbau: `Search`/`Facets`/`SearchWithFilters`/`Index`/`Delete`-
|
||||
Verhalten sonst unverändert, `mail/internal/dedup`/`indexworker`/
|
||||
`storage`/`crypto`/`encstorage`/`savedsearch` unverändert.
|
||||
|
||||
## Prüfungen
|
||||
|
||||
| # | Prüfung | Ergebnis |
|
||||
|---|---|---|
|
||||
| 1 | Test mit mehrsprachigem Testkorpus bestätigt korrekte Spracherkennung | **bestanden** – `TestRecognizeWithLanguageAndConfidence_MultilingualCorpus`: reales deutsches Testbild ("Rechnung ueber Lieferung...") real als `deu` erkannt, reales englisches Testbild ("Invoice for delivery...") real als `eng` erkannt |
|
||||
| 2 | Test: künstlich verschlechtertes Bild erzeugt niedrigeren Konfidenzwert | **bestanden** – `TestRecognizeWithLanguageAndConfidence_DegradedImageLowersConfidence`: reproduzierbare Pixelierung + Kontrastreduktion (reiner Go-Standardbibliothekscode, kein externes Werkzeug) senkt den real gemessenen Konfidenzwert von 91,76 auf 28,21 |
|
||||
| 3 | Abfrage aller Anhänge unterhalb einer Konfidenzschwelle liefert erwartete Treffer | **bestanden** – `TestAttachmentsBelowConfidence_QueryReturnsExpectedResults`: 4 Dokumente (2 niedrig-, 1 hoch-konfident, 1 ohne OCR-Anhang), Abfrage mit Schwelle 50 liefert real genau die 2 niedrig-konfidenten, weder den hoch-konfidenten noch den ohne OCR-Anhang |
|
||||
|
||||
## Build/Test-Ergebnis (192.168.1.131)
|
||||
|
||||
```
|
||||
go build ./... -> clean
|
||||
go vet ./... -> clean
|
||||
golangci-lint run ./... -> 0 issues
|
||||
go test ./internal/ocr/... -v -run 'Language|Degraded' -> 2/2 bestanden
|
||||
TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
|
||||
-> alle Pakete bestanden (Regressionsbug in reindex.go vor diesem
|
||||
Protokoll gefunden und behoben, danach vollständig grün)
|
||||
```
|
||||
|
||||
## Gesamtergebnis
|
||||
|
||||
**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
|
||||
real erfüllt. Entsperrt QA-03 (gemeinsam mit ARC-08, SRC-02, SRC-04,
|
||||
SRC-05, SRC-08, SRC-09 — alle jetzt Fertig, letzte fehlende
|
||||
Abhängigkeit).
|
||||
@@ -0,0 +1,124 @@
|
||||
// SRC-10: Spracherkennung & OCR-Qualitätsbewertung. Tesseract erkennt bei
|
||||
// kombinierten Sprachpaketen (Languages = "deu+eng") nicht, WELCHE Sprache
|
||||
// tatsächlich vorlag — daher wird das Bild hier bewusst EINZELN mit jedem
|
||||
// Kandidaten aus candidateLanguages erkannt, und die Sprache mit dem
|
||||
// höheren durchschnittlichen Worterkennungs-Konfidenzwert gewinnt
|
||||
// (Akzeptanzkriterium 1). Derselbe Tesseract-TSV-Lauf liefert den
|
||||
// Konfidenzwert direkt mit (Akzeptanzkriterium 2) — keine zweite externe
|
||||
// Bibliothek für Sprach- ODER Konfidenzerkennung nötig.
|
||||
package ocr
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"fmt"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// candidateLanguages sind die unterstützten Einzelsprachen — muss eine
|
||||
// Teilmenge der in Languages kombinierten Sprachpakete sein.
|
||||
var candidateLanguages = []string{"deu", "eng"}
|
||||
|
||||
// RecognizedText ist das Ergebnis einer sprach- und konfidenzbewussten
|
||||
// Texterkennung.
|
||||
type RecognizedText struct {
|
||||
Text string
|
||||
// Language ist der ISO-639-2-Sprachcode aus candidateLanguages mit dem
|
||||
// höchsten Konfidenzwert (Akzeptanzkriterium 1).
|
||||
Language string
|
||||
// Confidence ist der durchschnittliche Tesseract-Worterkennungs-
|
||||
// Konfidenzwert (0–100) der gewählten Sprache (Akzeptanzkriterium 2).
|
||||
Confidence float64
|
||||
}
|
||||
|
||||
// RecognizeWithLanguageAndConfidence erkennt Sprache und Text eines Bildes
|
||||
// und liefert einen auswertbaren Konfidenzwert.
|
||||
func RecognizeWithLanguageAndConfidence(ctx context.Context, imageBytes []byte) (RecognizedText, error) {
|
||||
var best RecognizedText
|
||||
haveResult := false
|
||||
|
||||
for _, lang := range candidateLanguages {
|
||||
text, confidence, err := recognizeWithTSV(ctx, imageBytes, lang)
|
||||
if err != nil {
|
||||
return RecognizedText{}, err
|
||||
}
|
||||
if !haveResult || confidence > best.Confidence {
|
||||
best = RecognizedText{Text: text, Language: lang, Confidence: confidence}
|
||||
haveResult = true
|
||||
}
|
||||
}
|
||||
return best, nil
|
||||
}
|
||||
|
||||
// recognizeWithTSV führt Tesseract mit GENAU einer Sprache im TSV-Ausgabe-
|
||||
// modus aus und liefert den zusammengesetzten Text sowie den
|
||||
// durchschnittlichen Konfidenzwert über alle erkannten Wörter (Tesseract-
|
||||
// TSV-Zeilen mit level=5, conf>=0 — negative Konfidenzwerte markieren
|
||||
// Struktur-/Layoutzeilen ohne eigenen Text, siehe Tesseract-TSV-Format).
|
||||
func recognizeWithTSV(ctx context.Context, imageBytes []byte, lang string) (text string, confidence float64, err error) {
|
||||
workDir, err := os.MkdirTemp("", "mail-ocr-lang-*")
|
||||
if err != nil {
|
||||
return "", 0, fmt.Errorf("ocr: arbeitsverzeichnis anlegen: %w", err)
|
||||
}
|
||||
defer func() { _ = os.RemoveAll(workDir) }()
|
||||
|
||||
imagePath := filepath.Join(workDir, "input")
|
||||
if err := os.WriteFile(imagePath, imageBytes, 0o600); err != nil {
|
||||
return "", 0, fmt.Errorf("ocr: bild schreiben: %w", err)
|
||||
}
|
||||
outBase := filepath.Join(workDir, "output")
|
||||
|
||||
cmd := exec.CommandContext(ctx, "tesseract", imagePath, outBase, "-l", lang, "tsv")
|
||||
var stderr bytes.Buffer
|
||||
cmd.Stderr = &stderr
|
||||
if err := cmd.Run(); err != nil {
|
||||
return "", 0, fmt.Errorf("ocr: tesseract (tsv, %s) fehlgeschlagen: %w (%s)", lang, err, stderr.String())
|
||||
}
|
||||
|
||||
tsvBytes, err := os.ReadFile(outBase + ".tsv")
|
||||
if err != nil {
|
||||
return "", 0, fmt.Errorf("ocr: tsv-ausgabe lesen: %w", err)
|
||||
}
|
||||
return parseTSV(string(tsvBytes))
|
||||
}
|
||||
|
||||
// tsvWordLevel ist der Tesseract-TSV-"level"-Wert für einzelne Wörter
|
||||
// (1=Seite, 2=Block, 3=Absatz, 4=Zeile, 5=Wort).
|
||||
const tsvWordLevel = "5"
|
||||
|
||||
func parseTSV(tsv string) (text string, confidence float64, err error) {
|
||||
lines := strings.Split(tsv, "\n")
|
||||
var words []string
|
||||
var confSum float64
|
||||
var confCount int
|
||||
|
||||
for i, line := range lines {
|
||||
if i == 0 || strings.TrimSpace(line) == "" {
|
||||
continue // Kopfzeile bzw. Leerzeile überspringen
|
||||
}
|
||||
cols := strings.Split(line, "\t")
|
||||
if len(cols) < 12 || cols[0] != tsvWordLevel {
|
||||
continue
|
||||
}
|
||||
conf, convErr := strconv.ParseFloat(cols[10], 64)
|
||||
if convErr != nil || conf < 0 {
|
||||
continue
|
||||
}
|
||||
word := cols[11]
|
||||
if word == "" {
|
||||
continue
|
||||
}
|
||||
words = append(words, word)
|
||||
confSum += conf
|
||||
confCount++
|
||||
}
|
||||
|
||||
if confCount == 0 {
|
||||
return "", 0, nil
|
||||
}
|
||||
return strings.Join(words, " "), confSum / float64(confCount), nil
|
||||
}
|
||||
@@ -0,0 +1,101 @@
|
||||
package ocr
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"image"
|
||||
"image/color"
|
||||
"image/png"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// TestRecognizeWithLanguageAndConfidence_MultilingualCorpus ist die
|
||||
// geforderte Pflichtprüfung 1: Test mit mehrsprachigem Testkorpus
|
||||
// bestätigt korrekte Spracherkennung.
|
||||
func TestRecognizeWithLanguageAndConfidence_MultilingualCorpus(t *testing.T) {
|
||||
requireTools(t)
|
||||
ctx := context.Background()
|
||||
|
||||
germanImage := knownTextImage(t, ctx, "Rechnung ueber Lieferung Nummer Zwei")
|
||||
englishImage := knownTextImage(t, ctx, "Invoice for delivery number two")
|
||||
|
||||
germanResult, err := RecognizeWithLanguageAndConfidence(ctx, germanImage)
|
||||
if err != nil {
|
||||
t.Fatalf("deutsches bild: %v", err)
|
||||
}
|
||||
if germanResult.Language != "deu" {
|
||||
t.Fatalf("erwartete sprache 'deu' für deutschen text, habe %q (text: %q)", germanResult.Language, germanResult.Text)
|
||||
}
|
||||
|
||||
englishResult, err := RecognizeWithLanguageAndConfidence(ctx, englishImage)
|
||||
if err != nil {
|
||||
t.Fatalf("englisches bild: %v", err)
|
||||
}
|
||||
if englishResult.Language != "eng" {
|
||||
t.Fatalf("erwartete sprache 'eng' für englischen text, habe %q (text: %q)", englishResult.Language, englishResult.Text)
|
||||
}
|
||||
}
|
||||
|
||||
// TestRecognizeWithLanguageAndConfidence_DegradedImageLowersConfidence ist
|
||||
// die geforderte Pflichtprüfung 2: künstlich verschlechtertes Bild erzeugt
|
||||
// niedrigeren Konfidenzwert.
|
||||
func TestRecognizeWithLanguageAndConfidence_DegradedImageLowersConfidence(t *testing.T) {
|
||||
requireTools(t)
|
||||
ctx := context.Background()
|
||||
|
||||
original := knownTextImage(t, ctx, "Qualitaetsvergleich Testbild Konfidenz")
|
||||
originalImg, err := png.Decode(bytes.NewReader(original))
|
||||
if err != nil {
|
||||
t.Fatalf("original dekodieren: %v", err)
|
||||
}
|
||||
degradedImg := pixelate(originalImg, 12)
|
||||
var degradedBuf bytes.Buffer
|
||||
if err := png.Encode(°radedBuf, degradedImg); err != nil {
|
||||
t.Fatalf("verschlechtertes bild kodieren: %v", err)
|
||||
}
|
||||
|
||||
originalResult, err := RecognizeWithLanguageAndConfidence(ctx, original)
|
||||
if err != nil {
|
||||
t.Fatalf("original erkennen: %v", err)
|
||||
}
|
||||
degradedResult, err := RecognizeWithLanguageAndConfidence(ctx, degradedBuf.Bytes())
|
||||
if err != nil {
|
||||
t.Fatalf("verschlechtertes bild erkennen: %v", err)
|
||||
}
|
||||
|
||||
t.Logf("original: conf=%.2f text=%q — verschlechtert: conf=%.2f text=%q",
|
||||
originalResult.Confidence, originalResult.Text, degradedResult.Confidence, degradedResult.Text)
|
||||
if degradedResult.Confidence >= originalResult.Confidence {
|
||||
t.Fatalf("erwartete niedrigeren konfidenzwert für verschlechtertes bild, habe original=%.2f verschlechtert=%.2f",
|
||||
originalResult.Confidence, degradedResult.Confidence)
|
||||
}
|
||||
}
|
||||
|
||||
// pixelate verschlechtert img künstlich, reproduzierbar und ohne externe
|
||||
// Werkzeuge: Downsample um factor per Nearest-Neighbor, dann wieder auf
|
||||
// Originalgröße hochskaliert — zerstört Feindetails der Textglyphen.
|
||||
func pixelate(img image.Image, factor int) image.Image {
|
||||
bounds := img.Bounds()
|
||||
w, h := bounds.Dx(), bounds.Dy()
|
||||
out := image.NewRGBA(bounds)
|
||||
for y := 0; y < h; y++ {
|
||||
for x := 0; x < w; x++ {
|
||||
blockX := (x / factor) * factor
|
||||
blockY := (y / factor) * factor
|
||||
c := img.At(bounds.Min.X+blockX, bounds.Min.Y+blockY)
|
||||
out.Set(bounds.Min.X+x, bounds.Min.Y+y, colorToGray50(c))
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// colorToGray50 mischt zusätzlich mit 50% Grau, um den Kontrast zu
|
||||
// verringern — verstärkt die künstliche Qualitätsverschlechterung über
|
||||
// reine Pixelierung hinaus.
|
||||
func colorToGray50(c color.Color) color.Color {
|
||||
r, g, b, a := c.RGBA()
|
||||
mix := func(v uint32) uint8 {
|
||||
return uint8((v>>8)/2 + 128/2)
|
||||
}
|
||||
return color.RGBA{R: mix(r), G: mix(g), B: mix(b), A: uint8(a >> 8)}
|
||||
}
|
||||
@@ -0,0 +1,187 @@
|
||||
// Package ocr implementiert SRC-07: eine OCR-Pipeline für Bild-/PDF-
|
||||
// Anhänge, als eigener Mail-OCR-Pfad unabhängig vom DMS-Board (siehe
|
||||
// repos-analyse-mail-reuse.md: dupliziertes Sprintf-WHERE-Muster aus
|
||||
// archivmail wird NICHT übernommen — dieses Paket baut keine SQL-Klauseln,
|
||||
// ruft ausschließlich externe Kommandozeilenwerkzeuge mit festen
|
||||
// Argumentlisten auf, niemals über eine Shell/String-Konkatenation).
|
||||
//
|
||||
// Zustandslos: dieses Paket kennt weder Mandanten noch Speicher — es
|
||||
// nimmt Anhangs-Bytes entgegen und liefert erkannten Text zurück, exakt
|
||||
// wie mail/internal/crypto und mail/internal/dedup. Tenant-Trennung
|
||||
// entsteht dadurch strukturell: es gibt keinen geteilten Zustand
|
||||
// zwischen Aufrufen, den unterschiedliche Mandanten sehen könnten (jeder
|
||||
// Aufruf bekommt sein eigenes Temp-Verzeichnis, siehe workDir).
|
||||
//
|
||||
// Bekannter Fehler vermeiden (siehe ARC-03-Ticket): OCR darf erst NACH
|
||||
// abgeschlossener Duplikatsprüfung laufen — das ist Sache des Aufrufers
|
||||
// (spätere Ingest-Tickets), dieses Paket kennt mail/internal/dedup nicht.
|
||||
package ocr
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"fmt"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"sort"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Languages ist die feste Tesseract-Sprachkombination (Akzeptanzkriterium
|
||||
// 1 aus SRC-10 baut hierauf auf) — Deutsch und Englisch, passend zum
|
||||
// deutschsprachigen NEXARCH-Einsatzkontext mit englischsprachigen
|
||||
// Geschäftskorrespondenzen.
|
||||
const Languages = "deu+eng"
|
||||
|
||||
// ExtractTextFromImage führt Tesseract-OCR auf einem einzelnen Bild aus
|
||||
// (PNG/JPEG/TIFF/BMP — von Tesseract/Leptonica unterstützte Formate).
|
||||
func ExtractTextFromImage(ctx context.Context, imageBytes []byte) (string, error) {
|
||||
workDir, err := os.MkdirTemp("", "mail-ocr-*")
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("ocr: arbeitsverzeichnis anlegen: %w", err)
|
||||
}
|
||||
defer func() { _ = os.RemoveAll(workDir) }()
|
||||
|
||||
imagePath := filepath.Join(workDir, "input")
|
||||
if err := os.WriteFile(imagePath, imageBytes, 0o600); err != nil {
|
||||
return "", fmt.Errorf("ocr: bild schreiben: %w", err)
|
||||
}
|
||||
outBase := filepath.Join(workDir, "output")
|
||||
|
||||
cmd := exec.CommandContext(ctx, "tesseract", imagePath, outBase, "-l", Languages)
|
||||
var stderr bytes.Buffer
|
||||
cmd.Stderr = &stderr
|
||||
if err := cmd.Run(); err != nil {
|
||||
return "", fmt.Errorf("ocr: tesseract fehlgeschlagen: %w (%s)", err, stderr.String())
|
||||
}
|
||||
|
||||
text, err := os.ReadFile(outBase + ".txt")
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("ocr: erkannten text lesen: %w", err)
|
||||
}
|
||||
return strings.TrimSpace(string(text)), nil
|
||||
}
|
||||
|
||||
// minTextLayerLength ist die Mindestanzahl nicht-leerer Zeichen, ab der
|
||||
// ein PDF als "hat bereits eine Textebene" gilt (Akzeptanzkriterium 3).
|
||||
// Ein paar Steuerzeichen/Leerzeichen aus pdftotext bei einem rein
|
||||
// bildbasierten PDF dürfen keine OCR-Umgehung auslösen.
|
||||
const minTextLayerLength = 10
|
||||
|
||||
// HasTextLayer prüft über pdftotext, ob pdfBytes bereits durchsuchbaren
|
||||
// Text enthält (Akzeptanzkriterium 3: bereits durchsuchbare PDFs werden
|
||||
// nicht unnötig erneut per OCR verarbeitet).
|
||||
func HasTextLayer(ctx context.Context, pdfBytes []byte) (bool, error) {
|
||||
text, err := extractPDFText(ctx, pdfBytes)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
return len(strings.TrimSpace(text)) >= minTextLayerLength, nil
|
||||
}
|
||||
|
||||
func extractPDFText(ctx context.Context, pdfBytes []byte) (string, error) {
|
||||
workDir, err := os.MkdirTemp("", "mail-ocr-pdf-*")
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("ocr: arbeitsverzeichnis anlegen: %w", err)
|
||||
}
|
||||
defer func() { _ = os.RemoveAll(workDir) }()
|
||||
|
||||
pdfPath := filepath.Join(workDir, "input.pdf")
|
||||
if err := os.WriteFile(pdfPath, pdfBytes, 0o600); err != nil {
|
||||
return "", fmt.Errorf("ocr: pdf schreiben: %w", err)
|
||||
}
|
||||
|
||||
cmd := exec.CommandContext(ctx, "pdftotext", pdfPath, "-")
|
||||
var stdout, stderr bytes.Buffer
|
||||
cmd.Stdout = &stdout
|
||||
cmd.Stderr = &stderr
|
||||
if err := cmd.Run(); err != nil {
|
||||
return "", fmt.Errorf("ocr: pdftotext fehlgeschlagen: %w (%s)", err, stderr.String())
|
||||
}
|
||||
return stdout.String(), nil
|
||||
}
|
||||
|
||||
// PDFResult ist das Ergebnis von ExtractTextFromPDF.
|
||||
type PDFResult struct {
|
||||
Text string
|
||||
// OCRPerformed ist false, wenn eine vorhandene Textebene genutzt
|
||||
// wurde (Akzeptanzkriterium 3), true, wenn tatsächlich per Tesseract
|
||||
// erkannt wurde (Akzeptanzkriterium 1).
|
||||
OCRPerformed bool
|
||||
}
|
||||
|
||||
// ExtractTextFromPDF liefert den Text eines PDF-Anhangs: hat das PDF
|
||||
// bereits eine Textebene, wird sie direkt übernommen (schneller,
|
||||
// zuverlässiger als OCR, Akzeptanzkriterium 3). Sonst wird jede Seite
|
||||
// gerastert und per Tesseract erkannt (Akzeptanzkriterium 1: gescannte
|
||||
// PDF-Anhänge).
|
||||
func ExtractTextFromPDF(ctx context.Context, pdfBytes []byte) (PDFResult, error) {
|
||||
existingText, err := extractPDFText(ctx, pdfBytes)
|
||||
if err != nil {
|
||||
return PDFResult{}, err
|
||||
}
|
||||
if len(strings.TrimSpace(existingText)) >= minTextLayerLength {
|
||||
return PDFResult{Text: strings.TrimSpace(existingText), OCRPerformed: false}, nil
|
||||
}
|
||||
|
||||
pageImages, err := rasterizePDF(ctx, pdfBytes)
|
||||
if err != nil {
|
||||
return PDFResult{}, err
|
||||
}
|
||||
|
||||
var pages []string
|
||||
for _, imageBytes := range pageImages {
|
||||
pageText, err := ExtractTextFromImage(ctx, imageBytes)
|
||||
if err != nil {
|
||||
return PDFResult{}, err
|
||||
}
|
||||
pages = append(pages, pageText)
|
||||
}
|
||||
return PDFResult{Text: strings.TrimSpace(strings.Join(pages, "\n")), OCRPerformed: true}, nil
|
||||
}
|
||||
|
||||
// rasterizePDF rastert jede Seite von pdfBytes über pdftoppm in ein PNG
|
||||
// und liefert die Seiten in Reihenfolge.
|
||||
func rasterizePDF(ctx context.Context, pdfBytes []byte) ([][]byte, error) {
|
||||
workDir, err := os.MkdirTemp("", "mail-ocr-raster-*")
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("ocr: arbeitsverzeichnis anlegen: %w", err)
|
||||
}
|
||||
defer func() { _ = os.RemoveAll(workDir) }()
|
||||
|
||||
pdfPath := filepath.Join(workDir, "input.pdf")
|
||||
if err := os.WriteFile(pdfPath, pdfBytes, 0o600); err != nil {
|
||||
return nil, fmt.Errorf("ocr: pdf schreiben: %w", err)
|
||||
}
|
||||
outBase := filepath.Join(workDir, "page")
|
||||
|
||||
cmd := exec.CommandContext(ctx, "pdftoppm", "-png", "-r", "300", pdfPath, outBase)
|
||||
var stderr bytes.Buffer
|
||||
cmd.Stderr = &stderr
|
||||
if err := cmd.Run(); err != nil {
|
||||
return nil, fmt.Errorf("ocr: pdftoppm fehlgeschlagen: %w (%s)", err, stderr.String())
|
||||
}
|
||||
|
||||
entries, err := os.ReadDir(workDir)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("ocr: gerasterte seiten auflisten: %w", err)
|
||||
}
|
||||
var pagePaths []string
|
||||
for _, e := range entries {
|
||||
if strings.HasSuffix(e.Name(), ".png") {
|
||||
pagePaths = append(pagePaths, filepath.Join(workDir, e.Name()))
|
||||
}
|
||||
}
|
||||
sort.Strings(pagePaths)
|
||||
|
||||
var pages [][]byte
|
||||
for _, p := range pagePaths {
|
||||
data, err := os.ReadFile(p)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("ocr: gerasterte seite lesen: %w", err)
|
||||
}
|
||||
pages = append(pages, data)
|
||||
}
|
||||
return pages, nil
|
||||
}
|
||||
@@ -0,0 +1,156 @@
|
||||
package ocr
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"image/png"
|
||||
"os/exec"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func requireTools(t *testing.T) {
|
||||
t.Helper()
|
||||
for _, tool := range []string{"tesseract", "pdftotext", "pdftoppm"} {
|
||||
if _, err := exec.LookPath(tool); err != nil {
|
||||
t.Skipf("%s nicht im PATH, Integrationstest übersprungen", tool)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// knownTextImage rastert ein hand-gebautes Text-PDF (bekannter Inhalt)
|
||||
// über die echte pdftoppm-Pipeline in ein reales PNG-Bild — liefert damit
|
||||
// ein Bild mit tatsächlich gerenderten, OCR-fähigen Glyphen, ohne eine
|
||||
// zusätzliche Font-Rendering-Bibliothek einzuführen.
|
||||
func knownTextImage(t *testing.T, ctx context.Context, text string) []byte {
|
||||
t.Helper()
|
||||
pdfBytes := buildTextLayerPDF(text)
|
||||
pages, err := rasterizePDF(ctx, pdfBytes)
|
||||
if err != nil {
|
||||
t.Fatalf("testbild rastern: %v", err)
|
||||
}
|
||||
if len(pages) != 1 {
|
||||
t.Fatalf("erwartete genau 1 gerasterte seite, habe %d", len(pages))
|
||||
}
|
||||
return pages[0]
|
||||
}
|
||||
|
||||
// TestExtractTextFromImage_KnownTextRecognized ist die geforderte
|
||||
// Pflichtprüfung 1: Bildanhang mit bekanntem Text liefert erwartete
|
||||
// Texterkennung.
|
||||
func TestExtractTextFromImage_KnownTextRecognized(t *testing.T) {
|
||||
requireTools(t)
|
||||
ctx := context.Background()
|
||||
imageBytes := knownTextImage(t, ctx, "Rechnungsnummer 4711")
|
||||
|
||||
got, err := ExtractTextFromImage(ctx, imageBytes)
|
||||
if err != nil {
|
||||
t.Fatalf("extracttextfromimage: %v", err)
|
||||
}
|
||||
if !strings.Contains(got, "Rechnungsnummer") || !strings.Contains(got, "4711") {
|
||||
t.Fatalf("erwarteten text nicht erkannt, habe: %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
// TestExtractTextFromPDF_SkipsOCRWhenTextLayerPresent ist die geforderte
|
||||
// Pflichtprüfung 2: PDF mit vorhandener Textebene wird korrekt
|
||||
// übersprungen.
|
||||
func TestExtractTextFromPDF_SkipsOCRWhenTextLayerPresent(t *testing.T) {
|
||||
requireTools(t)
|
||||
ctx := context.Background()
|
||||
pdfBytes := buildTextLayerPDF("Vertragsentwurf Version 3")
|
||||
|
||||
hasLayer, err := HasTextLayer(ctx, pdfBytes)
|
||||
if err != nil {
|
||||
t.Fatalf("hastextlayer: %v", err)
|
||||
}
|
||||
if !hasLayer {
|
||||
t.Fatal("erwartete erkannte textebene im vektor-pdf")
|
||||
}
|
||||
|
||||
result, err := ExtractTextFromPDF(ctx, pdfBytes)
|
||||
if err != nil {
|
||||
t.Fatalf("extracttextfrompdf: %v", err)
|
||||
}
|
||||
if result.OCRPerformed {
|
||||
t.Fatal("ocr wurde durchgeführt, obwohl eine textebene vorhanden war")
|
||||
}
|
||||
if !strings.Contains(result.Text, "Vertragsentwurf") {
|
||||
t.Fatalf("erwarteten text aus textebene nicht gefunden, habe: %q", result.Text)
|
||||
}
|
||||
}
|
||||
|
||||
// TestExtractTextFromPDF_PerformsOCRWhenNoTextLayer deckt
|
||||
// Akzeptanzkriterium 1 (gescannte PDF-Anhänge) zusätzlich end-zu-Ende ab:
|
||||
// ein PDF ohne Textebene, das nur ein Rasterbild enthält, wird real per
|
||||
// OCR erkannt.
|
||||
func TestExtractTextFromPDF_PerformsOCRWhenNoTextLayer(t *testing.T) {
|
||||
requireTools(t)
|
||||
ctx := context.Background()
|
||||
|
||||
pngBytes := knownTextImage(t, ctx, "Gescannter Anhang Test")
|
||||
img, err := png.Decode(bytes.NewReader(pngBytes))
|
||||
if err != nil {
|
||||
t.Fatalf("testbild dekodieren: %v", err)
|
||||
}
|
||||
scannedPDF, err := buildImageOnlyPDF(img)
|
||||
if err != nil {
|
||||
t.Fatalf("bild-pdf bauen: %v", err)
|
||||
}
|
||||
|
||||
hasLayer, err := HasTextLayer(ctx, scannedPDF)
|
||||
if err != nil {
|
||||
t.Fatalf("hastextlayer: %v", err)
|
||||
}
|
||||
if hasLayer {
|
||||
t.Fatal("bild-only-pdf wurde fälschlich als textebene erkannt")
|
||||
}
|
||||
|
||||
result, err := ExtractTextFromPDF(ctx, scannedPDF)
|
||||
if err != nil {
|
||||
t.Fatalf("extracttextfrompdf: %v", err)
|
||||
}
|
||||
if !result.OCRPerformed {
|
||||
t.Fatal("erwartete durchgeführte ocr bei fehlender textebene")
|
||||
}
|
||||
if !strings.Contains(result.Text, "Gescannter") {
|
||||
t.Fatalf("erwarteten text aus ocr nicht gefunden, habe: %q", result.Text)
|
||||
}
|
||||
}
|
||||
|
||||
// TestExtractTextFromPDF_ThroughputIsAcceptable ist die geforderte
|
||||
// Pflichtprüfung 3: Durchsatztest bestätigt akzeptable Verarbeitungszeit
|
||||
// je Anhang. Zielzeit 8s je Anhang (großzügig für Rasterung + OCR bei
|
||||
// 300dpi, deckt aber real ab, dass kein pathologischer Ausreißer
|
||||
// entsteht).
|
||||
func TestExtractTextFromPDF_ThroughputIsAcceptable(t *testing.T) {
|
||||
requireTools(t)
|
||||
ctx := context.Background()
|
||||
|
||||
const attachments = 3
|
||||
const targetPerAttachment = 8 * time.Second
|
||||
|
||||
pngBytes := knownTextImage(t, ctx, "Durchsatztest Anhang")
|
||||
img, err := png.Decode(bytes.NewReader(pngBytes))
|
||||
if err != nil {
|
||||
t.Fatalf("testbild dekodieren: %v", err)
|
||||
}
|
||||
scannedPDF, err := buildImageOnlyPDF(img)
|
||||
if err != nil {
|
||||
t.Fatalf("bild-pdf bauen: %v", err)
|
||||
}
|
||||
|
||||
start := time.Now()
|
||||
for i := 0; i < attachments; i++ {
|
||||
if _, err := ExtractTextFromPDF(ctx, scannedPDF); err != nil {
|
||||
t.Fatalf("anhang %d: %v", i, err)
|
||||
}
|
||||
}
|
||||
elapsed := time.Since(start)
|
||||
perAttachment := elapsed / attachments
|
||||
t.Logf("Durchsatz: %d Anhänge in %s (%s/Anhang, Ziel %s/Anhang)", attachments, elapsed, perAttachment, targetPerAttachment)
|
||||
if perAttachment > targetPerAttachment {
|
||||
t.Fatalf("verarbeitung zu langsam: %s/anhang, ziel %s/anhang", perAttachment, targetPerAttachment)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,95 @@
|
||||
package ocr
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"image"
|
||||
"image/jpeg"
|
||||
)
|
||||
|
||||
// buildTextLayerPDF erzeugt ein minimales, aber ECHTES PDF mit einer
|
||||
// vektorbasierten Textebene (Standardfont Helvetica, kein eingebettetes
|
||||
// Fontprogramm nötig) — von Hand gebaut, keine externe Bibliothek/kein
|
||||
// externes Werkzeug, damit der Test reproduzierbar und unabhängig von
|
||||
// Systempaketen bleibt. pdftotext extrahiert text unmittelbar daraus.
|
||||
func buildTextLayerPDF(text string) []byte {
|
||||
var buf bytes.Buffer
|
||||
offsets := make([]int, 0, 6)
|
||||
|
||||
buf.WriteString("%PDF-1.4\n")
|
||||
|
||||
writeObj := func(n int, body string) {
|
||||
offsets = append(offsets, buf.Len())
|
||||
fmt.Fprintf(&buf, "%d 0 obj\n%s\nendobj\n", n, body)
|
||||
}
|
||||
|
||||
writeObj(1, "<< /Type /Catalog /Pages 2 0 R >>")
|
||||
writeObj(2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>")
|
||||
writeObj(3, "<< /Type /Page /Parent 2 0 R /Resources << /Font << /F1 5 0 R >> >> /MediaBox [0 0 400 200] /Contents 4 0 R >>")
|
||||
|
||||
content := fmt.Sprintf("BT /F1 24 Tf 20 100 Td (%s) Tj ET", text)
|
||||
stream := fmt.Sprintf("<< /Length %d >>\nstream\n%s\nendstream", len(content), content)
|
||||
writeObj(4, stream)
|
||||
writeObj(5, "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>")
|
||||
|
||||
xrefStart := buf.Len()
|
||||
fmt.Fprintf(&buf, "xref\n0 %d\n", len(offsets)+1)
|
||||
buf.WriteString("0000000000 65535 f \n")
|
||||
for _, off := range offsets {
|
||||
fmt.Fprintf(&buf, "%010d 00000 n \n", off)
|
||||
}
|
||||
fmt.Fprintf(&buf, "trailer\n<< /Size %d /Root 1 0 R >>\nstartxref\n%d\n%%%%EOF", len(offsets)+1, xrefStart)
|
||||
|
||||
return buf.Bytes()
|
||||
}
|
||||
|
||||
// buildImageOnlyPDF erzeugt ein minimales, ECHTES PDF, dessen einzige
|
||||
// Seite ausschließlich aus einem eingebetteten Rasterbild besteht (JPEG
|
||||
// via /DCTDecode — von PDF nativ unterstützt, kein zusätzlicher Codec
|
||||
// nötig) — simuliert ein gescanntes PDF ohne Textebene
|
||||
// (Akzeptanzkriterium 1).
|
||||
func buildImageOnlyPDF(img image.Image) ([]byte, error) {
|
||||
var jpegBuf bytes.Buffer
|
||||
if err := jpeg.Encode(&jpegBuf, img, &jpeg.Options{Quality: 90}); err != nil {
|
||||
return nil, fmt.Errorf("jpeg kodieren: %w", err)
|
||||
}
|
||||
bounds := img.Bounds()
|
||||
w, h := bounds.Dx(), bounds.Dy()
|
||||
|
||||
var buf bytes.Buffer
|
||||
offsets := make([]int, 0, 6)
|
||||
buf.WriteString("%PDF-1.4\n")
|
||||
|
||||
writeObj := func(n int, header string, body []byte) {
|
||||
offsets = append(offsets, buf.Len())
|
||||
fmt.Fprintf(&buf, "%d 0 obj\n%s\n", n, header)
|
||||
if body != nil {
|
||||
buf.Write(body)
|
||||
buf.WriteString("\nendstream\n")
|
||||
}
|
||||
buf.WriteString("endobj\n")
|
||||
}
|
||||
|
||||
writeObj(1, "<< /Type /Catalog /Pages 2 0 R >>", nil)
|
||||
writeObj(2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>", nil)
|
||||
writeObj(3, fmt.Sprintf("<< /Type /Page /Parent 2 0 R /Resources << /XObject << /Im0 5 0 R >> >> /MediaBox [0 0 %d %d] /Contents 4 0 R >>", w, h), nil)
|
||||
|
||||
content := fmt.Sprintf("q %d 0 0 %d 0 0 cm /Im0 Do Q", w, h)
|
||||
writeObj(4, fmt.Sprintf("<< /Length %d >>\nstream", len(content)), []byte(content))
|
||||
|
||||
imgHeader := fmt.Sprintf(
|
||||
"<< /Type /XObject /Subtype /Image /Width %d /Height %d /ColorSpace /DeviceRGB /BitsPerComponent 8 /Filter /DCTDecode /Length %d >>\nstream",
|
||||
w, h, jpegBuf.Len(),
|
||||
)
|
||||
writeObj(5, imgHeader, jpegBuf.Bytes())
|
||||
|
||||
xrefStart := buf.Len()
|
||||
fmt.Fprintf(&buf, "xref\n0 %d\n", len(offsets)+1)
|
||||
buf.WriteString("0000000000 65535 f \n")
|
||||
for _, off := range offsets {
|
||||
fmt.Fprintf(&buf, "%010d 00000 n \n", off)
|
||||
}
|
||||
fmt.Fprintf(&buf, "trailer\n<< /Size %d /Root 1 0 R >>\nstartxref\n%d\n%%%%EOF", len(offsets)+1, xrefStart)
|
||||
|
||||
return buf.Bytes(), nil
|
||||
}
|
||||
@@ -38,11 +38,22 @@ var migrationAddAttachmentType string
|
||||
//go:embed migrations/0005_mail_documents_tag.sql
|
||||
var migrationAddTag string
|
||||
|
||||
// SRC-10: OCR-Sprach-/Qualitätsfelder, gleiches Muster wie die
|
||||
// Facettenfelder aus SRC-05.
|
||||
//
|
||||
//go:embed migrations/0006_mail_documents_ocr_language.sql
|
||||
var migrationAddOCRLanguage string
|
||||
|
||||
//go:embed migrations/0007_mail_documents_ocr_confidence.sql
|
||||
var migrationAddOCRConfidence string
|
||||
|
||||
var facetMigrations = []string{
|
||||
migrationAddSender,
|
||||
migrationAddMailbox,
|
||||
migrationAddAttachmentType,
|
||||
migrationAddTag,
|
||||
migrationAddOCRLanguage,
|
||||
migrationAddOCRConfidence,
|
||||
}
|
||||
|
||||
// Client spricht ausschließlich über die strukturierte Manticore-HTTP-
|
||||
@@ -122,6 +133,10 @@ type Document struct {
|
||||
Mailbox string `json:"mailbox"`
|
||||
AttachmentType string `json:"attachment_type"`
|
||||
Tag string `json:"tag"`
|
||||
// OCR-Sprach-/Qualitätsfelder (SRC-10), optional — leerer String/0
|
||||
// bedeutet "kein OCR-Anhang bzw. kein Konfidenzwert vorhanden".
|
||||
OCRLanguage string `json:"ocr_language"`
|
||||
OCRConfidence float64 `json:"ocr_confidence"`
|
||||
}
|
||||
|
||||
// Index legt/ersetzt ein Suchdokument (Akzeptanzkriterium 2: Schreibzugriff
|
||||
@@ -193,6 +208,11 @@ type Result struct {
|
||||
Subject string
|
||||
Score int64
|
||||
SentAtUnixEpoch int64
|
||||
// OCRLanguage/OCRConfidence (SRC-10 Akzeptanzkriterium 1: erkannte
|
||||
// Sprache für Anzeige nutzbar) — leer/0, wenn das Dokument keinen
|
||||
// OCR-Anhang hat.
|
||||
OCRLanguage string
|
||||
OCRConfidence float64
|
||||
}
|
||||
|
||||
// fieldWeights gewichtet Betreff höher als Text, Anhangstext am
|
||||
@@ -307,6 +327,8 @@ func (c *Client) Search(ctx context.Context, tenantSlug, queryText string) ([]Re
|
||||
Subject: hit.Source.Subject,
|
||||
Score: hit.Score,
|
||||
SentAtUnixEpoch: hit.Source.SentAtUnixEpoch,
|
||||
OCRLanguage: hit.Source.OCRLanguage,
|
||||
OCRConfidence: hit.Source.OCRConfidence,
|
||||
})
|
||||
}
|
||||
return results, nil
|
||||
@@ -317,9 +339,11 @@ type searchResponse struct {
|
||||
Hits []struct {
|
||||
Score int64 `json:"_score"`
|
||||
Source struct {
|
||||
MessageID string `json:"message_id"`
|
||||
Subject string `json:"subject"`
|
||||
SentAtUnixEpoch int64 `json:"sent_at"`
|
||||
MessageID string `json:"message_id"`
|
||||
Subject string `json:"subject"`
|
||||
SentAtUnixEpoch int64 `json:"sent_at"`
|
||||
OCRLanguage string `json:"ocr_language"`
|
||||
OCRConfidence float64 `json:"ocr_confidence"`
|
||||
} `json:"_source"`
|
||||
} `json:"hits"`
|
||||
} `json:"hits"`
|
||||
|
||||
@@ -142,6 +142,8 @@ func (c *Client) SearchWithFilters(ctx context.Context, tenantSlug, queryText st
|
||||
Subject: hit.Source.Subject,
|
||||
Score: hit.Score,
|
||||
SentAtUnixEpoch: hit.Source.SentAtUnixEpoch,
|
||||
OCRLanguage: hit.Source.OCRLanguage,
|
||||
OCRConfidence: hit.Source.OCRConfidence,
|
||||
})
|
||||
}
|
||||
return results, nil
|
||||
@@ -230,6 +232,56 @@ func (c *Client) Facets(ctx context.Context, tenantSlug, queryText string, filte
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// AttachmentsBelowConfidence liefert alle Dokumente eines Mandanten, deren
|
||||
// OCR-Konfidenzwert UNTER threshold liegt (SRC-10 Akzeptanzkriterium 3:
|
||||
// gezielt für manuelle Nachbearbeitung auffindbar). Dokumente ohne
|
||||
// OCR-Anhang (ocr_confidence bleibt 0) tauchen hier NICHT auf — 0 ist
|
||||
// "kein Wert", nicht "schlechtester Wert" (siehe Document-Feldkommentar) —
|
||||
// daher zusätzlicher Filter ocr_confidence > 0.
|
||||
func (c *Client) AttachmentsBelowConfidence(ctx context.Context, tenantSlug string, threshold float64) ([]Result, error) {
|
||||
payload := map[string]any{
|
||||
"index": IndexName,
|
||||
"query": map[string]any{
|
||||
"bool": map[string]any{
|
||||
"must": []map[string]any{
|
||||
{"equals": map[string]any{FieldTenantSlug: tenantSlug}},
|
||||
{"range": map[string]any{FieldOCRConfidence: map[string]any{"gt": 0}}},
|
||||
{"range": map[string]any{FieldOCRConfidence: map[string]any{"lt": threshold}}},
|
||||
},
|
||||
},
|
||||
},
|
||||
"sort": []map[string]any{{FieldOCRConfidence: "asc"}},
|
||||
"limit": searchResultLimit,
|
||||
}
|
||||
body, err := json.Marshal(payload)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("search: konfidenzanfrage serialisieren: %w", err)
|
||||
}
|
||||
|
||||
respBody, err := c.doSearchWithSwapRetry(ctx, body)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
var parsed searchResponse
|
||||
if err := json.Unmarshal(respBody, &parsed); err != nil {
|
||||
return nil, fmt.Errorf("search: antwort parsen: %w", err)
|
||||
}
|
||||
|
||||
results := make([]Result, 0, len(parsed.Hits.Hits))
|
||||
for _, hit := range parsed.Hits.Hits {
|
||||
results = append(results, Result{
|
||||
MessageID: hit.Source.MessageID,
|
||||
Subject: hit.Source.Subject,
|
||||
Score: hit.Score,
|
||||
SentAtUnixEpoch: hit.Source.SentAtUnixEpoch,
|
||||
OCRLanguage: hit.Source.OCRLanguage,
|
||||
OCRConfidence: hit.Source.OCRConfidence,
|
||||
})
|
||||
}
|
||||
return results, nil
|
||||
}
|
||||
|
||||
type facetResponse struct {
|
||||
Aggregations map[string]struct {
|
||||
Buckets []struct {
|
||||
|
||||
@@ -29,6 +29,10 @@ const (
|
||||
FieldMailbox = "mailbox"
|
||||
FieldAttachmentType = "attachment_type"
|
||||
FieldTag = "tag"
|
||||
// OCR-Sprach-/Qualitätsfelder (SRC-10), nachgezogen über
|
||||
// migrations/0006..0007.
|
||||
FieldOCRLanguage = "ocr_language"
|
||||
FieldOCRConfidence = "ocr_confidence"
|
||||
)
|
||||
|
||||
// FacetFields sind die je Kachel unterstützten Filterdimensionen
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
ALTER TABLE mail_documents ADD COLUMN ocr_language string attribute indexed
|
||||
@@ -0,0 +1 @@
|
||||
ALTER TABLE mail_documents ADD COLUMN ocr_confidence float
|
||||
@@ -0,0 +1,53 @@
|
||||
// Integrationstest (SRC-10): echte Manticore-Instanz, TEST_MANTICORE_URL
|
||||
// (gleiche Konvention wie facets_test.go/ranking_test.go).
|
||||
package search
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// TestAttachmentsBelowConfidence_QueryReturnsExpectedResults ist die
|
||||
// geforderte Pflichtprüfung 3: Abfrage aller Anhänge unterhalb einer
|
||||
// Konfidenzschwelle liefert erwartete Treffer.
|
||||
func TestAttachmentsBelowConfidence_QueryReturnsExpectedResults(t *testing.T) {
|
||||
client := setupClient(t)
|
||||
ctx := context.Background()
|
||||
tenant := "mandant-src10-konfidenz"
|
||||
|
||||
docs := []Document{
|
||||
{MessageID: "msg-conf-niedrig-1", Subject: "a", OCRLanguage: "deu", OCRConfidence: 22.5},
|
||||
{MessageID: "msg-conf-niedrig-2", Subject: "b", OCRLanguage: "eng", OCRConfidence: 41.0},
|
||||
{MessageID: "msg-conf-hoch", Subject: "c", OCRLanguage: "deu", OCRConfidence: 93.2},
|
||||
{MessageID: "msg-conf-kein-ocr", Subject: "d"}, // kein OCR-Anhang, OCRConfidence bleibt 0
|
||||
}
|
||||
for _, d := range docs {
|
||||
d.TenantSlug = tenant
|
||||
d.ID = DocumentID(tenant, d.MessageID)
|
||||
if err := client.Index(ctx, d); err != nil {
|
||||
t.Fatalf("index %s: %v", d.MessageID, err)
|
||||
}
|
||||
}
|
||||
|
||||
results, err := client.AttachmentsBelowConfidence(ctx, tenant, 50.0)
|
||||
if err != nil {
|
||||
t.Fatalf("attachmentsbelowconfidence: %v", err)
|
||||
}
|
||||
|
||||
ids := make(map[string]bool, len(results))
|
||||
for _, r := range results {
|
||||
ids[r.MessageID] = true
|
||||
}
|
||||
if !ids["msg-conf-niedrig-1"] || !ids["msg-conf-niedrig-2"] {
|
||||
t.Fatalf("erwartete beide niedrig-konfidenten anhänge, habe: %+v", results)
|
||||
}
|
||||
if ids["msg-conf-hoch"] {
|
||||
t.Fatalf("hoch-konfidenter anhang hätte nicht auftauchen dürfen: %+v", results)
|
||||
}
|
||||
if ids["msg-conf-kein-ocr"] {
|
||||
t.Fatalf("dokument ohne ocr-anhang (confidence=0) hätte nicht auftauchen dürfen: %+v", results)
|
||||
}
|
||||
if len(results) != 2 {
|
||||
t.Fatalf("erwartete genau 2 treffer, habe %d: %+v", len(results), results)
|
||||
}
|
||||
}
|
||||
@@ -276,13 +276,17 @@ func (c *Client) showTables(ctx context.Context) ([]string, error) {
|
||||
|
||||
// buildCreateTableSQL erzeugt die Schema-DDL für eine Zwischentabelle mit
|
||||
// demselben Spaltensatz wie mail_documents (Basis + Facettenfelder aus
|
||||
// SRC-05). tableName ist über tempTableNamePattern in Rebuild bereits
|
||||
// geprüft, bevor diese Funktion aufgerufen wird.
|
||||
// SRC-05 + OCR-Felder aus SRC-10). tableName ist über
|
||||
// tempTableNamePattern in Rebuild bereits geprüft, bevor diese Funktion
|
||||
// aufgerufen wird. MUSS bei jeder neuen Spalte in mail_documents
|
||||
// (migrations/000N_*.sql) mitgepflegt werden — sonst schlägt Reindex mit
|
||||
// "unknown column" fehl (siehe SRC-10, real so aufgetreten und behoben).
|
||||
func buildCreateTableSQL(tableName string) string {
|
||||
return fmt.Sprintf(
|
||||
"CREATE TABLE %s (%s string attribute indexed, %s string attribute indexed, %s text, %s text, %s text, %s string attribute indexed, %s string attribute indexed, %s string attribute indexed, %s string attribute indexed, %s timestamp)",
|
||||
"CREATE TABLE %s (%s string attribute indexed, %s string attribute indexed, %s text, %s text, %s text, %s string attribute indexed, %s string attribute indexed, %s string attribute indexed, %s string attribute indexed, %s timestamp, %s string attribute indexed, %s float)",
|
||||
tableName,
|
||||
FieldTenantSlug, FieldMessageID, FieldSubject, FieldBody, FieldAttachmentText,
|
||||
FieldSender, FieldMailbox, FieldAttachmentType, FieldTag, FieldSentAt,
|
||||
FieldOCRLanguage, FieldOCRConfidence,
|
||||
)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user