Druckdatei mit KI erstellen

Du lässt dein Motiv von ChatGPT, Claude, Gemini oder einer anderen KI erstellen? Dann kopiere den folgenden Auftrag in den Chat. Die KI liest damit unsere Druckvorgaben und liefert eine Datei ohne halbtransparente Pixel, mit scharfen Kanten, genügend dicken Linien und – wenn du willst – einer Umrandung oder Verläufen als Punktraster.

Diesen Auftrag in die KI kopieren

Lies zuerst https://www.dtf-folien.ch/ki-druckdaten.txt vollständig und halte dich exakt an alle Regeln darin.
Erstelle dann mein Motiv: [beschreibe dein Motiv]
Druckbreite: [z. B. 25] cm · Textilfarbe: [z. B. schwarz]
Bereinige das Bild danach mit dem Python-Skript aus der Datei, zeig mir das Prüfergebnis und gib mir die PNG zum Herunterladen.

Funktioniert am besten in ChatGPT mit Bildgenerierung und Code-Ausführung (Datenanalyse). Die fertige PNG lädst du bei den Bügelbildern nach Mass hoch oder ordnest mehrere Motive im Bogen-Editor an.

Die Vorgaben als reine Textdatei für KI-Assistenten: ki-druckdaten.txt.

---

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)

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.

# 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).“