From b9cfdbe29e5800d31591aaeec410b5e57055b78a Mon Sep 17 00:00:00 2001 From: flfeders Date: Thu, 24 Sep 2026 17:09:35 +0200 Subject: [PATCH] fix(scan): allow slower SANE network discovery --- agents/fedeo-device-agent/src/scan/sane.ts | 4 +++- agents/fedeo-device-agent/tests/scan.test.ts | 21 ++++++++++++++++++-- frontend/assets/device-agent/bundle.json | 2 +- 3 files changed, 23 insertions(+), 4 deletions(-) diff --git a/agents/fedeo-device-agent/src/scan/sane.ts b/agents/fedeo-device-agent/src/scan/sane.ts index c65f5f73..33b7d9f7 100644 --- a/agents/fedeo-device-agent/src/scan/sane.ts +++ b/agents/fedeo-device-agent/src/scan/sane.ts @@ -20,7 +20,9 @@ export const hasSane = () => commandExists("scanimage") export const listScanners = async () => { if (!await hasSane()) return [] - const result = await runCommand("scanimage", ["-L"], { timeoutMs: 10_000 }) + // SANE also probes network backends; these can take more than ten seconds + // even when the USB scanner is already available. + const result = await runCommand("scanimage", ["-L"], { timeoutMs: 30_000 }) if (result.code !== 0) return [] return result.stdout.split(/\r?\n/) .map((line) => line.trim().match(/^device `([^']+)'/)?.[1]) diff --git a/agents/fedeo-device-agent/tests/scan.test.ts b/agents/fedeo-device-agent/tests/scan.test.ts index d2fd8182..232cbcb1 100644 --- a/agents/fedeo-device-agent/tests/scan.test.ts +++ b/agents/fedeo-device-agent/tests/scan.test.ts @@ -3,16 +3,21 @@ import test, { TestContext } from "node:test" import os from "node:os" import path from "node:path" import { chmod, mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises" -import { runScan } from "../src/scan/sane.js" +import { listScanners, runScan } from "../src/scan/sane.js" import { commandExists, runCommand } from "../src/commands.js" import { AgentConfig, ScanJob } from "../src/types.js" const fakeScanner = `#!/usr/bin/env python3 -import json, os, sys +import json, os, sys, time from pathlib import Path from PIL import Image args = sys.argv[1:] Path(os.environ['SCAN_TEST_CALL']).write_text(json.dumps(args)) +if args == ['-L']: + time.sleep(float(os.environ.get('SCAN_TEST_DISCOVERY_DELAY', '0'))) + print("device " + chr(96) + "fujitsu:ScanSnap iX1600:test' is a FUJITSU scanner") + print("device " + chr(96) + "airscan:test' is a network scanner") + sys.exit(int(os.environ.get('SCAN_TEST_EXIT', '0'))) batch = next((arg.split('=', 1)[1] for arg in args if arg.startswith('--batch=')), None) single = args[args.index('--output-file') + 1] if '--output-file' in args else None count = int(os.environ.get('SCAN_TEST_PAGES', '4')) if batch else 1 @@ -52,6 +57,18 @@ const setup = async (t: TestContext) => { return { config, job, dir, args: async () => JSON.parse(await readFile(process.env.SCAN_TEST_CALL!, "utf8")) as string[] } } +test("scanner discovery waits for network probes beyond the former ten-second limit", async (t) => { + await setup(t) + process.env.SCAN_TEST_DISCOVERY_DELAY = "10.2" + assert.deepEqual(await listScanners(), ["fujitsu:ScanSnap iX1600:test", "airscan:test"]) +}) + +test("failed scanner discovery does not advertise devices from an unsuccessful command", async (t) => { + await setup(t) + process.env.SCAN_TEST_EXIT = "1" + assert.deepEqual(await listScanners(), []) +}) + test("duplex batch saves all pages as PDF, accepts NO_DOCS and passes A4 geometry", async (t) => { const { config, job, args } = await setup(t) process.env.SCAN_TEST_EMPTY_FINAL = "1" diff --git a/frontend/assets/device-agent/bundle.json b/frontend/assets/device-agent/bundle.json index c3b71491..84a2b6ed 100644 --- a/frontend/assets/device-agent/bundle.json +++ b/frontend/assets/device-agent/bundle.json @@ -10,7 +10,7 @@ "dist/main.js": "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", "dist/print/cups.js": "aW1wb3J0IHsgY29tbWFuZEV4aXN0cywgcnVuQ29tbWFuZCB9IGZyb20gIi4uL2NvbW1hbmRzLmpzIjsKZXhwb3J0IGNvbnN0IGhhc0N1cHMgPSAoKSA9PiBjb21tYW5kRXhpc3RzKCJscHN0YXQiKTsKZXhwb3J0IGNvbnN0IGxpc3RQcmludGVycyA9IGFzeW5jICgpID0+IHsKICAgIGlmICghYXdhaXQgaGFzQ3VwcygpKQogICAgICAgIHJldHVybiBbXTsKICAgIGNvbnN0IHJlc3VsdCA9IGF3YWl0IHJ1bkNvbW1hbmQoImxwc3RhdCIsIFsiLXAiXSwgeyB0aW1lb3V0TXM6IDEwXzAwMCB9KTsKICAgIGlmIChyZXN1bHQuY29kZSAhPT0gMCkKICAgICAgICByZXR1cm4gW107CiAgICByZXR1cm4gcmVzdWx0LnN0ZG91dAogICAgICAgIC5zcGxpdCgvXHI/XG4vKQogICAgICAgIC5tYXAoKGxpbmUpID0+IGxpbmUubWF0Y2goL15wcmludGVyXHMrKFxTKykvKT8uWzFdKQogICAgICAgIC5maWx0ZXIoKHByaW50ZXIpID0+IEJvb2xlYW4ocHJpbnRlcikpOwp9Owo=", "dist/scan/postprocess.js": "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", - "dist/scan/sane.js": "import { mkdir, mkdtemp, readdir, stat } from "node:fs/promises";
import path from "node:path";
import { commandExists, runCommand } from "../commands.js";
import { checkScanRuntime, createScanDocument } from "./postprocess.js";
const stringSetting = (settings, key) => {
    const value = settings[key];
    return typeof value === "string" && value.trim() ? value.trim() : undefined;
};
const booleanSetting = (settings, key, fallback) => {
    const value = settings[key];
    if (typeof value === "boolean")
        return value;
    if (typeof value === "string")
        return ["1", "true", "yes", "ja", "on"].includes(value.trim().toLowerCase());
    return fallback;
};
export const hasSane = () => commandExists("scanimage");
export const listScanners = async () => {
    if (!await hasSane())
        return [];
    const result = await runCommand("scanimage", ["-L"], { timeoutMs: 10_000 });
    if (result.code !== 0)
        return [];
    return result.stdout.split(/\r?\n/)
        .map((line) => line.trim().match(/^device `([^']+)'/)?.[1])
        .filter((device) => Boolean(device));
};
export const runScan = async (config, job, reportProgress = async () => { }) => {
    if (!await hasSane())
        throw new Error("scanimage ist nicht installiert oder nicht im PATH");
    const settings = job.settings || {};
    const format = stringSetting(settings, "format") || config.scanFormat;
    if (!["pdf", "png", "tiff"].includes(format))
        throw new Error("Scan-Format muss PDF, PNG oder TIFF sein");
    const resolution = Number(settings.resolution ?? config.scanResolution);
    if (!Number.isFinite(resolution) || resolution < 75 || resolution > 1200) {
        throw new Error("Die Scan-Auflösung muss zwischen 75 und 1200 dpi liegen");
    }
    const mode = stringSetting(settings, "mode") || config.scanMode;
    const source = stringSetting(settings, "source") || config.scanSource;
    const scannerName = job.scannerName || config.scannerName;
    const paperSize = stringSetting(settings, "paperSize") || "auto";
    if (!["auto", "A4", "Letter"].includes(paperSize))
        throw new Error("Unbekanntes Papierformat");
    const batch = Boolean(source && /adf|document feeder/i.test(source));
    if (batch && format !== "pdf")
        throw new Error("Für Einzug- und Duplex-Scans bitte PDF als Format wählen");
    const postprocess = booleanSetting(settings, "postprocess", config.scanPostprocess);
    const profile = stringSetting(settings, "postprocessProfile") || config.postprocessProfile;
    if (!["document", "receipt", "raw"].includes(profile))
        throw new Error("Unbekanntes Nachbearbeitungsprofil");
    await checkScanRuntime(config, postprocess);
    // Each physical scan has its own directory. A filename cannot escape it or overwrite another job.
    await mkdir(config.workDir, { recursive: true, mode: 0o700 });
    const jobDir = await mkdtemp(path.join(path.resolve(config.workDir), "scan-"));
    const requested = path.basename((job.requestedFilename || "scan").replace(/\\/g, "/"));
    const stem = requested.replace(/\.[^.]*$/, "").replace(/[\x00-\x1f]/g, "").trim() || "scan";
    const outputPath = path.join(jobDir, `${stem}.${format}`);
    try {
        // Device/source come first: changing source can change the remaining SANE options.
        const args = [];
        if (scannerName)
            args.push("--device-name", scannerName);
        if (source)
            args.push("--source", source);
        args.push("--mode", mode, "--resolution", String(resolution), "--format=png");
        if (paperSize !== "auto") {
            const [width, height] = paperSize === "A4" ? [210, 297] : [215.9, 279.4];
            if (scannerName?.startsWith("fujitsu:")) {
                args.push("--page-width", String(width), "--page-height", String(height));
            }
            args.push("-l", "0", "-t", "0", "-x", String(width), "-y", String(height));
        }
        if (batch) {
            // Relative pattern avoids interpreting '%' in a user-configured work directory.
            args.push("--batch=page-%06d.png", "--batch-start=1", "--batch-increment=1");
        }
        else {
            args.push("--output-file", "page-000001.png");
        }
        await reportProgress(batch ? "Dokumente werden eingezogen und gescannt..." : "Seite wird gescannt...");
        const result = await runCommand("scanimage", args, {
            cwd: jobDir,
            timeoutMs: config.scanTimeoutSeconds * 1000,
        });
        // SANE_STATUS_NO_DOCS (7) is the expected end of an unlimited ADF batch.
        // Never turn paper jams, I/O errors or canceled scans into a successful partial upload.
        if (result.code !== 0 && !(batch && result.code === 7)) {
            throw new Error(result.stderr.trim() || `scanimage wurde mit Code ${result.code} beendet`);
        }
        const names = (await readdir(jobDir))
            .filter((name) => /^page-\d+\.png$/.test(name))
            .sort((a, b) => Number(a.match(/\d+/)[0]) - Number(b.match(/\d+/)[0]));
        const pages = [];
        for (const [index, name] of names.entries()) {
            const page = path.join(jobDir, name);
            // Some scanimage versions leave a zero-byte file for the final NO_DOCS attempt.
            if ((await stat(page)).size === 0) {
                if (batch && result.code === 7 && index === names.length - 1)
                    continue;
                throw new Error(`Unvollständige Scan-Seite: ${name}`);
            }
            if (Number(name.match(/\d+/)[0]) !== index + 1)
                throw new Error("Im Scan fehlen Seiten");
            pages.push(page);
        }
        if (!pages.length)
            throw new Error("Keine Seiten gescannt. Bitte Papier in den Einzug legen.");
        if (source?.toLowerCase().includes("duplex") && pages.length % 2 !== 0) {
            throw new Error("Der Duplex-Scan ist unvollständig: Zu einer Vorderseite fehlt die Rückseite.");
        }
        await reportProgress(`${pages.length} Seiten gescannt. Datei wird erstellt...`);
        return await createScanDocument(config, pages, outputPath, resolution, postprocess, profile);
    }
    catch (error) {
        const message = error instanceof Error ? error.message : String(error);
        throw new Error(`${message} Rohscans bleiben zur Wiederherstellung in ${jobDir}.`);
    }
};
", + "dist/scan/sane.js": "import { mkdir, mkdtemp, readdir, stat } from "node:fs/promises";
import path from "node:path";
import { commandExists, runCommand } from "../commands.js";
import { checkScanRuntime, createScanDocument } from "./postprocess.js";
const stringSetting = (settings, key) => {
    const value = settings[key];
    return typeof value === "string" && value.trim() ? value.trim() : undefined;
};
const booleanSetting = (settings, key, fallback) => {
    const value = settings[key];
    if (typeof value === "boolean")
        return value;
    if (typeof value === "string")
        return ["1", "true", "yes", "ja", "on"].includes(value.trim().toLowerCase());
    return fallback;
};
export const hasSane = () => commandExists("scanimage");
export const listScanners = async () => {
    if (!await hasSane())
        return [];
    // SANE also probes network backends; these can take more than ten seconds
    // even when the USB scanner is already available.
    const result = await runCommand("scanimage", ["-L"], { timeoutMs: 30_000 });
    if (result.code !== 0)
        return [];
    return result.stdout.split(/\r?\n/)
        .map((line) => line.trim().match(/^device `([^']+)'/)?.[1])
        .filter((device) => Boolean(device));
};
export const runScan = async (config, job, reportProgress = async () => { }) => {
    if (!await hasSane())
        throw new Error("scanimage ist nicht installiert oder nicht im PATH");
    const settings = job.settings || {};
    const format = stringSetting(settings, "format") || config.scanFormat;
    if (!["pdf", "png", "tiff"].includes(format))
        throw new Error("Scan-Format muss PDF, PNG oder TIFF sein");
    const resolution = Number(settings.resolution ?? config.scanResolution);
    if (!Number.isFinite(resolution) || resolution < 75 || resolution > 1200) {
        throw new Error("Die Scan-Auflösung muss zwischen 75 und 1200 dpi liegen");
    }
    const mode = stringSetting(settings, "mode") || config.scanMode;
    const source = stringSetting(settings, "source") || config.scanSource;
    const scannerName = job.scannerName || config.scannerName;
    const paperSize = stringSetting(settings, "paperSize") || "auto";
    if (!["auto", "A4", "Letter"].includes(paperSize))
        throw new Error("Unbekanntes Papierformat");
    const batch = Boolean(source && /adf|document feeder/i.test(source));
    if (batch && format !== "pdf")
        throw new Error("Für Einzug- und Duplex-Scans bitte PDF als Format wählen");
    const postprocess = booleanSetting(settings, "postprocess", config.scanPostprocess);
    const profile = stringSetting(settings, "postprocessProfile") || config.postprocessProfile;
    if (!["document", "receipt", "raw"].includes(profile))
        throw new Error("Unbekanntes Nachbearbeitungsprofil");
    await checkScanRuntime(config, postprocess);
    // Each physical scan has its own directory. A filename cannot escape it or overwrite another job.
    await mkdir(config.workDir, { recursive: true, mode: 0o700 });
    const jobDir = await mkdtemp(path.join(path.resolve(config.workDir), "scan-"));
    const requested = path.basename((job.requestedFilename || "scan").replace(/\\/g, "/"));
    const stem = requested.replace(/\.[^.]*$/, "").replace(/[\x00-\x1f]/g, "").trim() || "scan";
    const outputPath = path.join(jobDir, `${stem}.${format}`);
    try {
        // Device/source come first: changing source can change the remaining SANE options.
        const args = [];
        if (scannerName)
            args.push("--device-name", scannerName);
        if (source)
            args.push("--source", source);
        args.push("--mode", mode, "--resolution", String(resolution), "--format=png");
        if (paperSize !== "auto") {
            const [width, height] = paperSize === "A4" ? [210, 297] : [215.9, 279.4];
            if (scannerName?.startsWith("fujitsu:")) {
                args.push("--page-width", String(width), "--page-height", String(height));
            }
            args.push("-l", "0", "-t", "0", "-x", String(width), "-y", String(height));
        }
        if (batch) {
            // Relative pattern avoids interpreting '%' in a user-configured work directory.
            args.push("--batch=page-%06d.png", "--batch-start=1", "--batch-increment=1");
        }
        else {
            args.push("--output-file", "page-000001.png");
        }
        await reportProgress(batch ? "Dokumente werden eingezogen und gescannt..." : "Seite wird gescannt...");
        const result = await runCommand("scanimage", args, {
            cwd: jobDir,
            timeoutMs: config.scanTimeoutSeconds * 1000,
        });
        // SANE_STATUS_NO_DOCS (7) is the expected end of an unlimited ADF batch.
        // Never turn paper jams, I/O errors or canceled scans into a successful partial upload.
        if (result.code !== 0 && !(batch && result.code === 7)) {
            throw new Error(result.stderr.trim() || `scanimage wurde mit Code ${result.code} beendet`);
        }
        const names = (await readdir(jobDir))
            .filter((name) => /^page-\d+\.png$/.test(name))
            .sort((a, b) => Number(a.match(/\d+/)[0]) - Number(b.match(/\d+/)[0]));
        const pages = [];
        for (const [index, name] of names.entries()) {
            const page = path.join(jobDir, name);
            // Some scanimage versions leave a zero-byte file for the final NO_DOCS attempt.
            if ((await stat(page)).size === 0) {
                if (batch && result.code === 7 && index === names.length - 1)
                    continue;
                throw new Error(`Unvollständige Scan-Seite: ${name}`);
            }
            if (Number(name.match(/\d+/)[0]) !== index + 1)
                throw new Error("Im Scan fehlen Seiten");
            pages.push(page);
        }
        if (!pages.length)
            throw new Error("Keine Seiten gescannt. Bitte Papier in den Einzug legen.");
        if (source?.toLowerCase().includes("duplex") && pages.length % 2 !== 0) {
            throw new Error("Der Duplex-Scan ist unvollständig: Zu einer Vorderseite fehlt die Rückseite.");
        }
        await reportProgress(`${pages.length} Seiten gescannt. Datei wird erstellt...`);
        return await createScanDocument(config, pages, outputPath, resolution, postprocess, profile);
    }
    catch (error) {
        const message = error instanceof Error ? error.message : String(error);
        throw new Error(`${message} Rohscans bleiben zur Wiederherstellung in ${jobDir}.`);
    }
};
", "dist/types.js": "ZXhwb3J0IHt9Owo=", "scripts/scan_document.py": "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", "scripts/opencv_postprocess.py": "#!/usr/bin/env python3
import argparse
import math
from pathlib import Path

import cv2
import numpy as np
from PIL import Image


def order_points(points):
    rect = np.zeros((4, 2), dtype="float32")
    point_sum = points.sum(axis=1)
    point_diff = np.diff(points, axis=1)

    rect[0] = points[np.argmin(point_sum)]
    rect[2] = points[np.argmax(point_sum)]
    rect[1] = points[np.argmin(point_diff)]
    rect[3] = points[np.argmax(point_diff)]
    return rect


def four_point_transform(image, points):
    rect = order_points(points)
    top_left, top_right, bottom_right, bottom_left = rect

    width_a = np.linalg.norm(bottom_right - bottom_left)
    width_b = np.linalg.norm(top_right - top_left)
    max_width = int(max(width_a, width_b))

    height_a = np.linalg.norm(top_right - bottom_right)
    height_b = np.linalg.norm(top_left - bottom_left)
    max_height = int(max(height_a, height_b))

    destination = np.array([
        [0, 0],
        [max_width - 1, 0],
        [max_width - 1, max_height - 1],
        [0, max_height - 1],
    ], dtype="float32")

    matrix = cv2.getPerspectiveTransform(rect, destination)
    return cv2.warpPerspective(image, matrix, (max_width, max_height), borderValue=(255, 255, 255))


def rotate_bound(image, angle):
    height, width = image.shape[:2]
    center = (width / 2, height / 2)
    matrix = cv2.getRotationMatrix2D(center, angle, 1.0)
    cos = abs(matrix[0, 0])
    sin = abs(matrix[0, 1])

    new_width = int((height * sin) + (width * cos))
    new_height = int((height * cos) + (width * sin))

    matrix[0, 2] += (new_width / 2) - center[0]
    matrix[1, 2] += (new_height / 2) - center[1]

    return cv2.warpAffine(image, matrix, (new_width, new_height), borderValue=(255, 255, 255))


def deskew_by_text_angle(image):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    inverted = cv2.bitwise_not(gray)
    threshold = cv2.threshold(inverted, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
    coordinates = np.column_stack(np.where(threshold > 0))

    if len(coordinates) < 500:
        return image

    angle = cv2.minAreaRect(coordinates)[-1]
    if angle < -45:
        angle = -(90 + angle)
    else:
        angle = -angle

    if abs(angle) < 0.2 or abs(angle) > 8:
        return image

    return rotate_bound(image, angle)


def find_document_contour(image, profile):
    ratio = image.shape[0] / 900.0
    resized = cv2.resize(image, (int(image.shape[1] / ratio), 900))
    gray = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY)
    gray = cv2.GaussianBlur(gray, (5, 5), 0)

    edges = cv2.Canny(gray, 45, 140)
    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (7, 7))
    edges = cv2.morphologyEx(edges, cv2.MORPH_CLOSE, kernel)

    contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    contours = sorted(contours, key=cv2.contourArea, reverse=True)[:8]

    min_area = resized.shape[0] * resized.shape[1] * (0.03 if profile == "receipt" else 0.12)

    for contour in contours:
        if cv2.contourArea(contour) < min_area:
            continue

        perimeter = cv2.arcLength(contour, True)
        approx = cv2.approxPolyDP(contour, 0.025 * perimeter, True)
        if len(approx) == 4:
            return approx.reshape(4, 2) * ratio

    return None


def trim_light_border(image):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    mask = cv2.threshold(gray, 245, 255, cv2.THRESH_BINARY_INV)[1]
    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (9, 9))
    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)

    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    if not contours:
        return image

    contour = max(contours, key=cv2.contourArea)
    if cv2.contourArea(contour) < image.shape[0] * image.shape[1] * 0.02:
        return image

    x, y, width, height = cv2.boundingRect(contour)
    padding = max(12, int(min(width, height) * 0.025))
    x = max(0, x - padding)
    y = max(0, y - padding)
    width = min(image.shape[1] - x, width + padding * 2)
    height = min(image.shape[0] - y, height + padding * 2)
    return image[y:y + height, x:x + width]


def enhance_receipt(image):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
    gray = clahe.apply(gray)
    gray = cv2.fastNlMeansDenoising(gray, None, 8, 7, 21)
    gray = cv2.normalize(gray, None, 0, 255, cv2.NORM_MINMAX)
    return cv2.cvtColor(gray, cv2.COLOR_GRAY2BGR)


def enhance_document(image):
    lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
    l_channel, a_channel, b_channel = cv2.split(lab)
    clahe = cv2.createCLAHE(clipLimit=1.6, tileGridSize=(8, 8))
    l_channel = clahe.apply(l_channel)
    return cv2.cvtColor(cv2.merge((l_channel, a_channel, b_channel)), cv2.COLOR_LAB2BGR)


def auto_rotate_profile(image, profile):
    height, width = image.shape[:2]

    if profile == "receipt" and width > height:
        return cv2.rotate(image, cv2.ROTATE_90_CLOCKWISE)

    return image


def postprocess(input_path, output_path, profile):
    image = cv2.imread(str(input_path), cv2.IMREAD_COLOR)
    if image is None:
        raise RuntimeError(f"OpenCV konnte {input_path} nicht lesen")

    contour = find_document_contour(image, profile)
    if contour is not None:
        processed = four_point_transform(image, contour.astype("float32"))
    else:
        processed = trim_light_border(image)

    processed = deskew_by_text_angle(processed)
    processed = trim_light_border(processed)
    processed = auto_rotate_profile(processed, profile)

    if profile == "receipt":
        processed = enhance_receipt(processed)
    elif profile != "raw":
        processed = enhance_document(processed)

    save_output(processed, output_path)


def save_output(image, output_path):
    suffix = output_path.suffix.lower()

    if suffix == ".pdf":
        rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        pil_image = Image.fromarray(rgb)
        if pil_image.mode != "RGB":
            pil_image = pil_image.convert("RGB")
        pil_image.save(output_path, "PDF", resolution=300.0)
        return

    if suffix in {".jpg", ".jpeg"}:
        cv2.imwrite(str(output_path), image, [cv2.IMWRITE_JPEG_QUALITY, 92])
        return

    if suffix == ".png":
        cv2.imwrite(str(output_path), image, [cv2.IMWRITE_PNG_COMPRESSION, 3])
        return

    if suffix in {".tif", ".tiff"}:
        cv2.imwrite(str(output_path), image)
        return

    raise RuntimeError(f"Nicht unterstütztes Ausgabeformat: {suffix}")


def main():
    parser = argparse.ArgumentParser(description="FEDEO Scan-Nachbearbeitung mit OpenCV")
    parser.add_argument("--input", required=True)
    parser.add_argument("--output", required=True)
    parser.add_argument("--profile", default="document", choices=["document", "receipt", "raw"])
    args = parser.parse_args()

    postprocess(Path(args.input), Path(args.output), args.profile)


if __name__ == "__main__":
    main()
",