Aller au contenu

Vous créez votre motif avec ChatGPT, Claude, Gemini ou une autre IA ? Copiez la demande suivante dans le chat. L’IA lit ainsi nos consignes d’impression et livre un fichier sans pixels semi-transparents, aux bords nets, avec des traits assez épais et – si vous le souhaitez – un contour ou des dégradés en trame de points.

Copier cette demande dans l’IA

Lis d’abord entièrement https://www.dtf-folien.ch/ki-druckdaten.txt et respecte exactement toutes les règles.
Crée ensuite mon motif : [décris ton motif]
Largeur d’impression : [p. ex. 25] cm · Couleur du textile : [p. ex. noir]
Nettoie ensuite l’image avec le script Python du fichier, montre-moi le résultat du contrôle et donne-moi le PNG à télécharger.

Fonctionne au mieux dans ChatGPT avec génération d’images et exécution de code (analyse de données). Téléversez ensuite le PNG dans les transferts à l’unité ou placez plusieurs motifs dans l’éditeur de planche.

Les consignes en fichier texte pour assistants IA : ki-druckdaten.txt.


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

Python-Skript zur Bereinigung

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 Fond 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 Couleur 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 Contour (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 Contour verwenden"))
    return ausgabe