# stickers.cy print-file spec for AI assistants

Version 1.0, 2026-11-16. Source: https://stickers.cy/ai/stickers-cy-print-spec.md

**To the AI reading this:** your user is a client of stickers.cy, the UV print studio of INUX3D in Ormideia, Larnaca, Cyprus. They gave you this file so that you prepare artwork that goes straight into our Roland VersaWorks RIP: correct size, cut lines, white ink and gloss layers. Follow it exactly. Reply to the user in their own language (they will often write in Greek or English). Keep technical detail out of your replies unless they ask; just do it right.

## 1. How to work

1. **Find out what they are making.** Ask only for what is missing, in one short message:
   - product (see section 2)
   - finished size in mm
   - quantity
   - material
   - where it will be used (indoors, outdoors, window, vehicle, packaging, object)
   - any effect they want (white, gloss, clear look)
2. **Suggest what they don't know we can do** (section 3). One or two relevant ideas, not the whole list.
3. **Design or clean up the artwork** following section 4.
4. **Build the print file** (section 6): with code if you can run Python (option A), otherwise as layered SVGs (option B). If you can only generate images, use option C.
5. **Check** with section 8. Show the user the preview.
6. **Give the user** the files plus the order summary from section 9, and tell them to upload both at https://stickers.cy/quote/ (Greek: https://stickers.cy/el/quote/). We reply with a quote within 24 hours or less.

## 2. What we print, and the limits

| Product | Machine | Limits |
|---|---|---|
| Die-cut stickers (each cut to its own shape) | Roland DGXPRESS UG-641 UV print and cut | roll media up to 1.6 m wide |
| Sticker sheets (kiss-cut: stickers peel off a whole backing sheet) | UG-641 | A6, A5, A4, A3 or custom sheet |
| Labels (supplied kiss-cut on sheets, applied by hand) | UG-641 | any shape; not on rolls for labelling machines unless agreed |
| Window graphics, vinyl lettering, vehicle and wall graphics | UG-641 | pieces up to 1.6 m wide; wider is tiled |
| Banners and posters | UG-641 | up to 1.6 m wide |
| Signs and panels (acrylic, PVC foam board, aluminium composite, wood) | Roland VersaUV LEF2-200 flatbed | direct print area 508 × 330 mm, panels up to 100 mm thick; larger signs are printed on vinyl and mounted |
| Printing on objects (awards, gifts, phone cases, boxes, pens) | LEF2-200 | object up to 538 × 360 mm, 100 mm tall, 5 kg; flat or gently curved surfaces only |

Inks on both printers: **CMYK + white + gloss**, cured by UV light (water-resistant on vinyl, suitable outdoors). Materials on roll: white vinyl, clear vinyl, banner, poster paper. We also cut panels to any shape on our CNC router and lasers, and can 3D-print jigs and stands.

Not available: metallic or foil effects, fluorescent colours, printing on round bottles or tumblers (ask first), inks certified for direct food contact (labels go on the outside of packaging).

## 3. Options to suggest

- **Clear vinyl + white ink:** a "no-label look" on bottles, jars, glass and windows. Colours sit on a white layer so they stay bright.
- **White sticker on clear:** white ink under the whole sticker shape, including its border. It looks like a white sticker but is thinner and cleaner.
- **White as a design colour:** white text or logos on clear vinyl, glass, dark acrylic or black objects.
- **Inside-the-glass window graphics:** printed reversed on clear vinyl, readable from the street, protected from weather and cleaning. Do **not** mirror the file yourself; write "reverse print, applied inside glass" in the order summary and we mirror it in the RIP.
- **Back-printed clear acrylic:** colour and white printed on the back face, seen glossy through the acrylic. Same rule: don't mirror, say "back print on clear acrylic".
- **Spot gloss:** clear gloss on parts of the design only (logo, title, a pattern) to make them shine against the matte vinyl. Gloss can also be built up into a raised texture you can feel.
- **Kiss-cut sheets:** several designs on one sheet, each peeling off on its own.
- **Cut to shape:** stickers, labels and signs cut along any outline, with a white or clear border.

## 4. Artwork rules (all files)

- **Size:** work at the final size in millimetres. Images need **300 dpi at final size** (banners: 100 to 150 dpi). If an image is too small, upscale it with an AI upscaler before building the file, and tell the user.
- **Colour:** set vector colours in **CMYK**. Use black only for neutral greys (for example C0 M0 Y0 K50); greys mixed from four inks can print with a colour cast. Large black areas: C50 M40 Y40 K100. Small text: K100 only. Raster images may stay sRGB: our RIP converts them with the printer's profile. Do not convert images to CMYK with a naive formula.
- **Text:** at least 6 pt and lines at least 0.25 mm thick on small stickers. Convert text to outlines, or embed fonts in the PDF. Check AI-generated text letter by letter: image generators misspell.
- **Bleed:** if a background colour runs to the cut line, extend it **2 mm past the cut line**. Keep text and logos **2 mm inside** the cut line.
- **No effects on spot layers:** no transparency, blend modes, shadows or gradients in white or gloss. A white gradient prints as a solid fill. For a fade, use a pattern of solid dots.
- **Don't draw the sticker:** no fake die-cut borders, drop shadows, mockup backgrounds, perspective or "sticker on a laptop" scenes in the print file. The file is the flat design only.

## 5. Spot colours (exact, case-sensitive names)

| Purpose | Spot colour name | How to apply |
|---|---|---|
| Cut line | `CutContour` | stroke only, 0.25 pt hairline, no fill; preview colour 100 % magenta |
| White ink | `RDG_WHITE` | fill only, no stroke, 100 % tint, overprint on |
| Gloss ink | `RDG_Gloss` | fill only, no stroke, 100 % tint, overprint on |

- Put each on its own layer named **Cut**, **Gloss**, **White**, above the **Artwork** layer. Set every spot object to **overprint** (fill overprint for white/gloss, stroke overprint for the cut) so it doesn't knock out the artwork. The printing order (white under or over the colour) is set in our RIP, not by layer order.
- **White under colour:** shrink the white shape **0.15 mm inside** the edge of the coloured artwork so no white halo shows.
- **When to add white:** on clear vinyl, clear acrylic, glass, and dark or coloured objects. Never on white vinyl.
- **CorelDRAW and Illustrator users** can send their native file (.cdr or .ai): create `CutContour`, `RDG_WHITE` and `RDG_Gloss` as spot colours in a custom palette with exactly these names, and convert text to curves.
- **If unsure, leave white/gloss out** and describe what you want in the order summary. Our RIP can generate white and gloss layers for files that have none.

## 6. Building the files

### Option A: PDF with spot colours (best; needs Python)

If you can run Python, save the script in section 7 as `prepare_print_file.py` and run it on a PNG of the artwork (transparent background is best). It writes `NAME.pdf` (the print file) and `NAME_preview.png` (show this to the user). Examples:

```
python3 prepare_print_file.py --art art.png --width-mm 60 --white art --gloss art --out logo-60mm
python3 prepare_print_file.py --art art.png --width-mm 80 --cut-offset-mm 2.5 --one-piece --out logo-80mm
python3 prepare_print_file.py --art art.png --width-mm 60 --white full --out clear-sticker
python3 prepare_print_file.py --art plaque.png --width-mm 150 --no-cut --white art --out plaque
```

| Flag | Meaning |
|---|---|
| `--width-mm` / `--height-mm` | final size of the artwork |
| `--cut-offset-mm` | border between art and cut (default 2) |
| `--one-piece` | join separate parts into one sticker shape |
| `--no-cut` | for banners, panels and objects |
| `--white none\|art\|full` | none; under the inked areas; under the whole sticker |
| `--gloss none\|art\|full\|mask.png` | none; over the inked areas; whole sticker; or a black-and-white mask image the same size as the art (black = gloss) |

Vector artwork: render it to PNG at 600 dpi first (for example with cairosvg), then run the script. If the user designs in CorelDRAW or Illustrator, they can instead send the native file (.cdr or .ai) with the spot colours from section 5 set up in a custom palette; give them those exact names and steps. For sticker sheets, run it once per design and send all the PDFs; we lay out the sheet.

### Option B: layered SVG files (no code execution)

Make files with the **same width, height and viewBox, in mm** (for example `width="70mm" height="70mm" viewBox="0 0 70 70"`):

- `NAME_artwork.svg` (or a 300 dpi PNG): the design.
- `NAME_cut.svg`: the cut line only, `fill="none" stroke="#EC008C" stroke-width="0.1"`, one closed path per piece, offset about 2 mm from the art.
- `NAME_white.svg`: if needed, the white-ink areas as solid black fills.
- `NAME_gloss.svg`: if needed, the gloss areas as solid black fills.

The file names tell us which spot colour each layer becomes.

### Option C: image only (image generators)

Generate the design flat, isolated on a transparent or plain white background, with no border, shadow, mockup or perspective, at the highest resolution available. Aim for 300 dpi at final size: 60 mm needs 709 px, 100 mm needs 1181 px. Send the PNG and describe white/gloss in the order summary; we make the cut, white and gloss layers.

## 7. Script: prepare_print_file.py

```python
#!/usr/bin/env python3
"""
stickers.cy print-file builder, v1.0 (2026-11-15)

Turns an artwork image into a print-ready PDF for Roland VersaWorks:
  - the artwork (flattened on white: white pixels = no ink)
  - CutContour  : hairline cut line (spot colour, stroke only), offset around the artwork
  - RDG_WHITE   : white ink layer (spot colour, fill only), choked slightly inside the artwork
  - RDG_Gloss   : gloss ink layer (spot colour, fill only)
All spot objects are set to overprint. Also writes NAME_preview.png to show the user.

Needs: numpy, pillow, scipy, contourpy (ships with matplotlib), reportlab
  pip install numpy pillow scipy contourpy reportlab

Examples
  # 60 mm die-cut sticker on clear vinyl, white under the art, gloss on the art
  python3 prepare_print_file.py --art logo.png --width-mm 60 --white art --gloss art --out bakery-60mm
  # white vinyl, cut only, 2.5 mm border
  python3 prepare_print_file.py --art logo.png --width-mm 80 --cut-offset-mm 2.5 --out logo-80mm
  # white sticker look on clear vinyl (white under the whole sticker incl. border)
  python3 prepare_print_file.py --art logo.png --width-mm 60 --white full --out logo-clear
  # print on an object / panel, no cut
  python3 prepare_print_file.py --art plaque.png --width-mm 150 --no-cut --white art --out plaque
"""
import argparse
import sys

try:
    import numpy as np
    from PIL import Image, ImageDraw
    from scipy.ndimage import distance_transform_edt as edt, gaussian_filter
    import contourpy
    from contourpy import FillType
    from reportlab.pdfgen import canvas
    from reportlab.lib.colors import CMYKColorSep
    from reportlab.lib.units import mm
    from reportlab.lib.utils import ImageReader
except ImportError as e:  # pragma: no cover
    sys.exit(f"Missing library ({e.name}). Run: pip install numpy pillow scipy contourpy reportlab")

# Exact VersaWorks spot names (case-sensitive). Alternate CMYK values only affect on-screen previews.
CUT = CMYKColorSep(0, 1, 0, 0, spotName="CutContour")
WHITE = CMYKColorSep(0, 0, 0, 0.12, spotName="RDG_WHITE")
GLOSS = CMYKColorSep(0.25, 0, 0, 0, spotName="RDG_Gloss")


def load_mask(img, bg_threshold):
    """True where the artwork has ink. Uses alpha if present, else treats near-white as background."""
    rgba = img.convert("RGBA")
    a = np.asarray(rgba)
    alpha = a[..., 3]
    has_alpha = alpha.min() < 250
    if has_alpha:
        mask = alpha >= 128
    else:
        mask = (a[..., :3] < bg_threshold).any(axis=2)
    flat = Image.new("RGB", rgba.size, (255, 255, 255))
    flat.paste(rgba, mask=rgba.split()[3])
    return mask, flat, has_alpha


def rdp(pts, eps):
    """Ramer-Douglas-Peucker simplification of a closed ring (Nx2)."""
    if len(pts) < 5:
        return pts
    keep = np.zeros(len(pts), bool)
    keep[0] = keep[-1] = True
    stack = [(0, len(pts) - 1)]
    while stack:
        s, e = stack.pop()
        if e <= s + 1:
            continue
        a, b = pts[s], pts[e]
        seg = b - a
        n = np.hypot(*seg)
        v = pts[s + 1:e] - a
        d = np.abs(seg[0] * v[:, 1] - seg[1] * v[:, 0]) / n if n > 0 else np.hypot(v[:, 0], v[:, 1])
        i = int(np.argmax(d))
        if d[i] > eps:
            m = s + 1 + i
            keep[m] = True
            stack += [(s, m), (m, e)]
    return pts[keep]


def regions(field, lower, upper, outer_only, eps_px, min_area_px):
    """Filled contour of lower <= field <= upper -> list of rings (pixel coords)."""
    gen = contourpy.contour_generator(z=field, fill_type=FillType.OuterOffset)
    pts_list, offs_list = gen.filled(lower, upper)
    rings = []
    for pts, offs in zip(pts_list, offs_list):
        bounds = list(zip(offs[:-1], offs[1:]))
        if outer_only:
            bounds = bounds[:1]
        for s, e in bounds:
            ring = pts[s:e]
            x, y = ring[:, 0], ring[:, 1]
            area = 0.5 * abs(np.dot(x, np.roll(y, 1)) - np.dot(y, np.roll(x, 1)))
            if area >= min_area_px:
                rings.append(rdp(ring, eps_px))
    return rings


def main():
    ap = argparse.ArgumentParser(description="stickers.cy print-file builder")
    ap.add_argument("--art", required=True, help="artwork image (PNG with transparency is best)")
    ap.add_argument("--width-mm", type=float, help="final width of the artwork in mm")
    ap.add_argument("--height-mm", type=float, help="final height of the artwork in mm (use instead of width)")
    ap.add_argument("--cut-offset-mm", type=float, default=2.0, help="cut line distance from the artwork edge (default 2)")
    ap.add_argument("--no-cut", action="store_true", help="no cut line (banners, panels, objects)")
    ap.add_argument("--one-piece", action="store_true", help="join separate parts of the design into one sticker shape")
    ap.add_argument("--white", default="none", help="none | art (under inked areas) | full (under the whole cut shape)")
    ap.add_argument("--white-choke-mm", type=float, default=0.15, help="pull white in from the art edge (default 0.15)")
    ap.add_argument("--gloss", default="none", help="none | art | full | path to a mask image (black = gloss, same size as art)")
    ap.add_argument("--bg-threshold", type=int, default=245, help="for images without transparency: brighter than this = background")
    ap.add_argument("--margin-mm", type=float, default=3.0, help="empty margin around the cut line")
    ap.add_argument("--out", required=True, help="output name without extension")
    a = ap.parse_args()

    img = Image.open(a.art)
    mask, flat, has_alpha = load_mask(img, a.bg_threshold)
    h_px, w_px = mask.shape
    if not mask.any():
        sys.exit("No artwork found (image is empty or entirely background).")
    if a.width_mm:
        ppm = w_px / a.width_mm
    elif a.height_mm:
        ppm = h_px / a.height_mm
    else:
        sys.exit("Give --width-mm or --height-mm (the final printed size).")
    dpi = ppm * 25.4
    warn = []
    if dpi < 300:
        warn.append(f"Artwork is {dpi:.0f} dpi at this size; 300 dpi is recommended (150 is the minimum for banners).")
    if not has_alpha:
        warn.append(f"No transparency: pixels brighter than {a.bg_threshold} were treated as background.")

    off_px = 0 if a.no_cut else a.cut_offset_mm * ppm
    pad = int(np.ceil(off_px + a.margin_mm * ppm)) + 2
    m = np.pad(mask, pad)
    H, W = m.shape
    dist_out = edt(~m)  # distance from the artwork, outside
    dist_in = edt(m)    # distance from the background, inside
    eps = 0.02 * ppm    # simplify paths to 0.02 mm
    min_area = (0.3 * ppm) ** 2

    cut_field = dist_out
    if a.one_piece and not a.no_cut:
        # morphological closing: grow until the parts touch, then shrink back by the same amount
        for extra_mm in (1, 2, 4, 6, 9, 13, 20):
            r = extra_mm * ppm
            closed = edt(dist_out <= off_px + r) >= r
            n_parts = len(regions(np.where(closed, 0.0, 1.0), -1, 0.5, True, eps, min_area))
            if n_parts <= 1:
                r *= 1.6  # a little more than the minimum, for rounder bridges
                closed = edt(dist_out <= off_px + r) >= r
                break
        # smooth signed distance of the joined shape; the cut runs along its zero line
        sd = gaussian_filter(edt(~closed) - edt(closed), 1.2)
        cut_field, cut_lo, cut_hi = sd, -1e9, 0.0
        if n_parts > 1:
            warn.append("The design has parts too far apart to join into one sticker; they stay separate.")
    else:
        cut_lo, cut_hi = -1, off_px
    cut_rings = [] if a.no_cut else regions(cut_field, cut_lo, cut_hi, True, eps, min_area)

    def layer(mode, choke_mm):
        if mode == "none":
            return []
        if mode == "art":
            return regions(dist_in, max(choke_mm * ppm, 0.5), 1e9, False, eps, min_area)
        if mode == "full":
            return cut_rings if cut_rings else regions(dist_in, 0.5, 1e9, False, eps, min_area)
        gm = np.asarray(Image.open(mode).convert("L").resize((w_px, h_px))) < 128
        cover = gm.mean()
        if cover == 0:
            warn.append("The gloss mask is empty (no black areas); no gloss was added.")
        elif cover > 0.95:
            warn.append("The gloss mask is almost entirely black, so gloss covers the whole artwork. Check the mask: black = gloss, white = no gloss.")
        return regions(edt(np.pad(gm, pad)), 0.5, 1e9, False, eps, min_area)

    white_rings = layer(a.white, a.white_choke_mm)
    gloss_rings = layer(a.gloss, 0)

    page_w, page_h = W / ppm * mm, H / ppm * mm
    to_pdf = lambda x, y: (x / ppm * mm, (H - y) / ppm * mm)

    c = canvas.Canvas(a.out + ".pdf", pagesize=(page_w, page_h))
    c.setTitle(f"{a.out} - stickers.cy print file")
    c.setAuthor("stickers.cy print-file builder 1.0")
    c.drawImage(ImageReader(flat), pad / ppm * mm, pad / ppm * mm, w_px / ppm * mm, h_px / ppm * mm)

    def path_of(rings):
        p = c.beginPath()
        for r in rings:
            x0, y0 = to_pdf(*r[0])
            p.moveTo(x0, y0)
            for x, y in r[1:]:
                p.lineTo(*to_pdf(x, y))
            p.close()
        return p

    c.saveState()
    c.setFillOverprint(True)
    c.setStrokeOverprint(True)
    c.setOverprintMask(1)
    if white_rings:
        c.setFillColor(WHITE)
        c.drawPath(path_of(white_rings), stroke=0, fill=1, fillMode=0)  # 0 = even-odd (keeps holes)
    if gloss_rings:
        c.setFillColor(GLOSS)
        c.drawPath(path_of(gloss_rings), stroke=0, fill=1, fillMode=0)
    if cut_rings:
        c.setStrokeColor(CUT)
        c.setLineWidth(0.25)
        c.setLineJoin(1)
        c.drawPath(path_of(cut_rings), stroke=1, fill=0)
    c.restoreState()
    c.showPage()
    c.save()

    # preview for the user: checker = no ink (vinyl/material shows), grey = white ink, white diagonal lines = gloss, magenta = cut
    s = max(1, int(round(ppm * 25.4 / 250)))  # preview at ~250 dpi
    pv = Image.new("RGB", (W, H), (255, 255, 255))
    ck = ImageDraw.Draw(pv)
    step = max(8, int(2 * ppm))
    for yy in range(0, H, step):
        for xx in range(0, W, step):
            if (xx // step + yy // step) % 2:
                ck.rectangle([xx, yy, xx + step - 1, yy + step - 1], fill=(232, 236, 234))
    def eo_mask(rings):
        acc = np.zeros((H, W), bool)
        for r in rings:
            mk = Image.new("1", (W, H), 0)
            ImageDraw.Draw(mk).polygon([tuple(p) for p in r], fill=1)
            acc ^= np.asarray(mk, bool)
        return Image.fromarray((acc * 255).astype("uint8"), "L")

    if white_rings:
        pv.paste((198, 198, 198), (0, 0), eo_mask(white_rings))
    art = Image.new("RGBA", (W, H), (0, 0, 0, 0))
    art.paste(img.convert("RGBA"), (pad, pad))
    pv.paste(art, (0, 0), art)
    if gloss_rings:
        hatch = Image.new("L", (W, H), 0)
        hd = ImageDraw.Draw(hatch)
        gap = max(6, int(ppm * 1.2))
        for k in range(-H, W, gap):
            hd.line([(k, 0), (k + H, H)], fill=255, width=max(1, int(ppm * 0.25)))
        gmask = Image.fromarray(np.minimum(np.asarray(hatch), np.asarray(eo_mask(gloss_rings))), "L")
        pv.paste((255, 255, 255), (0, 0), gmask)
    cd = ImageDraw.Draw(pv)
    for r in cut_rings:
        cd.line([tuple(p) for p in r] + [tuple(r[0])], fill=(228, 0, 124), width=max(2, int(ppm * 0.25)))
    pv = pv.resize((max(1, W // s), max(1, H // s)), Image.LANCZOS)
    pv.save(a.out + "_preview.png")

    print(f"Wrote {a.out}.pdf and {a.out}_preview.png")
    print(f"Page {W/ppm:.1f} x {H/ppm:.1f} mm | artwork {w_px/ppm:.1f} x {h_px/ppm:.1f} mm at {dpi:.0f} dpi")
    print(f"CutContour paths: {len(cut_rings)} | RDG_WHITE: {'yes' if white_rings else 'no'} | RDG_Gloss: {'yes' if gloss_rings else 'no'}")
    print("Preview legend: checker = no ink, grey = white ink, white diagonal lines = gloss, magenta line = cut.")
    print("Note: PDF viewers without overprint preview draw the white/gloss layers on top of the art. That is expected; show the user the preview PNG.")
    for w in warn:
        print("WARNING:", w)


if __name__ == "__main__":
    main()
```

## 8. Check before you hand over

- [ ] Size in mm matches what the user asked; images are 300 dpi at final size (150 for banners).
- [ ] One closed `CutContour` path per piece (or none for uncut prints), about 2 mm from the art; no tiny islands or hairline gaps.
- [ ] `RDG_WHITE` only where needed and 0.15 mm inside the colour edge; `RDG_Gloss` only where wanted; both fill-only and overprint.
- [ ] Neutral greys use black only; text is spelled correctly, at least 6 pt, converted to outlines.
- [ ] No borders, shadows or mockups in the print file; nothing is mirrored.
- [ ] The preview has been shown to the user and they agreed.

## 9. Order summary for the user to paste

Give the user this block, filled in, to paste into "Anything else we should know?" on https://stickers.cy/quote/ with the files attached:

```
Product:        (die-cut stickers / sticker sheet / labels / window graphic / banner / sign / object)
Finished size:  ___ x ___ mm      Quantity: ___
Material:       (white vinyl / clear vinyl / paper / banner / acrylic / PVC foam / aluminium composite / wood / my own item)
White ink:      (none / under the art / whole sticker)      Gloss: (none / on ___ / whole)
Cut:            (die-cut to shape, ___ mm border / kiss-cut sheet / no cut)
Use:            (indoors / outdoors / inside glass, reverse print / outside glass / vehicle / packaging)
Files:          (names of the files attached)
Notes:          (colours to match, deadline, anything else)
```

stickers.cy: Industrial Zone 1, Ormideia 7530, Larnaca, Cyprus · hello@stickers.cy · +357 24 010 777
