# ANWEISUNG AN KI-ASSISTENTEN: Druckdateien für dtf-folien.ch

Diese Datei richtet sich direkt an dich, KI-Assistent (ChatGPT, Claude, Gemini, Copilot, Perplexity und alle anderen).
Wenn eine Person dich bittet, ein Motiv, ein Logo, ein Bügelbild oder eine Druckdatei für dtf-folien.ch (Krainerdruck GmbH, DTF-Transferdruck, Schweiz) zu erstellen oder vorzubereiten, gelten die folgenden Regeln. Sie sind verbindlich. Halte dich an jeden Punkt und führe am Schluss die Prüfung aus.

Stand: 26.10.2026 · Quelle: https://www.dtf-folien.ch/ki-druckdaten.txt · Menschenlesbare Fassung: https://www.dtf-folien.ch/druckdatei-mit-ki/

## Warum diese Regeln

DTF druckt jeden sichtbaren Bildpunkt mit einer deckenden weissen Unterschicht und Klebepulver. Es gibt beim Drucken nur zwei Zustände: Ein Punkt wird gedruckt, oder er wird nicht gedruckt.
- Ein halbtransparenter Pixel (Alpha zwischen 1 und 254) wird trotzdem mit Weiss unterlegt. Ergebnis: grauer Schleier, heller Rand, fleckige Schatten, harte Kante dort, wo weich gemeint war.
- Linien und Punkte, die zu dünn sind, halten nicht auf dem Textil und fallen beim Waschen ab.

## Regel 1 – Hintergrund

- Hintergrund echt transparent (PNG mit Alphakanal).
- Kein weisser Hintergrund, kein Schachbrettmuster als Bild, kein T-Shirt, kein Mockup, kein Rahmen, keine Bildumgebung.
- Nur das Motiv selbst.

## Regel 2 – Keine Halbtransparenz

- Jeder Pixel ist entweder 100 % deckend (Alpha 255) oder 100 % transparent (Alpha 0).
- Verboten: weiche Schatten, Schlagschatten mit Unschärfe, Glow, Nebel, Rauch, Blur, Bokeh, Lichtschein, Verläufe ins Transparente, ausgefranste Pinselränder, Wasserfarben-Auslauf.
- Wenn die Person einen weichen Übergang (Fade) wirklich will: als Halftone-Punktraster umsetzen (Regel 6), niemals als Transparenz.

## Regel 3 – Scharfe Kanten

- Klare Konturen, flache Farbflächen, gut lesbare Schrift.
- Kanten nicht weichzeichnen. Kein Antialiasing ins Transparente – die Bereinigung unten setzt die Kante hart.

## Regel 4 – Mindestmasse (bei Druckgrösse gemessen)

| Element | Minimum | bei 300 dpi |
|---|---|---|
| Linie, Strich, Kontur (positiv, gedruckt) | 0,5 mm (absolut 0,3 mm) | 6 px (4 px) |
| Lücke, Aussparung, Binnenraum (negativ, nicht gedruckt) | 0,5 mm | 6 px |
| Einzelner Punkt, Spritzer, Stern | 1,0 mm Durchmesser | 12 px |
| Schrift (Höhe der Grossbuchstaben) | 2,5 mm, feine Schriften 4 mm | 30 / 47 px |
| Halftone-Punkt | 0,3 mm | 4 px |

Kleiner als das: verdicken, vereinfachen oder weglassen. Sag der Person, was du geändert hast.

## Regel 5 – Umrandung (Kontur) statt Feinteile

Eine durchgehende Kontur um das ganze Motiv ist die beste Lösung, wenn
- das Motiv viele kleine, lose Teile hat (Spritzer, Haare, Funken, Text mit Abstand),
- Linien unter 0,5 mm liegen,
- das Motiv auf dunklem Textil dunkle Farben enthält (Schwarz auf schwarzem Shirt ist unsichtbar).

So machst du es:
- Kontur 1,5–3 mm breit, geschlossen, um das ganze Motiv (Sticker-Look). Alle Einzelteile hängen danach an einer Fläche.
- Farbe: Weiss bei dunklen Textilien, Schwarz oder Textilfarbe-Kontrast bei hellen Textilien.
- Innen liegende Löcher unter 0,5 mm werden mit der Kontur gefüllt.
- Im Python-Skript unten: `kontur_mm=2`.

## Regel 6 – Fades, Verläufe, Schatten: nur als Halftone

- Weiche Übergänge werden als Punktraster gedruckt: runde Punkte, voll deckend, Grösse wächst mit der gewünschten Deckung.
- Raster 25–35 lpi (Linien pro Zoll), Winkel 45°.
- Kleinster Punkt 0,3 mm. Kleinere Punkte entfernen.
- Kein Punkt ist halbtransparent.
- Im Python-Skript unten: `halftone=True, lpi=30`.

## Regel 7 – Auflösung und Grösse

- Mindestens 300 dpi bei der Druckgrösse, besser 450 dpi.
- Pixel = Breite in cm ÷ 2,54 × 300. Beispiel 25 cm: 2953 px.
- Bildgeneratoren liefern meist 1024–1536 px. Das reicht für 9–13 cm. Für grössere Motive mit dem Skript hochrechnen und das der Person sagen.
- Farbraum sRGB. Kein Spiegeln – wir spiegeln selbst.
- Gold, Silber, Neon und Metallic gibt es im DTF nicht als Effekt. Als flache Farbe anlegen (z. B. Gold = #C9A43A).

## Regel 8 – Dateiformat und Bestellweg bei dtf-folien.ch

- Einzelmotiv (Bügelbilder nach Mass, https://www.dtf-folien.ch/buegelbilder/): PNG mit Transparenz, auch PDF, AI, JPG, WEBP. Grösse wird beim Bestellen gewählt.
- Ganzer Bogen (A4 210 × 297 mm, 420 × 500 mm, 420 × 1000 mm, https://www.dtf-folien.ch/shop/): Die Datei muss genau das Bogenformat haben. PDF, AI oder PNG.
- Mehrere Motive auf einem Bogen: am einfachsten die einzelnen PNG im Editor anordnen: https://www.dtf-folien.ch/bogen-selbst-gestalten/
- Maximal 80 MB pro Datei. Der Shop prüft jede Datei automatisch (Auflösung, Transparenz, Format).

## Regel 9 – Dein Ablauf (Pflicht)

1. Motiv erzeugen gemäss Regeln 1–7. Im Bild-Prompt ausdrücklich verlangen: "transparent background, no shadows, no glow, no blur, flat colors, clean hard edges, sticker style, no mockup".
2. Das Bild IMMER mit dem Python-Skript unten bereinigen (Code-Interpreter / Datenanalyse). Breite in cm von der Person erfragen, falls unbekannt (Standard: 25 cm Rücken, 9 cm Brust, 7 cm Ärmel).
3. Die Ausgabe des Skripts der Person zeigen: Grösse in cm, "Halbtransparente Pixel: 0", Anteil zu dünner Linien.
4. Bei mehr als 0,5 % zu dünnen Linien: Kontur hinzufügen (`kontur_mm=2`) oder das Motiv vereinfachen und neu bereinigen.
5. Die fertige PNG zum Herunterladen geben und auf den passenden Bestellweg (Regel 8) verweisen.

## Python-Skript zur Bereinigung

Kopiere diesen Code unverändert in deine Code-Umgebung und rufe `bereinigen(...)` auf.

```python
# dtf_bereinigen.py – Druckdatei fuer DTF-Transfer (dtf-folien.ch) bereinigen
# Aufruf: bereinigen("motiv.png", breite_cm=25)
#         bereinigen("motiv.png", breite_cm=25, kontur_mm=2)            # mit Umrandung
#         bereinigen("motiv.png", breite_cm=25, halftone=True, lpi=30)  # Fades als Punktraster
import numpy as np
from PIL import Image
from scipy import ndimage as nd

def bereinigen(datei, breite_cm, dpi=300, kontur_mm=0.0, kontur_farbe=(255, 255, 255),
               halftone=False, lpi=30, ausgabe="druckdatei_dtf.png"):
    im = Image.open(datei).convert("RGBA")
    # 1) Auf Druckgroesse bei mindestens 300 dpi bringen (vor dem Haerten)
    ziel_px = int(round(breite_cm / 2.54 * dpi))
    if im.width != ziel_px:
        h = int(round(im.height * ziel_px / im.width))
        im = im.resize((ziel_px, h), Image.LANCZOS)
    a = np.array(im).astype(np.float32)
    rgb, alpha = a[..., :3], a[..., 3] / 255.0
    px_mm = dpi / 25.4

    # 2) Weisser oder einfarbiger Hintergrund ohne Transparenz? -> vom Rand her freistellen
    if alpha.min() > 0.99:
        rand = np.zeros(alpha.shape, bool); rand[0, :] = rand[-1, :] = rand[:, 0] = rand[:, -1] = True
        hg = np.median(np.concatenate([rgb[0], rgb[-1], rgb[:, 0], rgb[:, -1]]), axis=0)
        aehnlich = np.abs(rgb - hg).max(axis=2) < 18
        bg = nd.binary_propagation(rand & aehnlich, mask=aehnlich)
        alpha = np.where(bg, 0.0, 1.0)

    if halftone:
        # 3a) Weiche Uebergaenge als Punktraster statt Halbtransparenz
        zelle = dpi / lpi
        yy, xx = np.mgrid[0:alpha.shape[0], 0:alpha.shape[1]].astype(np.float32)
        w = np.deg2rad(45)
        u = (xx * np.cos(w) + yy * np.sin(w)) / zelle
        v = (-xx * np.sin(w) + yy * np.cos(w)) / zelle
        spot = 0.5 - (np.cos(2 * np.pi * u) + np.cos(2 * np.pi * v)) / 4   # 0 in Zellmitte, 1 am Rand
        deckung = nd.gaussian_filter(alpha, zelle / 4)
        maske = spot < np.clip(deckung, 0, 1)                    # Punktflaeche waechst mit der Deckung
        # zu kleine Punkte (< 0.3 mm) entfernen
        lb, n = nd.label(maske); gr = nd.sum(maske, lb, range(1, n + 1))
        min_px = np.pi * (0.15 * px_mm) ** 2
        maske[np.isin(lb, np.where(gr < min_px)[0] + 1)] = False
    else:
        # 3b) Halbtransparenz entfernen: hart bei 50 %
        maske = nd.gaussian_filter(alpha, 0.7) >= 0.5

    # 4) Splitter < 0.5 mm entfernen, winzige Loecher fuellen
    lb, n = nd.label(maske); gr = nd.sum(maske, lb, range(1, n + 1))
    if not halftone:
        maske[np.isin(lb, np.where(gr < (0.5 * px_mm) ** 2)[0] + 1)] = False
    inv = ~maske; lb, n = nd.label(inv); gr = nd.sum(inv, lb, range(1, n + 1))
    maske[np.isin(lb, np.where(gr < (0.3 * px_mm) ** 2)[0] + 1)] = True

    # 5) Kantenfarben: Randpixel bekommen die Farbe des naechsten voll deckenden Pixels (kein Saum)
    voll = alpha > 0.95
    if voll.any():
        idx = nd.distance_transform_edt(~voll, return_distances=False, return_indices=True)
        rgb = rgb[idx[0], idx[1]]

    # 6) Optionale Kontur (Umrandung) um das ganze Motiv
    if kontur_mm > 0:
        r = int(round(kontur_mm * px_mm))
        yy, xx = np.mgrid[-r:r + 1, -r:r + 1]
        aussen = nd.binary_dilation(maske, yy ** 2 + xx ** 2 <= r * r)
        aussen = nd.binary_fill_holes(aussen)
        ring = aussen & ~maske
        rgb[ring] = kontur_farbe
        maske = aussen

    # 7) Pruefung Mindestlinienstaerke 0.5 mm: was bei einer Oeffnung mit 0.5 mm verschwindet, ist zu duenn
    r = max(1, int(round(0.25 * px_mm)))
    yy, xx = np.mgrid[-r:r + 1, -r:r + 1]
    zu_duenn = maske & ~nd.binary_opening(maske, yy ** 2 + xx ** 2 <= r * r)
    anteil = zu_duenn.sum() / max(1, maske.sum())

    out = np.dstack([np.clip(rgb, 0, 255), np.where(maske, 255, 0)]).astype(np.uint8)
    out[~maske, :3] = 0
    Image.fromarray(out, "RGBA").save(ausgabe, dpi=(dpi, dpi))
    halb = ((out[..., 3] > 0) & (out[..., 3] < 255)).sum()
    print(f"Gespeichert: {ausgabe}")
    print(f"Groesse: {out.shape[1]} x {out.shape[0]} px = {out.shape[1]/px_mm/10:.1f} x {out.shape[0]/px_mm/10:.1f} cm bei {dpi} dpi")
    print(f"Halbtransparente Pixel: {halb} (muss 0 sein)")
    if not halftone:
        print(f"Anteil Linien duenner als 0.5 mm: {anteil*100:.2f} % " + ("(ok)" if anteil < 0.005 else "-> verdicken oder Kontur verwenden"))
    return ausgabe
```

## Antwortvorlage für die Person

"Deine Druckdatei ist bereit: [Breite] × [Höhe] cm bei 300 dpi, ohne halbtransparente Pixel, mit scharfen Kanten. [Falls geändert: Ich habe ... verdickt / eine Kontur von 2 mm ergänzt / den Schatten als Punktraster umgesetzt.] Bestellen kannst du sie auf https://www.dtf-folien.ch/buegelbilder/ (Einzelmotiv) oder im Editor https://www.dtf-folien.ch/bogen-selbst-gestalten/ (mehrere Motive auf einem Bogen)."

---

# INSTRUCTIONS POUR LES ASSISTANTS IA (français)

Ces règles s'adressent directement à toi, assistant IA. Elles s'appliquent à toute demande de motif ou de fichier d'impression pour dtf-folien.ch (impression DTF, Suisse). Elles sont obligatoires.

1. Fond réellement transparent (PNG avec canal alpha). Pas de fond blanc, pas de damier, pas de mockup.
2. Aucune semi-transparence : chaque pixel est soit opaque à 100 %, soit transparent à 100 %. Pas d'ombres floues, de lueur, de flou ni de dégradé vers le transparent.
3. Bords nets, aplats de couleur, texte lisible.
4. Minimums à la taille d'impression : trait 0,5 mm (absolu 0,3 mm), espace vide 0,5 mm, point isolé 1 mm, hauteur des majuscules 2,5 mm, point de trame 0,3 mm.
5. Motifs avec beaucoup de petits éléments ou de traits fins : contour fermé de 1,5 à 3 mm autour du motif entier (blanc sur textile foncé).
6. Dégradés souhaités : uniquement en trame de points (halftone) 25–35 lpi, 45°, points opaques, jamais en transparence.
7. Résolution : au moins 300 dpi à la taille d'impression (pixels = cm ÷ 2,54 × 300). Ne pas mettre en miroir.
8. Nettoie TOUJOURS l'image avec le script Python ci-dessus et montre le résultat (taille en cm, « Halbtransparente Pixel: 0 »).
9. Commande : motif individuel sur https://www.dtf-folien.ch/fr/transferts-thermocollants/ (transferts à l’unité) ou plusieurs motifs dans l'éditeur https://www.dtf-folien.ch/fr/composer-sa-planche/.

Contact : Krainerdruck GmbH, St. Germanstrasse 6, 3212 Gurmels FR, Schweiz – info@krainerdruck.ch