id2pdf 0.1.0__py3-none-any.whl

id2pdf/__init__.py

@@ -0,0 +1,33 @@
+"""Scan both sides of an ID card onto one A4 page, as a PDF.
+
+The card may lie anywhere on the scanner glass: a quick scan of the whole glass finds it,
+then only that spot is scanned at full resolution, straightened and cut out.
+"""
+
+from .detect import CARD_MM, card_from_image, cut_out, find_cards
+from .i18n import set_language
+from .layout import CARD_DPI, IMAGE_SUFFIXES, PAGE_DPI, id_card_page, images_to_pdf, open_image, save_pdf
+from .scanner import ScanError, find_scanner, scan, scan_card_side, scan_id_card, scan_pages
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "CARD_DPI",
+    "CARD_MM",
+    "IMAGE_SUFFIXES",
+    "PAGE_DPI",
+    "ScanError",
+    "card_from_image",
+    "cut_out",
+    "find_cards",
+    "find_scanner",
+    "id_card_page",
+    "images_to_pdf",
+    "open_image",
+    "save_pdf",
+    "scan",
+    "scan_card_side",
+    "scan_id_card",
+    "scan_pages",
+    "set_language",
+]

id2pdf/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

id2pdf/cli.py

@@ -0,0 +1,71 @@
+"""The id2pdf command."""
+
+import argparse
+import sys
+from pathlib import Path
+
+from . import __version__
+from .detect import card_from_image
+from .i18n import _
+from .layout import CARD_DPI, id_card_page, open_image, save_pdf
+from .scanner import ScanError, diagnose, find_scanner, scan_id_card, scan_pages
+
+
+def parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="id2pdf",
+        description=_(
+            "Scan both sides of an ID card onto one A4 page, as a PDF. The card may lie "
+            "anywhere on the scanner glass; it is found, straightened and cut out."
+        ),
+    )
+    p.add_argument("output", type=Path, nargs="?", help=_("the PDF to write (with --diagnose: a folder for the scan)"))
+    mode = p.add_mutually_exclusive_group()
+    mode.add_argument(
+        "--images",
+        nargs=2,
+        type=Path,
+        metavar=("FRONT", "BACK"),
+        help=_("use existing scans or photos of the two sides instead of scanning"),
+    )
+    mode.add_argument("--pages", type=int, metavar="N", help=_("scan N plain A4 pages instead of a card"))
+    mode.add_argument(
+        "--diagnose", action="store_true", help=_("scan the glass and print what is found (numbers only)")
+    )
+    p.add_argument("--device", help=_("SANE device (default: the first scanner in 'scanimage -L')"))
+    p.add_argument("-f", "--force", action="store_true", help=_("overwrite the output without asking"))
+    p.add_argument("--version", action="version", version=f"id2pdf {__version__}")
+    return p
+
+
+def main(argv: list[str] | None = None) -> None:
+    args = parser().parse_args(argv)
+    if not args.output and not args.diagnose:
+        parser().error(_("the output PDF is required"))
+    if args.output and args.output.exists() and not args.diagnose and not args.force:
+        answer = input(_("{path} already exists. Overwrite? [y/N] ").format(path=args.output)).strip().lower()
+        if answer not in (_("y"), "y"):
+            sys.exit(_("Nothing was changed."))
+    try:
+        if args.images:
+            sides = [card_from_image(open_image(path)) for path in args.images]
+            save_pdf([id_card_page(*sides)], args.output, CARD_DPI)
+        else:
+            device = args.device or find_scanner()
+            print(_("Scanner: {device}").format(device=device))
+            if args.diagnose:
+                diagnose(device, args.output)
+                return
+            if args.pages:
+                save_pdf(scan_pages(device, args.pages), args.output)
+            else:
+                save_pdf([scan_id_card(device)], args.output, CARD_DPI)
+    except ScanError as error:
+        sys.exit(str(error))
+    except (EOFError, KeyboardInterrupt):
+        sys.exit("\n" + _("Cancelled, nothing was saved."))
+    print(_("Saved: {path}").format(path=args.output))
+
+
+if __name__ == "__main__":
+    main()

id2pdf/detect.py

@@ -0,0 +1,173 @@
+"""Finding ID-1 cards (85.6 x 54 mm: ID cards, driving licences, ...) on scans."""
+
+import cv2
+import numpy as np
+from PIL import Image, ImageDraw
+
+CARD_MM = (85.6, 54.0)
+CARD_CORNER_MM = 3.18
+PREVIEW_DPI = 100  # quick scan of the whole glass to find the card
+DARKER = 15  # grey levels below the lid that count as part of a card (the lid's shading is less)
+GLASS_EDGE_MM = 2  # strip along the edges of the glass ignored when looking for the card
+
+Rect = tuple[tuple[float, float], tuple[float, float], float]  # cv2.minAreaRect: centre, size, angle
+
+# Why card_candidates() did not take an object for a card.
+SHAPE, SIZE, TOO_SMALL = "shape", "size", "too small"
+
+
+def mm_to_px(mm: float, dpi: float) -> int:
+    return round(mm / 25.4 * dpi)
+
+
+def px_to_mm(px: float, dpi: float) -> float:
+    return px / dpi * 25.4
+
+
+def card_candidates(image: Image.Image, dpi: float | None, glass: bool = False) -> list[tuple[Rect, str]]:
+    """Every object on a scan with why it is not a card ("" = it is one), largest first.
+
+    A card shows as sharp edges (its outline and shadow, its print) and areas clearly darker
+    than the lid; the lid's shading is gradual and only slightly darker, and dust is too
+    small to make a card shape. glass: the image is the whole glass, whose edges are ignored.
+    dpi None skips the size check (photos).
+    """
+    gray = cv2.cvtColor(np.array(image.convert("RGB")), cv2.COLOR_RGB2GRAY)
+    smooth = cv2.GaussianBlur(gray, (5, 5), 0)
+    lid = float(np.median(gray))
+    mask = ((cv2.Canny(smooth, 20, 60) > 0) | (smooth < lid - DARKER)).astype(np.uint8) * 255
+    if glass:
+        edge = mm_to_px(GLASS_EDGE_MM, dpi or PREVIEW_DPI)
+        mask[:edge, :] = mask[-edge:, :] = 0
+        mask[:, :edge] = mask[:, -edge:] = 0
+    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, np.ones((2, 2), np.uint8))
+    k = max(3, mm_to_px(1.5, dpi or PREVIEW_DPI))
+    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (k, k)))
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    found = []
+    for contour in contours:
+        rect = cv2.minAreaRect(cv2.convexHull(contour))
+        long, short = sorted(rect[1], reverse=True)
+        if short < 10:
+            continue
+        reason = ""
+        # A thick card lifts the lid: its shadow makes the object up to ~10 mm larger all round.
+        if abs(long / short - CARD_MM[0] / CARD_MM[1]) > 0.25:
+            reason = SHAPE
+        elif dpi is not None and not 0.85 < long / mm_to_px(CARD_MM[0], dpi) < 1.45:
+            reason = SIZE
+        elif dpi is None and long * short < 0.05 * gray.size:
+            reason = TOO_SMALL
+        found.append((rect, reason))
+    return sorted(found, key=lambda c: -c[0][1][0] * c[0][1][1])
+
+
+def perimeter(width: float, height: float, corner: float, spacing: float) -> list[tuple[np.ndarray, np.ndarray]]:
+    """For each straight side of a width x height rectangle centred on 0: its points and normal."""
+    xs = np.arange(-width / 2 + corner, width / 2 - corner, spacing)
+    ys = np.arange(-height / 2 + corner, height / 2 - corner, spacing)
+    return [
+        (np.stack([xs, np.full_like(xs, -height / 2)], 1), np.array([0.0, 1.0])),
+        (np.stack([xs, np.full_like(xs, height / 2)], 1), np.array([0.0, 1.0])),
+        (np.stack([np.full_like(ys, -width / 2), ys], 1), np.array([1.0, 0.0])),
+        (np.stack([np.full_like(ys, width / 2), ys], 1), np.array([1.0, 0.0])),
+    ]
+
+
+def fit_card(gray: np.ndarray, blob: Rect, dpi: float) -> Rect:
+    """The card inside an object found on the scan, which may include the card's shadow.
+
+    Places a card-sized rectangle (within 3 %) on the sharpest edges near the object: the
+    card's edge is a sharp step, its shadow a soft one. Every side has to lie on an edge, so
+    the score is the weakest side's mean sharpness across it, blurred a little so that a
+    slightly misplaced edge still counts. The angle comes from the object, whose shadow is
+    about even all round; on edges alone it is poorly determined.
+    """
+    smooth = cv2.GaussianBlur(gray, (3, 3), 0).astype(np.float32)
+    sigma = max(1.0, mm_to_px(0.3, dpi))
+    across_x = cv2.GaussianBlur(np.abs(cv2.Sobel(smooth, cv2.CV_32F, 1, 0)), (0, 0), sigma)
+    across_y = cv2.GaussianBlur(np.abs(cv2.Sobel(smooth, cv2.CV_32F, 0, 1)), (0, 0), sigma)
+    card_w, card_h = (mm_to_px(mm, dpi) for mm in CARD_MM)
+    corner = mm_to_px(CARD_CORNER_MM + 0.5, dpi)
+    spacing = max(1.0, dpi / 100)
+    (cx, cy), (w, h), angle = blob
+    if w < h:
+        w, h, angle = h, w, angle + 90
+    angle = (angle + 90) % 180 - 90
+    rows, cols = gray.shape
+
+    def best(angles, xs, ys, scales):
+        top = (-1.0, cx, cy, angle, 1.0, 1.0)
+        for a in angles:
+            t = np.deg2rad(a)
+            turn = np.array([[np.cos(t), -np.sin(t)], [np.sin(t), np.cos(t)]])
+            for sx in scales:
+                for sy in scales:
+                    weakest = None
+                    for points, normal in perimeter(card_w * sx, card_h * sy, corner, spacing):
+                        r = points @ turn.T
+                        nx, ny = np.abs(turn @ normal)
+                        gx = np.clip(np.rint(xs[:, None, None] + r[None, None, :, 0]).astype(int), 0, cols - 1)
+                        gy = np.clip(np.rint(ys[None, :, None] + r[None, None, :, 1]).astype(int), 0, rows - 1)
+                        side = (across_x[gy, gx] * nx + across_y[gy, gx] * ny).mean(axis=2)
+                        weakest = side if weakest is None else np.minimum(weakest, side)
+                    i, j = np.unravel_index(np.argmax(weakest), weakest.shape)
+                    if weakest[i, j] > top[0]:
+                        top = (float(weakest[i, j]), float(xs[i]), float(ys[j]), float(a), sx, sy)
+        return top
+
+    step = max(1, mm_to_px(0.5, dpi))
+    span_x = max(0.0, (w - card_w) / 2) + mm_to_px(2, dpi)
+    span_y = max(0.0, (h - card_h) / 2) + mm_to_px(2, dpi)
+    _, x, y, a, _, _ = best(
+        np.array([angle]),
+        np.arange(cx - span_x, cx + span_x + 1, step),
+        np.arange(cy - span_y, cy + span_y + 1, step),
+        (1.0,),
+    )
+    fine = max(1.0, step / 3)
+    _, x, y, a, sx, sy = best(
+        np.arange(a - 0.5, a + 0.51, 0.25),
+        np.arange(x - step, x + step + 1, fine),
+        np.arange(y - step, y + step + 1, fine),
+        np.arange(0.97, 1.031, 0.01),
+    )
+    return (x, y), (card_w * sx, card_h * sy), a
+
+
+def find_cards(image: Image.Image, dpi: float | None, glass: bool = False) -> list[Rect]:
+    """Cards on a scan, largest first; with a known dpi each is fitted to the card's real edges."""
+    blobs = [rect for rect, reason in card_candidates(image, dpi, glass) if not reason]
+    if dpi is None:
+        return blobs
+    gray = np.array(image.convert("L"))
+    return [fit_card(gray, blob, dpi) for blob in blobs]
+
+
+def cut_out(image: Image.Image, rect: Rect) -> Image.Image:
+    """The card straightened (long side horizontal), with white at its rounded corners."""
+    (cx, cy), (w, h), angle = rect
+    if w < h:  # make the angle the one of the long side
+        w, h, angle = h, w, angle + 90
+    angle = (angle + 90) % 180 - 90  # the smallest turn that makes the long side horizontal
+    turn = cv2.getRotationMatrix2D((cx, cy), angle, 1.0)
+    turn[0, 2] += w / 2 - cx
+    turn[1, 2] += h / 2 - cy
+    card = cv2.warpAffine(
+        np.array(image.convert("RGB")),
+        turn,
+        (round(w), round(h)),
+        flags=cv2.INTER_CUBIC,
+        borderValue=(255, 255, 255),
+    )
+    card = Image.fromarray(card)
+    outline = Image.new("L", card.size, 0)
+    radius = round(CARD_CORNER_MM / CARD_MM[1] * card.height)
+    ImageDraw.Draw(outline).rounded_rectangle((0, 0, card.width - 1, card.height - 1), radius=radius, fill=255)
+    return Image.composite(card, Image.new("RGB", card.size, "white"), outline)
+
+
+def card_from_image(image: Image.Image, dpi: float | None = None) -> Image.Image:
+    """The card cut out of a scan or photo, or the image as it is if no card is found."""
+    cards = find_cards(image, dpi)
+    return cut_out(image, cards[0]) if cards else image

id2pdf/i18n.py

@@ -0,0 +1,23 @@
+"""Translations of the messages (gettext, domain "id2pdf").
+
+The language follows the usual environment variables (LANGUAGE, LC_ALL, LC_MESSAGES,
+LANG); a program that uses id2pdf as a library can pick one with set_language().
+"""
+
+import gettext
+from pathlib import Path
+
+LOCALE_DIR = Path(__file__).parent / "locale"
+
+_translation: gettext.NullTranslations = gettext.translation("id2pdf", LOCALE_DIR, fallback=True)
+
+
+def set_language(language: str | None) -> None:
+    """Use this language ("hr", "en", ...); None goes back to the environment's."""
+    global _translation
+    languages = [language] if language else None
+    _translation = gettext.translation("id2pdf", LOCALE_DIR, languages=languages, fallback=True)
+
+
+def _(message: str) -> str:
+    return _translation.gettext(message)

id2pdf/layout.py

@@ -0,0 +1,49 @@
+"""Putting cards and pages into a PDF."""
+
+from pathlib import Path
+
+from PIL import Image, ImageOps
+
+from .detect import CARD_MM, mm_to_px
+
+CARD_DPI = 300
+PAGE_DPI = 200  # enough for documents, keeps a page around 1 MB
+A4_MM = (210, 297)
+GAP_MM = 15
+IMAGE_SUFFIXES = {".jpg", ".jpeg", ".png", ".webp", ".tif", ".tiff", ".bmp"}
+
+
+def card_size(image: Image.Image) -> Image.Image:
+    """Scale to the real card size (landscape) so the printout is 1:1."""
+    if image.height > image.width:
+        image = image.rotate(90, expand=True)
+    return ImageOps.contain(image, (mm_to_px(CARD_MM[0], CARD_DPI), mm_to_px(CARD_MM[1], CARD_DPI)))
+
+
+def id_card_page(front: Image.Image, back: Image.Image) -> Image.Image:
+    """Both sides on one A4 page, at real size like a photocopy."""
+    front, back = card_size(front), card_size(back)
+    page = Image.new("RGB", (mm_to_px(A4_MM[0], CARD_DPI), mm_to_px(A4_MM[1], CARD_DPI)), "white")
+    gap = mm_to_px(GAP_MM, CARD_DPI)
+    top = (page.height - front.height - gap - back.height) // 3  # a bit above the middle
+    for image, y in ((front, top), (back, top + front.height + gap)):
+        page.paste(image, ((page.width - image.width) // 2, y))
+    return page
+
+
+def save_pdf(images: list[Image.Image], output: Path, dpi: int = PAGE_DPI) -> None:
+    output.parent.mkdir(parents=True, exist_ok=True)
+    first, *rest = images
+    first.save(output, "PDF", resolution=dpi, save_all=True, append_images=rest, quality=85)
+
+
+def open_image(path: Path) -> Image.Image:
+    """An image file, turned the way the camera's EXIF data says."""
+    return ImageOps.exif_transpose(Image.open(path)).convert("RGB")
+
+
+def images_to_pdf(paths: list[Path], output: Path) -> None:
+    """Photos or scans from elsewhere into one PDF, one image per page."""
+    images = [open_image(p) for p in paths]
+    longest = max(max(i.size) for i in images)
+    save_pdf(images, output, dpi=max(72, round(longest / (A4_MM[1] / 25.4))))

id2pdf/locale/hr/LC_MESSAGES/id2pdf.po

@@ -0,0 +1,210 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the id2pdf package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: id2pdf\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2026-10-18 19:52+0200\n"
+"PO-Revision-Date: 2026-10-18 20:00+0200\n"
+"Last-Translator: anaisoob <anaisoob@tutamail.com>\n"
+"Language-Team: Croatian\n"
+"Language: hr\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && "
+"n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
+
+#: src/id2pdf/cli.py:18
+msgid ""
+"Scan both sides of an ID card onto one A4 page, as a PDF. The card may lie "
+"anywhere on the scanner glass; it is found, straightened and cut out."
+msgstr ""
+"Skenira obje strane osobne iskaznice na jednu A4 stranicu, kao PDF. Osobna "
+"može ležati bilo gdje na staklu skenera; skripta je pronađe, izravna i "
+"izreže."
+
+#: src/id2pdf/cli.py:22
+msgid "the PDF to write (with --diagnose: a folder for the scan)"
+msgstr "PDF koji se sprema (uz --diagnose: mapa za sken)"
+
+#: src/id2pdf/cli.py:29
+msgid "use existing scans or photos of the two sides instead of scanning"
+msgstr ""
+"koristi postojeće skenove ili fotografije obiju strana umjesto skeniranja"
+
+#: src/id2pdf/cli.py:31
+msgid "scan N plain A4 pages instead of a card"
+msgstr "skenira N običnih A4 stranica umjesto kartice"
+
+#: src/id2pdf/cli.py:33
+msgid "scan the glass and print what is found (numbers only)"
+msgstr "skenira staklo i ispiše što je pronađeno (samo brojevi)"
+
+#: src/id2pdf/cli.py:35
+msgid "SANE device (default: the first scanner in 'scanimage -L')"
+msgstr "SANE uređaj (zadano: prvi skener iz 'scanimage -L')"
+
+#: src/id2pdf/cli.py:36
+msgid "overwrite the output without asking"
+msgstr "zamijeni postojeću datoteku bez pitanja"
+
+#: src/id2pdf/cli.py:44
+msgid "the output PDF is required"
+msgstr "potreban je izlazni PDF"
+
+#: src/id2pdf/cli.py:46
+#, python-brace-format
+msgid "{path} already exists. Overwrite? [y/N] "
+msgstr "{path} već postoji. Zamijeniti? [d/N] "
+
+#: src/id2pdf/cli.py:47
+msgid "y"
+msgstr "d"
+
+#: src/id2pdf/cli.py:48
+msgid "Nothing was changed."
+msgstr "Ništa nije promijenjeno."
+
+#: src/id2pdf/cli.py:55
+#, python-brace-format
+msgid "Scanner: {device}"
+msgstr "Skener: {device}"
+
+#: src/id2pdf/cli.py:66
+msgid "Cancelled, nothing was saved."
+msgstr "Prekinuto, ništa nije spremljeno."
+
+#: src/id2pdf/cli.py:67
+#, python-brace-format
+msgid "Saved: {path}"
+msgstr "Spremljeno: {path}"
+
+#: src/id2pdf/scanner.py:34
+msgid "The scanimage command is missing (package sane)."
+msgstr "Nema naredbe scanimage (paket sane)."
+
+#: src/id2pdf/scanner.py:36
+msgid "'scanimage -L' failed:"
+msgstr "'scanimage -L' nije uspio:"
+
+#: src/id2pdf/scanner.py:40
+msgid "No scanner found. Check 'scanimage -L'."
+msgstr "Skener nije pronađen. Provjerite 'scanimage -L'."
+
+#: src/id2pdf/scanner.py:57
+msgid "The scanner is still busy, trying again..."
+msgstr "Skener je još zauzet, pokušavam ponovno..."
+
+#: src/id2pdf/scanner.py:60
+msgid "Scanning failed:"
+msgstr "Skeniranje nije uspjelo:"
+
+#: src/id2pdf/scanner.py:65
+msgid "Then press Enter (Ctrl+C to cancel) "
+msgstr "Zatim pritisnite Enter (Ctrl+C za prekid) "
+
+#: src/id2pdf/scanner.py:71
+msgid ""
+"Put the card on the glass front side down, anywhere (text upright), and "
+"close the lid."
+msgstr ""
+"Stavite osobnu prednjom stranom prema staklu, bilo gdje (tekst uspravno), i "
+"zatvorite poklopac."
+
+#: src/id2pdf/scanner.py:73
+msgid ""
+"Put the card on the glass back side down, anywhere (text upright), and close "
+"the lid."
+msgstr ""
+"Stavite osobnu stražnjom stranom prema staklu, bilo gdje (tekst uspravno), i "
+"zatvorite poklopac."
+
+#: src/id2pdf/scanner.py:75
+msgid "Looking for the card on the glass..."
+msgstr "Tražim osobnu na staklu..."
+
+#: src/id2pdf/scanner.py:80
+msgid ""
+"No card found. Put it away from the edge of the glass, flat, and close the "
+"lid."
+msgstr ""
+"Osobna nije pronađena. Stavite je dalje od ruba stakla, ravno, i zatvorite "
+"poklopac."
+
+#: src/id2pdf/scanner.py:82
+msgid "There is more than one card on the glass, taking the largest."
+msgstr "Na staklu je više kartica, uzimam najveću."
+
+#: src/id2pdf/scanner.py:91
+msgid "Scanning the card..."
+msgstr "Skeniram osobnu..."
+
+#: src/id2pdf/scanner.py:118
+#, python-brace-format
+msgid "Put page {n} of {pages} face down on the glass and close the lid."
+msgstr ""
+"Stavite {n}. od {pages} stranica licem prema staklu i zatvorite poklopac."
+
+#: src/id2pdf/scanner.py:119
+msgid "Scanning..."
+msgstr "Skeniram..."
+
+#: src/id2pdf/scanner.py:126
+msgid "Put the card on the glass as usual and close the lid."
+msgstr "Stavite osobnu na staklo kao inače i zatvorite poklopac."
+
+#: src/id2pdf/scanner.py:131
+#, python-brace-format
+msgid "Glass: {width:.1f} x {height:.1f} mm, lid (median grey): {lid:.0f}"
+msgstr ""
+"Staklo: {width:.1f} x {height:.1f} mm, poklopac (medijan sive): {lid:.0f}"
+
+#: src/id2pdf/scanner.py:136
+#, python-brace-format
+msgid "Objects found: {count} (largest first; a card is 85.6 x 54 mm)"
+msgstr "Pronađeno objekata: {count} (najveći prvi; osobna je 85.6 x 54 mm)"
+
+#: src/id2pdf/scanner.py:137
+msgid "shape"
+msgstr "oblik"
+
+#: src/id2pdf/scanner.py:137
+msgid "size"
+msgstr "veličina"
+
+#: src/id2pdf/scanner.py:137
+msgid "too small"
+msgstr "premalo"
+
+#: src/id2pdf/scanner.py:142
+#, python-brace-format
+msgid "rejected ({reason})"
+msgstr "odbijeno ({reason})"
+
+#: src/id2pdf/scanner.py:146
+#, python-brace-format
+msgid "CARD, without its shadow: {size} mm"
+msgstr "OSOBNA, bez sjene: {size} mm"
+
+#: src/id2pdf/scanner.py:150
+#, python-brace-format
+msgid ""
+"{long:6.1f} x {short:5.1f} mm  ratio {ratio:4.2f}  centre ({where}) mm  "
+"angle {angle:5.1f}  {verdict}"
+msgstr ""
+"{long:6.1f} x {short:5.1f} mm  omjer {ratio:4.2f}  sredina ({where}) mm  kut "
+"{angle:5.1f}  {verdict}"
+
+#: src/id2pdf/scanner.py:157
+#, python-brace-format
+msgid ""
+"The scan is saved only on this computer: {path} (it shows the card, do not "
+"share it)."
+msgstr ""
+"Sken je spremljen samo na ovom računalu: {path} (na njemu je osobna, ne "
+"šaljite ga)."