update

tools/generowanie/akrylowa_statuetka_podziekowanie_rodzice_wzor2.py

@@ -0,0 +1,173 @@
+"""
+Generator PSD - Akrylowa statuetka podziekowanie dla Rodzicow ze zdjeciem (Wzor 2).
+
+Plaska struktura PSD: w grupie "Projekt" znajduja sie:
+- warstwy tekstowe: naglowek, tresc, para, data, motto
+- Smart Object zdjecia: zdjecie (clipping mask do warstwy ponizej)
+
+Podmiana zdjecia:
+- jesli --zdjecie wskazuje na istniejacy plik graficzny -> zostaje wstawione,
+  przeskalowane "cover" do oryginalnych boundsow placeholdera i wycentrowane
+- jesli zdjecie nie zostalo podane lub plik nie istnieje -> wstawiamy
+  zielony prostokat (#00FF00) jako sygnal, ze klient nie przeslal foto
+
+Wymaga: uruchomiony Adobe Photoshop, photoshop-python-api, Pillow.
+"""
+
+import argparse
+import os
+import photoshop.api as ps
+
+
+PROJEKT_DIR = os.path.join(
+    r"d:\pomysloweprezenty.pl\projekty\ślub - podziękowania",
+    "Akrylowa statuetka podziękowanie dla rodziców ze zdjęciem - Wzór 2",
+)
+SZABLON_PATH = os.path.join(PROJEKT_DIR, "Akrylowa statuetka podziękowanie dla rodziców ze zdjęciem - Wzór 2.psd")
+GOTOWE_DIR = os.path.join(PROJEKT_DIR, "_gotowe")
+
+ASSETS_DIR = os.path.join(os.path.dirname(__file__), "_assets")
+GREEN_PLACEHOLDER_PATH = os.path.join(ASSETS_DIR, "green_placeholder.png")
+
+PHOTO_SLOT = "zdjecie"
+
+
+def ensure_green_placeholder():
+    """Tworzy raz zielony PNG (#00FF00) jako placeholder dla brakujacego zdjecia."""
+    if os.path.exists(GREEN_PLACEHOLDER_PATH):
+        return GREEN_PLACEHOLDER_PATH
+    os.makedirs(ASSETS_DIR, exist_ok=True)
+    from PIL import Image
+    Image.new("RGB", (1000, 1000), (0, 255, 0)).save(GREEN_PLACEHOLDER_PATH)
+    return GREEN_PLACEHOLDER_PATH
+
+
+def set_text(layer, new_text):
+    """Zmienia tekst zachowujac srodek bounding boxa (centrowane warstwy)."""
+    b = [float(x) for x in layer.bounds]
+    cx, cy = (b[0] + b[2]) / 2, (b[1] + b[3]) / 2
+    layer.textItem.contents = new_text
+    b2 = [float(x) for x in layer.bounds]
+    cx2, cy2 = (b2[0] + b2[2]) / 2, (b2[1] + b2[3]) / 2
+    dx, dy = cx - cx2, cy - cy2
+    if dx or dy:
+        layer.translate(dx, dy)
+
+
+def set_layer_text(container, layer_name, new_text):
+    if new_text is None:
+        return
+    layer = container.artLayers[layer_name]
+    old = layer.textItem.contents
+    set_text(layer, new_text)
+    print(f'    {layer_name}: "{old}" -> "{new_text}"')
+
+
+def replace_smart_object_contents(app, file_path):
+    """Wykonuje akcje placedLayerReplaceContents na aktywnej warstwie SO."""
+    desc = ps.ActionDescriptor()
+    desc.putPath(app.charIDToTypeID("null"), file_path)
+    desc.putInteger(app.charIDToTypeID("PgNm"), 1)
+    app.executeAction(app.stringIDToTypeID("placedLayerReplaceContents"), desc)
+
+
+def replace_photo_cover(app, so_layer, photo_path):
+    """Podmienia zawartosc Smart Object i skaluje 'cover' do oryginalnych boundsow."""
+    target = [float(x) for x in so_layer.bounds]
+    target_w = target[2] - target[0]
+    target_h = target[3] - target[1]
+    target_cx = (target[0] + target[2]) / 2
+    target_cy = (target[1] + target[3]) / 2
+
+    app.activeDocument.activeLayer = so_layer
+    replace_smart_object_contents(app, photo_path)
+
+    new_b = [float(x) for x in so_layer.bounds]
+    new_w = new_b[2] - new_b[0]
+    new_h = new_b[3] - new_b[1]
+    if new_w <= 0 or new_h <= 0:
+        return
+
+    scale = max(target_w / new_w, target_h / new_h) * 100.0
+    so_layer.resize(scale, scale, ps.AnchorPosition.MiddleCenter)
+
+    cur = [float(x) for x in so_layer.bounds]
+    cur_cx = (cur[0] + cur[2]) / 2
+    cur_cy = (cur[1] + cur[3]) / 2
+    so_layer.translate(target_cx - cur_cx, target_cy - cur_cy)
+
+
+def swap_photo_slot(app, container, slot_name, photo_path):
+    """Podmienia zdjecie w slocie; brak/nieistnieje -> zielony placeholder."""
+    so_layer = container.artLayers[slot_name]
+    if photo_path and os.path.isfile(photo_path):
+        print(f"  {slot_name}: {photo_path}")
+        replace_photo_cover(app, so_layer, photo_path)
+    else:
+        if photo_path:
+            print(f"  {slot_name}: UWAGA plik nie istnieje ({photo_path}) - zielony placeholder")
+        else:
+            print(f"  {slot_name}: brak - zielony placeholder")
+        replace_photo_cover(app, so_layer, ensure_green_placeholder())
+
+
+def generate(klient, para, data, tresc=None, naglowek=None, motto=None, zdjecie=None):
+    os.makedirs(GOTOWE_DIR, exist_ok=True)
+    output_path = os.path.join(GOTOWE_DIR, f"{klient}.psd")
+
+    app = ps.Application()
+    doc = app.open(SZABLON_PATH)
+    print(f"Otwarto szablon: {doc.name}")
+
+    try:
+        projekt = doc.layerSets["Projekt"]
+
+        print("  Podmiana tekstow:")
+        set_layer_text(projekt, "naglowek", naglowek)
+        set_layer_text(projekt, "tresc", tresc)
+        set_layer_text(projekt, "para", para)
+        set_layer_text(projekt, "data", data)
+        set_layer_text(projekt, "motto", motto)
+
+        print("  Podmiana zdjecia:")
+        swap_photo_slot(app, projekt, PHOTO_SLOT, zdjecie)
+
+        psd_opts = ps.PhotoshopSaveOptions()
+        doc.saveAs(output_path, psd_opts, True)
+        print(f"Zapisano: {output_path}")
+    finally:
+        try:
+            doc.close(ps.SaveOptions.DoNotSaveChanges)
+        except Exception:
+            pass
+
+    print("Gotowe!")
+    return output_path
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generator PSD - Akrylowa statuetka podziekowanie dla Rodzicow Wzor 2"
+    )
+    parser.add_argument("--klient", required=True, help="Nazwa pliku wyjsciowego (bez rozszerzenia)")
+    parser.add_argument("--para", required=True, help="Imiona pary mlodej (np. 'Klaudia i Marcin')")
+    parser.add_argument("--data", required=True, help="Data uroczystosci (np. '04.10.2025')")
+    parser.add_argument("--tresc", default=None, help="Tresc podziekowania (opcjonalnie, domyslnie z szablonu)")
+    parser.add_argument("--naglowek", default=None, help="Naglowek (opcjonalnie, domyslnie 'Kochani Rodzice!')")
+    parser.add_argument("--motto", default=None, help="Motto (opcjonalnie)")
+    parser.add_argument("--zdjecie", default=None, help="Sciezka do zdjecia (opcjonalnie; brak = zielony placeholder)")
+
+    args = parser.parse_args()
+    generate(
+        klient=args.klient,
+        para=args.para,
+        data=args.data,
+        tresc=args.tresc,
+        naglowek=args.naglowek,
+        motto=args.motto,
+        zdjecie=args.zdjecie,
+    )
+
+
+if __name__ == "__main__":
+    main()

tools/generowanie/buteleczki_slub_wzor2.py

@@ -0,0 +1,204 @@
+"""
+Generator PSD - Podziekowanie dla gosci weselnych (buteleczka, Wzor 2).
+
+Otwiera szablon PSD, podmienia teksty w Smart Object "Projekt"
+z zachowaniem pozycji warstw, zapisuje jako nowy PSD w folderze _gotowe.
+
+Wszystkie 8 warstw w szablonie to linkowane kopie tego samego Smart Object,
+wiec edycja w "Projekt" propaguje sie automatycznie na pozostale buteleczki.
+
+Wymaga: uruchomiony Adobe Photoshop, pakiet photoshop-python-api.
+
+Uzycie:
+    python buteleczki_slub_wzor2.py --imie_pana "Piotr" --imie_pani "Anna" \
+        --data "12.12.2024" --klient "Anna Kowalska"
+
+    python buteleczki_slub_wzor2.py --imie_pana "Piotr" --imie_pani "Anna" \
+        --inicjal_pana "P" --inicjal_pani "A" --data "12.12.2024" \
+        --tekst "Dziekujemy!" --klient "Anna Kowalska"
+"""
+
+import argparse
+import os
+import photoshop.api as ps
+
+
+# --- Sciezki ---
+PROJEKT_DIR = os.path.join(
+    r"d:\pomysloweprezenty.pl\projekty\ślub - buteleczki",
+    "Podziękowanie dla gości weselnych buteleczka z nadrukiem UV - Wzór 2",
+)
+SZABLON_PATH = os.path.join(PROJEKT_DIR, "szablon 370x300.psd")
+GOTOWE_DIR = os.path.join(PROJEKT_DIR, "_gotowe")
+
+# Nazwa warstwy Smart Object w glownym PSD (jeden z 8 - edycja propaguje na wszystkie)
+SMART_OBJECT_LAYER = "Projekt"
+
+
+def open_smart_object(app):
+    """Otwiera zawartosc aktywnej warstwy Smart Object do edycji."""
+    desc = ps.ActionDescriptor()
+    ref = ps.ActionReference()
+    ref.putEnumerated(
+        app.stringIDToTypeID("layer"),
+        app.stringIDToTypeID("ordinal"),
+        app.stringIDToTypeID("targetEnum"),
+    )
+    desc.putReference(app.stringIDToTypeID("null"), ref)
+    app.executeAction(app.stringIDToTypeID("placedLayerEditContents"), desc)
+
+
+def change_text_preserve_position(layer, new_text):
+    """Zmienia tekst warstwy z zachowaniem oryginalnej pozycji.
+
+    Zwraca (dx, dy, ok) gdzie ok=False oznacza ze bounds_after=(0,0,0,0)
+    (warstwa poza canvas SO po zmianie tekstu - delta nieuzyteczna).
+    """
+    bounds_before = [float(b) for b in layer.bounds]
+    layer.textItem.contents = new_text
+    bounds_after = [float(b) for b in layer.bounds]
+
+    if bounds_after == [0.0, 0.0, 0.0, 0.0]:
+        return (None, None, False)
+
+    dx = bounds_before[0] - bounds_after[0]
+    dy = bounds_before[1] - bounds_after[1]
+    if dx != 0 or dy != 0:
+        layer.translate(dx, dy)
+    return (dx, dy, True)
+
+
+def apply_replacements(group, replacements):
+    """Podmienia teksty w grupie warstw z fallbackiem dla warstw gubiacych bounds.
+
+    Photoshop po zmianie textItem.contents potrafi przeniesc warstwe
+    poza canvas SO (bounds=0). Wykrywamy to i kompensujemy srednia delta
+    z poprawnie obsluzonych warstw - przesuniecie jest systematyczne.
+    """
+    deltas = []
+    pending = []
+
+    for layer_name, new_text in replacements.items():
+        layer = group.artLayers[layer_name]
+        old_text = layer.textItem.contents
+        dx, dy, ok = change_text_preserve_position(layer, new_text)
+        if ok:
+            deltas.append((dx, dy))
+            print(f'  {layer_name}: "{old_text}" -> "{new_text}"')
+        else:
+            pending.append((layer_name, layer, old_text, new_text))
+            print(f'  {layer_name}: "{old_text}" -> "{new_text}" (poza canvas, fallback)')
+
+    if pending:
+        if not deltas:
+            raise RuntimeError("Wszystkie warstwy poza canvas - brak referencji do fallbacku")
+        avg_dx = sum(d[0] for d in deltas) / len(deltas)
+        avg_dy = sum(d[1] for d in deltas) / len(deltas)
+        for layer_name, layer, _old, _new in pending:
+            layer.translate(avg_dx, avg_dy)
+            print(f'    [{layer_name}] fallback translate ({avg_dx:.2f},{avg_dy:.2f})')
+
+
+def generate(
+    imie_pana,
+    imie_pani,
+    data,
+    klient,
+    inicjal_pana=None,
+    inicjal_pani=None,
+    tekst=None,
+):
+    """Generuje PSD z podmienionymi danymi."""
+    os.makedirs(GOTOWE_DIR, exist_ok=True)
+    output_path = os.path.join(GOTOWE_DIR, f"{klient}.psd")
+
+    # Auto-inicjaly z imion jesli nie podane
+    if inicjal_pana is None:
+        inicjal_pana = imie_pana[:1].upper() if imie_pana else ""
+    if inicjal_pani is None:
+        inicjal_pani = imie_pani[:1].upper() if imie_pani else ""
+
+    app = ps.Application()
+    doc = app.open(SZABLON_PATH)
+    print(f"Otwarto szablon: {doc.name}")
+
+    target = None
+    for layer in doc.layers:
+        if layer.name == SMART_OBJECT_LAYER:
+            target = layer
+            break
+
+    if target is None:
+        doc.close(ps.SaveOptions.DoNotSaveChanges)
+        raise RuntimeError(f"Nie znaleziono warstwy '{SMART_OBJECT_LAYER}'")
+
+    app.activeDocument.activeLayer = target
+    open_smart_object(app)
+    so_doc = app.activeDocument
+
+    # Nawigacja do grupy z tekstami (po renamie: "Tekst")
+    tekst_group = so_doc.layerSets["Tekst"]
+
+    replacements = {
+        "imie_pana": imie_pana,
+        "imie_pani": imie_pani,
+        "inicjal_pana": inicjal_pana,
+        "inicjal_pani": inicjal_pani,
+        "data": data,
+    }
+    if tekst is not None:
+        replacements["tekst"] = tekst
+
+    apply_replacements(tekst_group, replacements)
+
+    so_doc.save()
+    so_doc.close()
+    print("Smart Object zapisany")
+
+    psd_opts = ps.PhotoshopSaveOptions()
+    app.activeDocument.saveAs(output_path, psd_opts, True)
+    print(f"Zapisano: {output_path}")
+
+    app.activeDocument.close(ps.SaveOptions.DoNotSaveChanges)
+    print("Gotowe!")
+    return output_path
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generator PSD - buteleczki weselne Wzor 2"
+    )
+    parser.add_argument("--imie_pana", required=True, help="Imie pana mlodego (np. Piotr)")
+    parser.add_argument("--imie_pani", required=True, help="Imie pani mlodej (np. Anna)")
+    parser.add_argument("--data", required=True, help="Data slubu (np. 12.12.2024)")
+    parser.add_argument("--klient", required=True, help="Nazwa pliku wyjsciowego (bez .psd)")
+    parser.add_argument(
+        "--inicjal_pana",
+        default=None,
+        help="Inicjal pana mlodego (domyslnie: pierwsza litera --imie_pana)",
+    )
+    parser.add_argument(
+        "--inicjal_pani",
+        default=None,
+        help="Inicjal pani mlodej (domyslnie: pierwsza litera --imie_pani)",
+    )
+    parser.add_argument(
+        "--tekst",
+        default=None,
+        help="Tekst podziekowania (domyslnie: oryginalny z szablonu)",
+    )
+
+    args = parser.parse_args()
+    generate(
+        imie_pana=args.imie_pana,
+        imie_pani=args.imie_pani,
+        data=args.data,
+        klient=args.klient,
+        inicjal_pana=args.inicjal_pana,
+        inicjal_pani=args.inicjal_pani,
+        tekst=args.tekst,
+    )
+
+
+if __name__ == "__main__":
+    main()