Clean start: purge history, track binaries with Git LFS

.gitattributes

@@ -0,0 +1,2 @@
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+poetry.lock
+/.gradio
+/.copaint/__pycache__

README.md

@@ -0,0 +1,35 @@
+# COPAINT
+TLDR: From generated Image -> Copaint PDF
+<!-- insert image data/demo.png -->
+[![demo](data/demo.jpg)](data/demo.jpg)
+
+
+## Usage and Install
+```
+# Install dependencies
+pip install torch torchvision reportlab PyPDF2 Pillow argparse  gradio_pdf
+
+# Run
+python copaint.py --input_image data/bear.jpg --copaint_logo data/logo_copaint.jpg --outputfolder output
+
+# Using the CLI
+pip install --upgrade pip
+pip install -e .
+
+# Case 1 : generate all the presets
+copaint --input_image data/bear.jpg --copaint_logo data/logo_copaint.jpg --outputfolder output --use_presets True
+
+# Case 2 : provide a number of participants, the program will generate the best grid
+copaint --input_image data/bear.jpg --copaint_logo data/logo_copaint.jpg --outputfolder output --nparticipants 45 
+
+# Case 3 : provide the number of cells in the grid
+copaint --input_image data/bear.jpg --copaint_logo data/logo_copaint.jpg --outputfolder output --h_cells 3 --w_cells 4
+```
+
+## Build and deploy
+```
+# Build
+poetry build
+# Deploy
+poetry publish
+```

app.py

@@ -0,0 +1,20 @@
+import argparse
+from copaint.gradio_ui import build_gradio_ui
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-s", "--share",
+        action=argparse.BooleanOptionalAction,  # enables --share / --no-share
+        default=True,
+        help="Share the app publicly (default: true)"
+    )
+    args = parser.parse_args()
+
+    demo = build_gradio_ui()
+    demo.launch(share=args.share)
+
+
+if __name__ == "__main__":
+    main()

copaint/cli.py

@@ -0,0 +1,173 @@
+import argparse
+from copaint.copaint import image_to_pdf 
+# from copaint import image_to_copaint_pdf 
+from PIL import Image
+import numpy as np
+import random
+actual_participants_over_participants = 0.7 # how many people actually show up compared to the number of participants
+
+# Default list of identifiers
+default_identifiers = [
+    "sunshine",
+    "bliss",
+    "smile",
+    "serenity",
+    "laughter",
+    "breeze",
+    "harmony",
+    "glee",
+    "cheer",
+    "delight",
+    "hope",
+    "sparkle",
+    "kindness",
+    "charm",
+    "grace",
+    "radiance",
+    "jubilee",
+    "flutter",
+    "playful",
+    "whimsy",
+    "gleam",
+    "glow",
+    "twinkle",
+    "love",
+    "joy",
+    "peace",
+    "cheeky",
+    "amity",
+    "blissful",
+    "grateful"
+]
+
+# Function to get a default identifier (random or specified)
+def default_identifier(index=None):
+    """
+    Get a default identifier from the list.
+    
+    Args:
+        index: Optional index to get a specific identifier.
+              If None, returns a random identifier.
+    
+    Returns:
+        str: A default identifier
+    """
+    if index is not None and 0 <= index < len(default_identifiers):
+        return default_identifiers[index]
+    return random.choice(default_identifiers)
+
+def get_grid_size(nparticipants, input_image):
+    """ Takes the number of participants and the input image and returns the grid size, with the objective of making each cell as square as possible."""
+    # get the dimensions of the input image, load with PIL
+    input_image = Image.open(input_image)
+    w, h = input_image.size
+    n_cell = nparticipants * actual_participants_over_participants
+    aspect_ratio = w/h
+    h_cells = np.sqrt(aspect_ratio * n_cell)
+    w_cells = aspect_ratio * h_cells
+    
+    """ 
+    We have the following equations:
+    (1) w_cells/h_cells = aspect_ratio (as close as possible up to w_cells and h_cells being integers)
+    (2) h_cells * w_cells = n_cell
+    
+    Solving to 
+    (1) w_cells = aspect_ratio * h_cells
+    # replace in (2)
+    (2) h_cells * aspect_ratio * h_cells = n_cell
+    Leads to (3) h_cells^2 * aspect_ratio = n_cell
+    Leads to h_cells = sqrt(n_cell / aspect_ratio)
+    """
+    h_cells = np.round(np.sqrt(n_cell / aspect_ratio))
+    w_cells = np.round(aspect_ratio * h_cells)
+    
+    # convert to integers
+    h_cells = int(h_cells)
+    w_cells = int(w_cells)
+    
+    
+    print(f"Using {h_cells} x {w_cells} = {h_cells*w_cells} grid size for a canvas of size {h}*{w} and {nparticipants} participants (actual {n_cell})")
+    return int(h_cells), int(w_cells)
+
+def main():
+    parser = argparse.ArgumentParser(description='CoPaint')
+    parser.add_argument('--input_image', type=str, default='./data/bear.png', help='input image')
+    parser.add_argument('--copaint_logo', type=str, default='./data/logo_copaint.png', help='copaint logo')
+    parser.add_argument('--outputfolder', type=str, default='output/', help='output image')
+    parser.add_argument('--nparticipants', type=int, help='number of participants', default=None)
+    parser.add_argument('--h_cells', type=int, help='number of cells in height', default=None)
+    parser.add_argument('--w_cells', type=int, help='number of cells in width', default=None)
+    parser.add_argument('--unique_identifier', type=str, help='unique identifier like Mauricette, in case users are doing multiple copaint at the same time, to avoid mixing the tiles', default=None)
+    parser.add_argument('--cell_size_in_cm', type=float,  default=None, help='size of a cell in cm, for printing purposes')
+    parser.add_argument('--use_presets', action='store_true', help='use a couple of presets cuts based on the size of the number of people attending')
+    parser.add_argument('--a4', action='store_true',  help='use A4 format for the pdf')
+    parser.add_argument('--high_res', action='store_true',  help='save in high resolution mode (PNG format without resizing)')
+    parser.add_argument('--min_cell_size_in_cm', type=int, default=2, help='minimum size of cells in cm')
+    parser.add_argument('--debug', action='store_true',  help='debug mode')
+    
+    # done adding arguments
+    args = parser.parse_args()
+
+    
+    if args.unique_identifier is None:
+        # select one at random
+        idx = np.random.choice(len(default_identifiers), 1)
+        args.unique_identifier = default_identifiers[idx[0]]
+    
+    presets = [
+        [2, 3], #  6 people
+        [3, 3], #  9 people
+        [3, 4], # 12 people
+        [4, 4], # 16 people
+        [4, 5], # 20 people
+        [4, 6], # 24 people
+        [5, 6], # 30 people
+        [6, 8], # 48 people
+        [7, 9],  # 63 people
+        [7, 10], # 70 people
+        [8, 10], # 80 people
+        [8, 12],  # 96 people
+    ]
+    preset_number_of_guests = [presets[i][0]*presets[i][1] for i in range(len(presets))]
+    
+    # generate all presets
+    if args.use_presets:
+        # disregard other parameters and use the presets
+        # assert other parameters are not set
+        assert(args.h_cells is None), "When using presets, the number of H cells can't be set"
+        assert(args.w_cells is None), "When using presets, the number of W cells can't be set"
+        assert(args.nparticipants is None), "When using presets, the number of participants can't be set"
+        
+        for preset in presets:        
+            image_to_pdf(args.input_image, args.copaint_logo, args.outputfolder, preset[0], preset[1], 
+                                unique_identifier=args.unique_identifier, cell_size_in_cm=args.cell_size_in_cm, 
+                                a4=args.a4, high_res=args.high_res, min_cell_size_in_cm=args.min_cell_size_in_cm, debug=args.debug)
+    
+    # generate a copaint pdf based on the number of participants
+    elif args.nparticipants:
+        # assert other parameters are not set
+        assert(args.h_cells is None), "When choosing via number of participants, the number of H cells can't be set"
+        assert(args.w_cells is None ), "When choosing via number of participants, the number of W cells can't be set"
+        
+        # get the grid size based on the number of participants
+        h_cells, w_cells = get_grid_size(args.nparticipants, args.input_image)
+        image_to_pdf(args.input_image, args.copaint_logo, args.outputfolder, h_cells, w_cells, 
+                            unique_identifier=args.unique_identifier, cell_size_in_cm=args.cell_size_in_cm, 
+                            a4=args.a4, high_res=args.high_res, min_cell_size_in_cm=args.min_cell_size_in_cm, debug=args.debug)
+
+        # # Depracated find the first preset that can accomodate the number of participants
+        # preset_number_of_guests_inflated_by_losers = actual_participants_over_participants*args.nparticipants
+        # for i, preset in enumerate(presets):
+        #     if preset_number_of_guests_inflated_by_losers <= preset_number_of_guests[i]:
+        #         print(f"Using preset {preset} for {args.nparticipants} participants")
+        #         image_to_copaint_pdf(args.input_image, args.copaint_logo, args.outputfolder, preset[0], preset[1])
+        #         break
+    
+    # Generate the copaint pdf using the specified number of cells
+    else:        
+        image_to_pdf(args.input_image, args.copaint_logo, args.outputfolder, args.h_cells, args.w_cells, 
+                            unique_identifier=args.unique_identifier, cell_size_in_cm=args.cell_size_in_cm, 
+                            a4=args.a4, high_res=args.high_res, min_cell_size_in_cm=args.min_cell_size_in_cm, debug=args.debug)
+    
+if __name__ == '__main__':
+    main()

copaint/copaint.py

@@ -0,0 +1,574 @@
+# cc @2024  COPAINT
+# troubleshooting: groueix@copaint.com
+
+"""
+# usage
+python copaint.py --input data/input_design.png --back data/back_design.png --outputfolder output
+
+# install dependencies
+pip install torch torchvision reportlab PyPDF2 Pillow argparse 
+
+# if you are using a mac, you might need to install cairosvg and cairo to load SVG files
+pip install cairosvg ; brew install cairo libffi
+export PKG_CONFIG_PATH="/usr/local/lib/pkgconfig:/opt/homebrew/lib/pkgconfig:$PKG_CONFIG_PATH"
+export DYLD_LIBRARY_PATH="/usr/local/lib:/opt/homebrew/lib:$DYLD_LIBRARY_PATH"
+"""
+
+
+import argparse
+import os
+import numpy as np
+import torchvision
+import torch
+import time  # Add this import for timing
+from reportlab.pdfgen import canvas
+from reportlab.lib.pagesizes import letter, A4
+from reportlab.lib.units import inch
+import PyPDF2
+
+from functools import lru_cache
+from matplotlib import font_manager
+
+from PIL import Image, ImageDraw, ImageFont
+Image.MAX_IMAGE_PIXELS = None  # Removes the limit entirely
+fromPIltoTensor = torchvision.transforms.ToTensor()
+fromTensortoPIL = torchvision.transforms.ToPILImage()
+
+
+@lru_cache(maxsize=1)
+def get_font(debug=False) -> str:
+    """
+    Get the path to the Bradley Hand font, cached after first call.
+    """
+    start_time = time.time()
+    good_font_options = ["Avenir Next", "HelveticaNeue", "AdobeClean-Regular", "Arial"] # "Bradley Hand"
+    font_paths = ["/System/Library/Fonts/Avenir Next.ttc"]
+    for font_path in font_paths:
+        if os.path.exists(font_path):
+            print(f"Found '{font_path}' font")
+            return font_path
+    
+    available_fonts = font_manager.findSystemFonts(fontpaths=None, fontext='ttf')
+    font_path = None
+    for good_font in good_font_options:
+        font_path = next((font for font in available_fonts if good_font in font), None)
+        if font_path:
+            print(f"Found '{good_font}' font: {font_path}")
+            break
+
+    if font_path is None:
+        font_path = available_fonts[0]
+        print(f"No good fonts found. Using default: {font_path}")
+        print("Please install one of the recommended fonts.")
+
+    if debug:
+        print(f"Font loading took {time.time() - start_time:.4f} seconds")
+    return font_path
+
+font_path = get_font()
+
+
+def load_image(image_path, debug=False):
+    """ Load an image from a file path and return a tensor. """
+    start_time = time.time()
+    # check if the path exists
+    assert os.path.exists(image_path), f"File not found: {image_path}"
+    # check if the file is an SVG
+    if image_path.endswith(".svg"):
+        import cairosvg
+        import io
+        # Convert SVG to PNG
+        with open(image_path, "rb") as svg_file:
+            png_data = cairosvg.svg2png(file_obj=svg_file)
+        # Load the PNG data into a Pillow Image
+        image = Image.open(io.BytesIO(png_data))
+        # display
+        # image.show()
+    else:
+        image = Image.open(image_path)
+    
+    image_open_time = time.time()
+    if debug:
+        print(f"Image opening took {image_open_time - start_time:.4f} seconds")
+    
+    image = fromPIltoTensor(image).unsqueeze(0)
+    print(f"Loaded image of shape {image.shape}, from {image_path}")
+    # resize to low res for testing
+    # image = torch.nn.functional.interpolate(image, size=1000)
+    
+    if debug:
+        print(f"Image to tensor conversion took {time.time() - image_open_time:.4f} seconds")
+        print(f"Total image loading took {time.time() - start_time:.4f} seconds")
+    return image
+
+
+def save_image(tensor, image_path, debug=False):
+    """ Save a tensor to an image file. """
+    start_time = time.time()
+    print(f"Saving image of shape {tensor.shape} to {image_path}")
+    image = fromTensortoPIL(tensor.squeeze(0))
+    conversion_time = time.time()
+    if debug:
+        print(f"Tensor to PIL conversion took {conversion_time - start_time:.4f} seconds")
+    
+    image.save(image_path)
+    if debug:
+        print(f"Image saving took {time.time() - conversion_time:.4f} seconds")
+        print(f"Total save_image took {time.time() - start_time:.4f} seconds")
+
+
+def save_tensor_to_pdf(tensor, pdf_path, is_front=True, margin=0.25, img_small_side_in_cm=None, a4=False, high_res=False, scale=None, debug=False):
+    """
+    Save a tensor to a PDF, the tensor is assumed to be a single image, and is centered on the page.
+    """
+    start_time = time.time()
+    image = fromTensortoPIL(tensor.squeeze(0))
+    img_width, img_height = image.size    
+    # 1 Inch = 72 Points : ad-hoc metric used in typography and the printing industry.
+    # The US Letter format is US Letter size: 8.5 by 11 inches
+    W, H = 8.5, 11 # the unit is inch
+    if a4:
+        print("Using A4 format")
+        W, H = 8.27, 11.69 # the unit is inch
+    
+    page_width_in_pt = (W - 2*margin) * inch
+    page_height_in_pt = (H - 2*margin) * inch
+
+    
+    img_small_side_in_pt = None
+    img_large_side_in_pt = None
+    if img_small_side_in_cm is not None:
+        img_small_side_in_pt = img_small_side_in_cm * inch * 0.393701 # 1 cm = 0.393701 inches
+        img_large_side_in_pt = img_small_side_in_pt * max(img_width, img_height) / min(img_width, img_height)
+        assert(img_small_side_in_pt < page_width_in_pt and img_large_side_in_pt < page_height_in_pt), f"Cell size in cm is too large for the page, max in pt unit is {page_width_in_pt}x{page_height_in_pt}, got {img_small_side_in_pt}x{img_large_side_in_pt}. It looks you manually set the size of the cell in cm, but the image is too large for the page, try a smaller cell size."
+        
+    
+    print(f"Saving tensor of shape {tensor.shape} to {pdf_path}")
+    
+    # Convert tensor to image
+    t1 = time.time()
+    if debug:
+        print(f"Tensor to PIL conversion took {time.time() - t1:.4f} seconds")
+    
+    t2 = time.time()
+    # Check if image should be rotated
+    scale_1, rotated = None, True
+    if scale is not None:
+        scale_1, rotated = scale
+        
+    if image.width > image.height  and rotated:
+        print("Rotating image. Size in pixels: ", image.width, image.height)
+        image = image.rotate(90, expand=True)
+        print("Rotated image. Size in pixels: ", image.width, image.height)
+        img_width, img_height = image.width, image.height
+        rotated = True
+    else:
+        rotated = False
+    # check if it's better to maxout width or height
+
+
+    if scale_1 is None:
+        if img_small_side_in_pt is not None:
+            scale_1 = img_small_side_in_pt / min(img_width, img_height) # this might go over the page
+        else:    
+            # Calculate the scaling factor to fit the image within the page
+            scale_width = page_width_in_pt / img_width
+            scale_height = page_height_in_pt / img_height
+            scale_1 = min(scale_width, scale_height)  # Choose the smaller scale to preserve aspect ratio
+        
+    # Calculate the resized image dimensions
+    new_width = img_width * scale_1
+    new_height = img_height * scale_1
+
+    # Calculate offsets to center the image on the page
+    x_offset = (page_width_in_pt - new_width) // 2
+    y_offset = (page_height_in_pt - new_height) // 2
+    if debug:
+        print(f"Image calculations took {time.time() - t2:.4f} seconds")
+    
+    # Save image to PDF
+    t3 = time.time()
+    # Use PNG for high-res mode instead of JPG
+    image_path = "temp.png" if high_res else "temp.jpg"
+    image.save(image_path)
+    if debug:
+        print(f"Temporary image saving took {time.time() - t3:.4f} seconds")
+    
+    # Create a PDF
+    t4 = time.time()
+    if a4:
+        c = canvas.Canvas(pdf_path, pagesize = A4)
+    else:
+        c = canvas.Canvas(pdf_path, pagesize = letter)
+    c.drawImage(image_path, x_offset+margin*inch, y_offset+margin*inch, width=new_width, height=new_height, preserveAspectRatio=True)
+    c.save()
+    if debug:
+        print(f"PDF creation took {time.time() - t4:.4f} seconds")
+    
+    os.remove(image_path)
+    if debug:
+        print(f"Total PDF saving took {time.time() - start_time:.4f} seconds")
+    return pdf_path, (scale_1, rotated)
+
+
+def merge_pdf_list(pdfs, output_path, debug=False): 
+    """ Merge a list of PDFs into a single PDF. """     
+    start_time = time.time()
+    merger = PyPDF2.PdfMerger()
+    for pdf in pdfs:
+        merger.append(pdf)
+    merger.write(output_path)
+    merger.close()
+    if debug:
+        print(f"PDF merging took {time.time() - start_time:.4f} seconds")
+    return output_path
+
+
+def create_image_with_text(text: str = "1", size: int = 400, underline: bool = True, debug=False) -> torch.Tensor:
+    """ Create an image with text using PIL. Returns a torch tensor. """
+    start_time = time.time()
+    # Create a blank image (200x200 pixels, white background)
+    if isinstance(size, int):
+        size = (size, size)
+    image = Image.new("RGB", size, "white")
+    
+    # Create a drawing object
+    draw = ImageDraw.Draw(image)
+
+    # Set the font (optional)
+    try:
+        font = ImageFont.truetype(font_path, size=int(size[1]/1.3))  # Ensure the font is available
+    except IOError:
+        font = ImageFont.load_default() 
+        # turn size to 100
+        
+    # Use textbbox to measure the text dimensions
+    visual_bbox = draw.textbbox((0, 0), text, font=font)    
+    # (-4, 101, 340, 260)
+    text_width = visual_bbox[2] - visual_bbox[0]  # Width of the text
+    text_height = visual_bbox[3] - visual_bbox[1]  # Height of the text
+
+    center_point = (size[0] // 2, size[1] // 2)
+    top_left_of_BB = (center_point[0] - text_width // 2, center_point[1] - text_height // 2)
+    baseline = (top_left_of_BB[0] - visual_bbox[0], top_left_of_BB[1] - visual_bbox[1])
+    visual_bbox = draw.textbbox(baseline, text, font=font)
+    # draw.rectangle(visual_bbox, outline="red", width=2)
+    # print(f" text {text} Text width: {text_width}, Text height: {text_height}", f"Image width: {image.width}, Image height: {image.height}", f"Text position: {baseline}")
+
+    # # Draw the text
+    draw.text(baseline, text, fill="black", font=font)
+    
+    if underline:
+        # # Add a line under the text
+        x = baseline[0]
+        y = visual_bbox[3] + 20
+        draw.line((x, y, x+text_width, y), fill="black", width=5)
+
+    tensor = fromPIltoTensor(image).unsqueeze(0)
+    
+    if debug and len(text) <= 2:  # Only log for short texts (cell numbers) when debugging
+        print(f"Creating image with text '{text}' took {time.time() - start_time:.4f} seconds")
+    return tensor
+
+
+def create_back_image(h, w, h_cells, w_cells, logo_image, unique_identifier, list_of_cell_idx=None, debug=False):
+    """
+    Create back image tensor, of size hxw - 
+    Black pixels at the separation of cells to draw the lines
+    The logo is in each cell, with the cell number underlined
+    logo_image : tensor of size 1x3xhxw
+    """
+    print(f"Creating back image of size {h}x{w} for {h_cells}x{w_cells} cells")
+    start_time = time.time()
+    num_channels = 3 # do not consider the alpha channel
+    back_image = torch.ones(1, num_channels, h, w)
+    # cell size in pixels
+    cell_h = h // h_cells
+    cell_w = w // w_cells
+    # hyperparameters controlling the thickness of the lines and the logo size
+    line_thickness = min(cell_h, cell_w) // 100
+    logo_size = min(cell_h, cell_w) // 4
+    logo_offset = min(cell_h, cell_w) // 50
+    number_size = min(cell_h, cell_w) // 2
+    
+    if debug:
+        print(f"thickness of the lines: {line_thickness}")
+        print(f"Initialization took {time.time() - start_time:.4f} seconds")
+    
+    # Create the grid lines
+    grid_start_time = time.time()
+    line_half_thickness = line_thickness // 2
+    for i in range(h_cells):
+        for j in range(w_cells):
+            h0 = i * cell_h # height start
+            h1 = (i + 1) * cell_h # height end
+            w0 = j * cell_w # width start
+            w1 = (j + 1) * cell_w # width end
+            
+            if h0+line_half_thickness < h:
+                back_image[:, :num_channels, h0:(h0+line_half_thickness), :] = 0
+            if w0+line_half_thickness < w:
+                back_image[:, :num_channels, :, w0:(w0+line_half_thickness)] = 0
+            if h1 - line_half_thickness > 0:
+                back_image[:, :num_channels, (h1-line_half_thickness):h1, :] = 0
+            if w1  - line_half_thickness > 0:
+                back_image[:, :num_channels, :, (w1-line_half_thickness):w1] = 0
+    if debug:
+        print(f"Creating grid lines took {time.time() - grid_start_time:.4f} seconds")
+    
+    # Resize logo for all cells
+    logo_resize_time = time.time()
+    _, _, h, w = logo_image.size()
+    scale_logo = min(logo_size / h, logo_size / w)
+    new_h, new_w = int(h * scale_logo), int(w * scale_logo)
+    logo_image_resized = torch.nn.functional.interpolate(logo_image, size=(new_h, new_w), mode='bilinear')
+    
+    if debug:
+        print(f"Logo resizing took {time.time() - logo_resize_time:.4f} seconds")
+    
+    # Add content to cells
+    cell_content_time = time.time()
+    letscopaint = create_image_with_text("@letscopaint", underline=False, 
+                                                    size=(int(0.8*number_size), number_size//8), 
+                                                    debug=debug)
+    for i in range(h_cells):
+        for j in range(w_cells):
+            h0 = i * cell_h # height start
+            h1 = (i + 1) * cell_h # height end
+            w0 = j * cell_w # width start
+            w1 = (j + 1) * cell_w # width end
+            
+            # add logo at the bottom right of the cell
+            logo_size_h, logo_size_w = logo_image_resized.shape[2:]
+            back_image[:, :, h1-logo_size_h-logo_offset:h1-logo_offset, w1-logo_size_w-logo_offset:w1-logo_offset] = logo_image_resized[:, :num_channels, :, :]
+            
+            # add cell number at the center of the cell
+            # invert cell number to match the order of the canvas. 1 is at the top right, and w_cells is at the top left
+            if list_of_cell_idx is not None:
+                print(f"list_of_cell_idx: {list_of_cell_idx}")
+            if list_of_cell_idx is not None:
+                cell_number = list_of_cell_idx[i*w_cells+j]
+            else:
+                cell_number = i*w_cells+(w_cells-j)
+            image_with_number = create_image_with_text(f"{cell_number}", size=number_size, debug=debug)
+            start_h_big = h0 + (h1 - h0) // 2 - number_size // 2
+            start_w_big = w0 + (w1 - w0) // 2 - number_size // 2
+            back_image[:, :, start_h_big:start_h_big+number_size, start_w_big:start_w_big+number_size] = image_with_number[:, :num_channels, :, :]
+            
+            # add unique identifier
+            unique_identifier_size_w = number_size
+            unique_identifier_size_h = number_size // 4
+            image_with_unique_identifier = create_image_with_text(unique_identifier, underline=False, 
+                                                                size=(unique_identifier_size_w, unique_identifier_size_h), 
+                                                                debug=debug)
+            start_h = h0 + unique_identifier_size_h // 2 # Fix
+            start_w = w0 + unique_identifier_size_h // 2 # Fix
+            back_image[:, :, start_h:start_h+unique_identifier_size_h, start_w:start_w+unique_identifier_size_w] = image_with_unique_identifier[:, :num_channels, :, :]
+            
+            start_letscopaint_h = h1-logo_offset # Fix
+            start_letscopaint_w = w0 + unique_identifier_size_h // 16 # Fix
+            back_image[:, :, start_letscopaint_h-(number_size//8):start_letscopaint_h, start_letscopaint_w:start_letscopaint_w+(int(0.8*number_size))] = letscopaint[:, :num_channels, :, :]
+    
+    if debug:
+        print(f"Adding content to cells took {time.time() - cell_content_time:.4f} seconds")
+        print(f"Created back image of shape {back_image.shape}")
+        print(f"Total back image creation took {time.time() - start_time:.4f} seconds")
+    return back_image
+
+
+def image_to_pdf_core(input_image, file_name, logo_image, outputfolder, h_cells, w_cells, unique_identifier="Mauricette", cell_size_in_cm=None, a4=False, high_res=False, list_of_cell_idx=None, scale=None,  debug=False):
+    overall_start_time = time.time()
+    os.makedirs(outputfolder, exist_ok=True)
+    scale_1, scale_2, scale_3, scale_4 = None, None, None, None
+    if scale is not None:
+        scale_1, scale_2, scale_3, scale_4 = scale
+        
+    # Load image
+    t1 = time.time()
+    if not isinstance(input_image, torch.Tensor):
+        image = load_image(input_image, debug=debug)
+    else:
+        image = input_image
+  
+    _, c, h, w = image.shape
+    print(f"Image shape: {image.shape}")
+    logo_image = load_image(logo_image, debug=debug)
+    if debug:
+        print(f"Image loading took {time.time() - t1:.4f} seconds")
+    
+    # # Quick check that the greatest dimension corresponds to the greatest number of cells
+    # if h > w and h_cells < w_cells:
+    #     print("Swapping h_cells and w_cells")
+    #     h_cells, w_cells = w_cells, h_cells
+    # elif w > h and w_cells < h_cells:
+    #     print("Swapping h_cells and w_cells")
+    #     h_cells, w_cells = w_cells, h_cells
+    
+    # Create back image
+    t2 = time.time()
+    multiplier_w = max(1,  10000 // w)
+    multiplier_h = max(1,  10000 // h)
+    if scale_3 is None:
+        scale_3 = max(multiplier_w, multiplier_h)
+
+    print(f"Creating back image with {h*scale_3} x {w*scale_3} pixels for {h_cells} x {w_cells} cells")
+    back_image = create_back_image(h*scale_3, w*scale_3, h_cells, w_cells, logo_image, 
+                                  unique_identifier=unique_identifier, list_of_cell_idx=list_of_cell_idx,  debug=debug)
+    if debug:
+        save_image(back_image, os.path.join(outputfolder, "back_image.png"), debug=debug)
+        print(f"Back image creation and saving took {time.time() - t2:.4f} seconds")
+    
+    # Save to PDF
+    t3 = time.time()
+    os.makedirs(outputfolder, exist_ok=True)
+    output_path_front = os.path.join(outputfolder, "output_front.pdf")
+    output_path_back = os.path.join(outputfolder, "output_back.pdf")
+    
+    img_small_side_in_cm = None
+    if cell_size_in_cm is not None:       
+        # Why Min? Cells are not neccearily square, depending on the aspect ratio of the image, and the number of H and W cells, so we assume cell_size_in_cm is the smallest side of the cell.
+        print(f"cell_size_in_cm: {cell_size_in_cm}")
+        min_cells = min(h_cells, w_cells)
+        img_small_side_in_cm = cell_size_in_cm * min_cells # smallest side in cm.
+
+    # print image and back image shapes
+    if debug:
+        print(f"Image shape: {image.shape}")
+        print(f"Back image shape: {back_image.shape}")
+    
+    # Only resize back image if not high-res
+    if not high_res:
+        back_image_h, back_image_w = back_image.shape[2:]
+        scale_h = 4096 / back_image_h
+        if scale_4 is None:
+            scale_4 = scale_h
+        back_image = torch.nn.functional.interpolate(back_image, scale_factor=scale_4, mode='bilinear')
+    
+    
+
+    _, scale_1 = save_tensor_to_pdf(image, output_path_front, is_front=True, img_small_side_in_cm=img_small_side_in_cm, a4=a4, high_res=high_res, scale=scale_1, debug=debug)
+    _, scale_2 = save_tensor_to_pdf(back_image, output_path_back, is_front=False, img_small_side_in_cm=img_small_side_in_cm, a4=a4, high_res=high_res, scale=scale_2, debug=debug)
+    
+    scale = (scale_1 , scale_2, scale_3, scale_4)     
+    if debug:
+        print(f"PDF creation took {time.time() - t3:.4f} seconds")
+    
+    # concatenate pdfs
+    t4 = time.time()
+    print("Concatenating PDFs")
+
+    output_path = os.path.join(outputfolder, f"{file_name}_{h_cells}x{w_cells}_copaint.pdf")
+    merge_pdf_list([output_path_front, output_path_back], output_path, debug=debug)
+    # clean unnecessary files
+    os.remove(output_path_front)
+    os.remove(output_path_back)
+    if debug:
+        print(f"PDF concatenation and cleanup took {time.time() - t4:.4f} seconds")
+    
+    print(f"Total processing time: {time.time() - overall_start_time:.4f} seconds")
+    print(f"Done! Output saved to {output_path}")
+    return output_path, scale
+    
+    
+def image_to_pdf(input_image, logo_image, outputfolder, h_cells, w_cells, unique_identifier="Mauricette", cell_size_in_cm=None, a4=False, high_res=False, min_cell_size_in_cm=2, list_of_cell_idx=None, debug=False):
+    """
+    Create a copaint PDF from an image and a logo.
+    """
+    print(f"h_cells: {h_cells}, w_cells: {w_cells}, a4: {a4}")
+
+    image = load_image(input_image, debug=debug)
+    _, c, h, w = image.shape  
+
+    file_name = os.path.basename(input_image)
+    
+    # Check if the image needs to be split to fit in the page.
+    
+    if cell_size_in_cm is not None:
+        min_cell_size_in_cm = cell_size_in_cm
+        
+    # The US Letter format is US Letter size: 8.5 by 11 inches
+    W, H = 8.5, 11 # the unit is inch
+    if a4:
+        print("Using A4 format")
+        W, H = 8.27, 11.69 # the unit is inch
+    
+    margin = 0.25 # hardcoded margin
+    page_width_in_pt = (W - 2 * margin) * inch
+    page_height_in_pt = (H - 2 * margin) * inch
+    
+    max_cell_per_page_h = h_cells
+    max_cell_per_page_w = w_cells
+    
+    established_cell_size = False
+    while not established_cell_size:
+        img_small_side_in_pt = min(max_cell_per_page_h, max_cell_per_page_w) * min_cell_size_in_cm * inch * 0.393701 # 1 cm = 0.393701 inches
+        minimum_is_width = min(w, h) == w
+        img_large_side_in_pt = img_small_side_in_pt * max(w, h) / min(w, h)
+        print(f"img_small_side_in_pt: {img_small_side_in_pt}, img_large_side_in_pt: {img_large_side_in_pt}")
+        print(f"page_width_in_pt: {page_width_in_pt}, page_height_in_pt: {page_height_in_pt}")
+        if img_large_side_in_pt < page_height_in_pt and img_small_side_in_pt < page_width_in_pt:
+            established_cell_size = True
+        
+        else:
+            max_cell_per_page_h = max_cell_per_page_h // 2
+            max_cell_per_page_w = max_cell_per_page_w // 2    
+        
+        print(f"Decreasing max_cell_per_page to {max_cell_per_page_h}x{max_cell_per_page_w}")            
+    
+    
+    divide_factor_h = int(np.ceil(h_cells / max_cell_per_page_h))
+    divide_factor_w = int(np.ceil(w_cells / max_cell_per_page_w))
+    
+    print(f"divide_factor_h: {divide_factor_h}, divide_factor_w: {divide_factor_w}")
+    copaint_pdfs = []
+    scale = None
+    for i in range(divide_factor_h):
+        for j in range(divide_factor_w):
+            cell_h_start = i * max_cell_per_page_h
+            cell_h_end = min((i + 1) * max_cell_per_page_h, h_cells)
+            cell_w_start = j * max_cell_per_page_w
+            cell_w_end = min((j + 1) * max_cell_per_page_w, w_cells)
+            list_of_cell_idx = [cell_h_idx * w_cells + (w_cells-cell_w_idx) for cell_h_idx in range(cell_h_start, cell_h_end) for cell_w_idx in range(cell_w_start, cell_w_end)]
+            
+            print(f"cell_h_start: {cell_h_start}, cell_h_end: {cell_h_end}, cell_w_start: {cell_w_start}, cell_w_end: {cell_w_end}")
+            h_cells_new = cell_h_end - cell_h_start
+            w_cells_new = cell_w_end - cell_w_start
+            file_name_new = f"{file_name}_{i}x{j}"
+            
+            px_h_start = int(cell_h_start * h / h_cells)
+            px_h_end = int(cell_h_end * h / h_cells)
+            px_w_start = int(cell_w_start * w / w_cells)
+            px_w_end = int(cell_w_end * w / w_cells)
+            
+            image_new = image[:, :, px_h_start:px_h_end, px_w_start:px_w_end]
+            
+            
+            pdf_path, new_scale = image_to_pdf_core(image_new, file_name_new, logo_image, outputfolder, h_cells_new, w_cells_new, unique_identifier, cell_size_in_cm, a4, high_res,  list_of_cell_idx=list_of_cell_idx, scale=scale, debug=debug)
+            if scale is None:
+                scale = new_scale
+            copaint_pdfs.append(pdf_path)
+    
+    # Merge the copaint PDFs
+    output_path = os.path.join(outputfolder, "copaint-design.pdf")
+    merge_pdf_list(copaint_pdfs, output_path, debug=debug)
+    
+    # clean unnecessary files
+    for pdf in copaint_pdfs:
+        os.remove(pdf)
+    
+    print(f"Done! Final output saved to {output_path}")
+    return output_path
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='CoPaint')
+    parser.add_argument('--input_image', type=str, default='./data/bear.png', help='input image')
+    parser.add_argument('--copaint_logo', type=str, default='./data/logo_copaint.png', help='copaint logo')
+    parser.add_argument('--outputfolder', type=str, default='output/', help='output image')
+    parser.add_argument('--h_cells', type=int, help='number of cells in height', default=9)
+    parser.add_argument('--w_cells', type=int, help='number of cells in width', default=6)
+    parser.add_argument('--debug', action='store_true', help='show timing information')
+    
+    # done adding arguments
+    args = parser.parse_args() 
+    image_to_pdf(args.input_image, args.copaint_logo, args.outputfolder, args.h_cells, args.w_cells, cell_size_in_cm=None, debug=args.debug)

copaint/gradio_ui.py

@@ -0,0 +1,262 @@
+"""Gradio based ui for Copaint pdf generator.
+"""
+import gradio as gr
+import shutil
+import tempfile
+
+from gradio_pdf import PDF
+from importlib.resources import files
+from pathlib import Path
+
+from copaint.copaint import image_to_pdf 
+import torchvision
+import torch
+
+fromPIltoTensor = torchvision.transforms.ToTensor()
+fromTensortoPIL = torchvision.transforms.ToPILImage()
+
+
+def add_grid_to_image(image, h_cells, w_cells):
+    # image is a torch tensor of shape (3, h, w)
+    image = image.convert("RGB")
+    image = fromPIltoTensor(image)
+    grid_color = torch.tensor([16,15,46]).unsqueeze(1).unsqueeze(1) / 255.0
+    h,w = image.shape[1:]
+    thickness = max(min(1, int(min(h,w)/100)), 1)
+    print("thickness, h, w", thickness, h, w)
+    for i in range(h_cells+1):
+        idx_i = int(i*h/h_cells)
+        image[:, idx_i-thickness:idx_i+thickness, :] = grid_color
+        
+    for j in range(w_cells+1):
+        idx_j = int(j*w/w_cells)
+        image[:, :, idx_j-thickness:idx_j+thickness] = grid_color
+    image = fromTensortoPIL(image)
+
+    return image
+
+
+def canvas_ratio(image):
+    w,h = image.size
+    aspect_ratio = w/h
+    if aspect_ratio > 1:
+        aspect_ratio = 1/aspect_ratio
+    
+    # find nearest aspect ratio in the list of predefined ones 
+    predefined_aspect_ratios = [2/3, 1/2, 1/1, 5/6, 4/5, 5/7]
+    predefined_aspect_ratios_str = ["2/3", "1/2", "1/1", "5/6", "4/5", "5/7"]
+    min_diff = float('inf')
+    closest_ratio_idx = None
+    for idx, ratio in enumerate(predefined_aspect_ratios):
+        diff = abs(aspect_ratio - ratio)
+        if diff < min_diff:
+            min_diff = diff
+            closest_ratio_idx = idx
+    closest_ratio_str = predefined_aspect_ratios_str[closest_ratio_idx]
+    
+    if min_diff > 0.1:
+        return None
+    else:
+        return f"Best canvas ratio: {closest_ratio_str}"
+
+
+def add_grid_and_display_ratio(image, h_cells, w_cells):
+    if image is None:
+        return None, gr.update(visible=False)    
+    return add_grid_to_image(image, h_cells, w_cells), gr.update(visible=True, value=canvas_ratio(image))
+
+
+def process_copaint(
+    input_image, 
+    h_cells=None, 
+    w_cells=None, 
+    a4=False,
+    high_res=False,
+    cell_size_in_cm=None,
+    min_cell_size_in_cm=2,
+    copaint_name="",
+    copaint_logo=None,
+):
+    """Process the input and generate CoPaint PDF"""
+    # Create temporary directories for processing
+    temp_input_dir = tempfile.mkdtemp()
+    temp_output_dir = tempfile.mkdtemp()
+    
+    try:
+        # Save uploaded images to temp directory
+        input_path = Path(temp_input_dir) / "input_image.png"
+        input_image.save(input_path)
+        
+        logo_path = None
+        if copaint_logo is not None:
+            logo_path = Path(temp_input_dir) / "logo.png"
+            copaint_logo.save(logo_path)
+        else:
+            # Use default logo path from the package
+            logo_path = files("copaint.static") / "logo_copaint.png"
+
+        if copaint_name == "" or copaint_name is None:
+            from copaint.cli import default_identifier
+            copaint_name = default_identifier()
+
+        if a4 == "A4":
+            a4 = True
+        else:
+            a4 = False
+        
+        # Generate the PDF
+        pdf_path = image_to_pdf(
+            input_image=str(input_path), 
+            logo_image=str(logo_path), 
+            outputfolder=temp_output_dir, 
+            h_cells=h_cells, 
+            w_cells=w_cells, 
+            unique_identifier=copaint_name,
+            cell_size_in_cm=cell_size_in_cm,
+            a4=a4,
+            high_res=high_res,
+            min_cell_size_in_cm=min_cell_size_in_cm
+        )
+        
+        return pdf_path, None  # Return path and no error
+    except Exception as e:
+        # Return error message
+        return None, f"Error generating PDF: {str(e)}"
+    finally:
+        # Clean up temporary input directory
+        shutil.rmtree(temp_input_dir)
+
+
+def build_gradio_ui():
+    # Create Gradio Interface
+    with gr.Blocks(title="CoPaint Generator", theme='NoCrypt/miku') as demo:
+
+        gr.Markdown("# 🤖 CoPaint Generator")
+        gr.Markdown("Upload an image with your painting design and set grid parameters to generate a CoPaint PDF template 🖨️📄✂️ for your next collaborative painting activities. 🎨🖌️")
+
+        # --- inputs ---
+        with gr.Row(equal_height=True):
+
+            # Upload Design Template
+            with gr.Column(scale=2):
+                input_image = gr.Image(type="pil", label="Upload Your Design")
+
+            with gr.Column(scale=1):
+                # Grid
+                with gr.Tab("Grid Layout"):
+                    gr.Markdown("<div style='text-align: center; font-weight: bold;'>Squares' Grid</div>")
+                    w_cells = gr.Number(label="↔ (width)", value=4, precision=0)
+                    h_cells = gr.Number(label=" by ↕ (heigth)", value=6, precision=0)
+
+                    gr.Examples(
+                        examples=[
+                            [6, 9],
+                            [4, 6],
+                            [3, 3],
+                            [3, 4],
+                            [2, 2]
+                        ],
+                        example_labels=[
+                            "Copaint Wedding 6x9 Grid (54 squares)", 
+                            "Copaint Classic 4x6 Grid (24 squares)", 
+                            "Copaint Mini 3x3 Grid (9 squares)", 
+                            "Copaint Mini 3x4 Grid (12 squares)", 
+                            "Copaint Mini 2x2 Grid (4 squares)"],
+                        inputs=[w_cells, h_cells],
+                    )
+
+                    # Grid + Design preview
+                    gr.Markdown("<div style='text-align: center; font-weight: bold;'>Preview</div>")
+                    output_image = gr.Image(label="Squares' Grid Preview", interactive=False)
+
+                    # canvas ratio message
+                    canvas_msg =  gr.Markdown(label="Canvas Ratio", visible=False)
+
+                # PDF options
+                with gr.Tab("PDF Printing Options"):
+                    use_a4 = gr.Dropdown(choices=["US letter", "A4"], label="Paper Format", value="US letter")
+
+                    with gr.Accordion("Advanced settings (optional)", open=False):
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                high_res = gr.Checkbox(label="High Resolution Mode (>20sec long processing)")
+
+                                cell_size = gr.Number(label="Square Size, in cm (optional)",
+                                                      value="",
+                                                      info="If none is provided, the design size automatically adjusts to fit on a single page.")
+
+                                copaint_name = gr.Textbox(label="Add a Custom Design Name (optional)",
+                                                          value="",
+                                                          max_length=10,
+                                                          info="You can add a custom design name: it will appear on the back of each square, in the top left corner.")
+                                
+                                copaint_logo = gr.Image(type="pil",
+                                                        label="Add a Custom Logo (optional)")
+                                gr.Markdown(
+                                    "<div style='font-size: 0.85em;'>"
+                                    "You can add a custom logo: it will appear on the back of each square, in the bottom right corner."
+                                    "</div>")
+
+        # --- outputs ---
+        with gr.Row():
+            # PDF
+            with gr.Column(scale=1):
+                submit_btn = gr.Button("Generate Copaint PDF", variant="primary")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                output_file = gr.File(label="Download PDF", visible=False, interactive=False)
+            with gr.Column(scale=1):
+                output_error_msg = gr.Textbox(label="Error Message", visible=False)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                output_pdf = PDF(label="PDF Preview")
+
+        # Update output_image: trigger update when any input changes
+        input_image.change(
+                fn=add_grid_and_display_ratio,
+                inputs=[input_image, h_cells, w_cells],
+                outputs=[output_image, canvas_msg]
+            )
+        for component in [h_cells, w_cells]:
+            component.change(
+                fn=add_grid_to_image,
+                inputs=[input_image, h_cells, w_cells],
+                outputs=output_image
+            )
+
+        # Submit function: generate pdf
+        def on_submit(input_image, h_cells, w_cells, use_a4, high_res, cell_size, copaint_name, copaint_logo):
+            if input_image is None:
+                return None, None, gr.update(visible=True, value="Please upload an image first 👀")
+            
+            if cell_size is None or cell_size == "" or cell_size == 0:
+                cell_size = None
+            
+            pdf_path, error = process_copaint(
+                input_image=input_image,
+                h_cells=int(h_cells),
+                w_cells=int(w_cells),
+                a4=use_a4,
+                high_res=high_res,
+                cell_size_in_cm=cell_size if cell_size else None,
+                min_cell_size_in_cm=float(2),
+                copaint_name=copaint_name,
+                copaint_logo=copaint_logo
+            )
+                
+            if error:
+                # Show error message
+                return None, None, gr.update(visible=True, value=error)
+            else:
+                # Show successful PDF
+                return pdf_path, gr.update(visible=True, value=pdf_path, interactive=False), gr.update(visible=False)
+        
+        submit_btn.click(
+            on_submit,
+            inputs=[input_image, h_cells, w_cells, use_a4, high_res, cell_size, copaint_name, copaint_logo],
+            outputs=[output_pdf, output_file, output_error_msg]
+        )
+        
+    return demo

pyproject.toml

@@ -0,0 +1,34 @@
+[tool.poetry]
+name = "copaint"
+version = "1.0.0"
+description = "A backend to go from Image to copaint PDF, using torch and Pillow."
+authors = ["Thibault Groueix <thibault.groueix.2012@polytechnique,org>"]
+license = "All rights reserved"
+readme = "README.md"
+include = [
+  "copaint/static/*"
+]
+
+[tool.poetry.dependencies]
+# pip install torch torchvision reportlab PyPDF2 Pillow argparse 
+python = ">=3.10,<4.0"
+Pillow = "^10.0.0"
+torch = "^2.0.0"  # If you're using PyTorch
+click = "^8.0.0"  # For the CLI
+torchvision = "^0.20.1"  # If you're using PyTorch
+reportlab = "^3.6.0"  # For PDF generation
+PyPDF2 = "^1.26.0"  # For PDF generation
+argparse = "^1.4.0"  # For the CLI
+matplotlib = "^3.9.2"
+
+[tool.poetry.scripts]
+copaint = "copaint.cli:main"
+copaint-app = "app:main"  # Launch Gradio UI
+
+[tool.poetry.group.ui.dependencies]
+gradio = "^5.23.3"
+gradio-pdf = "^0.0.22"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

requirements.txt

@@ -0,0 +1,13 @@
+# Core dependencies
+Pillow==10.0.0
+torch==2.0.0
+torchvision==0.20.1
+click==8.0.0
+reportlab==3.6.0
+PyPDF2==1.26.0
+argparse==1.4.0
+matplotlib==3.9.2
+
+# UI dependencies (from [tool.poetry.group.ui.dependencies])
+gradio==5.23.3
+gradio-pdf==0.0.22