looks better, can still be improved

copaint/cli.py

@@ -1,93 +1,54 @@
+"""Command line interface for Copaint pdf generator.
+"""
 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
+import logging
 
-# Default list of identifiers
+from copaint.copaint import image_to_pdf
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S'
+)
+logger = logging.getLogger(__name__)
+
+# Default identifiers for unique_identifier parameter
 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"
+    "Mauricette", "Gertrude", "Bernadette", "Henriette", "Georgette", "Antoinette", "Colette", "Suzette", "Yvette", "Paulette",
+    "Juliette", "Odette", "Marinette", "Lucette", "Pierrette", "Cosette", "Rosette", "Claudette", "Violette", "Josette"
 ]
 
-# 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 default_identifier():
+    """Return a random default identifier."""
+    return np.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
+    """Get grid size based on number of participants."""
+    # Compute the grid size based on the number of participants
+    # We want to find h_cells and w_cells such that h_cells * w_cells >= nparticipants
+    # and h_cells/w_cells is close to the aspect ratio of the image
+    from PIL import Image
+    image = Image.open(input_image)
+    w, h = image.size
     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)
     
+    # Find the smallest grid that can accommodate nparticipants
+    min_cells = int(np.ceil(np.sqrt(nparticipants)))
+    for i in range(min_cells, min_cells+10):
+        for j in range(min_cells, min_cells+10):
+            if i*j >= nparticipants:
+                ratio = j/i
+                if abs(ratio - aspect_ratio) < 0.2:
+                    logger.info(f"Found grid size {i}x{j} for {nparticipants} participants")
+                    return i, j
     
-    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)
+    # If no good ratio is found, just use the smallest grid that can accommodate nparticipants
+    h_cells = min_cells
+    w_cells = int(np.ceil(nparticipants/min_cells))
+    logger.warning(f"No good aspect ratio found. Using {h_cells}x{w_cells} grid for {nparticipants} participants")
+    return h_cells, w_cells
 
 def main():
     parser = argparse.ArgumentParser(description='CoPaint')
@@ -105,46 +66,19 @@ def main():
     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.debug:
+        logger.setLevel(logging.DEBUG)
     
     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)
+        logger.info(f"Using random identifier: {args.unique_identifier}")
     
     # generate a copaint pdf based on the number of participants
-    elif args.nparticipants:
+    if 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"
@@ -154,20 +88,12 @@ def main():
         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

@@ -25,16 +25,32 @@ from reportlab.pdfgen import canvas
 from reportlab.lib.pagesizes import letter, A4
 from reportlab.lib.units import inch
 import PyPDF2
+import logging
 
 from functools import lru_cache
 from matplotlib import font_manager
 
 from PIL import Image, ImageDraw, ImageFont
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S'
+)
+logger = logging.getLogger(__name__)
+
+# Configure debug logging based on environment variable
+logger.setLevel(logging.DEBUG)
+
 Image.MAX_IMAGE_PIXELS = None  # Removes the limit entirely
 fromPIltoTensor = torchvision.transforms.ToTensor()
 fromTensortoPIL = torchvision.transforms.ToPILImage()
 
 
+pre_loaded_images = {}
+
+
 @lru_cache(maxsize=1)
 def get_font(debug=False) -> str:
     """
@@ -45,7 +61,7 @@ def get_font(debug=False) -> str:
     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")
+            logger.info(f"Found '{font_path}' font")
             return font_path
     
     available_fonts = font_manager.findSystemFonts(fontpaths=None, fontext='ttf')
@@ -53,16 +69,16 @@ def get_font(debug=False) -> str:
     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}")
+            logger.info(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.")
+        logger.warning(f"No good fonts found. Using default: {font_path}")
+        logger.warning("Please install one of the recommended fonts.")
 
     if debug:
-        print(f"Font loading took {time.time() - start_time:.4f} seconds")
+        logger.debug(f"Font loading took {time.time() - start_time:.4f} seconds")
     return font_path
 
 font_path = get_font()
@@ -82,8 +98,6 @@ def load_image(image_path, debug=False):
             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)
         # convert to RGBA
@@ -95,32 +109,30 @@ def load_image(image_path, debug=False):
     
     image_open_time = time.time()
     if debug:
-        print(f"Image opening took {image_open_time - start_time:.4f} seconds")
+        logger.debug(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)
+    logger.info(f"Loaded image of shape {image.shape}, from {image_path}")
     
     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")
+        logger.debug(f"Image to tensor conversion took {time.time() - image_open_time:.4f} seconds")
+        logger.debug(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}")
+    logger.info(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")
+        logger.debug(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")
+        logger.debug(f"Image saving took {time.time() - conversion_time:.4f} seconds")
+        logger.debug(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):
@@ -128,13 +140,14 @@ def save_tensor_to_pdf(tensor, pdf_path, is_front=True, margin=0.25, img_small_s
     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")
+        logger.info("Using A4 format")
         W, H = 8.27, 11.69 # the unit is inch
     
     page_width_in_pt = (W - 2*margin) * inch
@@ -149,12 +162,12 @@ def save_tensor_to_pdf(tensor, pdf_path, is_front=True, margin=0.25, img_small_s
         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}")
+    logger.info(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")
+        logger.debug(f"Tensor to PIL conversion took {time.time() - t1:.4f} seconds")
     
     t2 = time.time()
     # Check if image should be rotated
@@ -163,9 +176,9 @@ def save_tensor_to_pdf(tensor, pdf_path, is_front=True, margin=0.25, img_small_s
         scale_1, rotated = scale
         
     if image.width > image.height  and rotated:
-        print("Rotating image. Size in pixels: ", image.width, image.height)
+        logger.info(f"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)
+        logger.info(f"Rotated image. Size in pixels: {image.width}, {image.height}")
         img_width, img_height = image.width, image.height
         rotated = True
     else:
@@ -190,7 +203,7 @@ def save_tensor_to_pdf(tensor, pdf_path, is_front=True, margin=0.25, img_small_s
     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")
+        logger.debug(f"Image calculations took {time.time() - t2:.4f} seconds")
     
     # Save image to PDF
     t3 = time.time()
@@ -198,7 +211,7 @@ def save_tensor_to_pdf(tensor, pdf_path, is_front=True, margin=0.25, img_small_s
     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")
+        logger.debug(f"Temporary image saving took {time.time() - t3:.4f} seconds")
     
     # Create a PDF
     t4 = time.time()
@@ -209,11 +222,11 @@ def save_tensor_to_pdf(tensor, pdf_path, is_front=True, margin=0.25, img_small_s
     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")
+        logger.debug(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")
+        logger.debug(f"Total PDF saving took {time.time() - start_time:.4f} seconds")
     return pdf_path, (scale_1, rotated)
 
 
@@ -226,7 +239,7 @@ def merge_pdf_list(pdfs, output_path, debug=False):
     merger.write(output_path)
     merger.close()
     if debug:
-        print(f"PDF merging took {time.time() - start_time:.4f} seconds")
+        logger.debug(f"PDF merging took {time.time() - start_time:.4f} seconds")
     return output_path
 
 
@@ -273,7 +286,7 @@ def create_image_with_text(text: str = "1", size: int = 400, underline: bool = T
     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")
+        logger.debug(f"Creating image with text '{text}' took {time.time() - start_time:.4f} seconds")
     return tensor
 
 
@@ -284,7 +297,7 @@ def create_back_image(h, w, h_cells, w_cells, logo_image, logo_insta_image, uniq
     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")
+    logger.info(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)
@@ -298,8 +311,8 @@ def create_back_image(h, w, h_cells, w_cells, logo_image, logo_insta_image, uniq
     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")
+        logger.debug(f"thickness of the lines: {line_thickness}")
+        logger.debug(f"Initialization took {time.time() - start_time:.4f} seconds")
     
     # Create the grid lines
     grid_start_time = time.time()
@@ -320,7 +333,7 @@ def create_back_image(h, w, h_cells, w_cells, logo_image, logo_insta_image, uniq
             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")
+        logger.debug(f"Creating grid lines took {time.time() - grid_start_time:.4f} seconds")
     
     # Resize logo for all cells
     logo_resize_time = time.time()
@@ -335,7 +348,7 @@ def create_back_image(h, w, h_cells, w_cells, logo_image, logo_insta_image, uniq
     new_h_insta, new_w_insta = int(h_insta * scale_insta), int(w_insta * scale_insta)
     logo_insta_image_resized = torch.nn.functional.interpolate(logo_insta_image, size=(new_h_insta, new_w_insta), mode='bilinear')
     if debug:
-        print(f"Logo resizing took {time.time() - logo_resize_time:.4f} seconds ({time.time() - t_insta:.4f} for insta and {t_insta - logo_resize_time:.4f} for copaint logo)")
+        logger.debug(f"Logo resizing took {time.time() - logo_resize_time:.4f} seconds ({time.time() - t_insta:.4f} for insta and {t_insta - logo_resize_time:.4f} for copaint logo)")
         # save logo_insta_image_resized
         save_image(logo_insta_image_resized, "logo_insta_image_resized.png", debug=debug)
     # Add content to cells
@@ -343,6 +356,12 @@ def create_back_image(h, w, h_cells, w_cells, logo_image, logo_insta_image, uniq
     letscopaint = create_image_with_text("copaint_art", underline=False, 
                                                     size=(int(0.8*number_size), number_size//8), 
                                                     debug=debug)
+    # 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)
     for i in range(h_cells):
         for j in range(w_cells):
             h0 = i * cell_h # height start
@@ -357,7 +376,7 @@ def create_back_image(h, w, h_cells, w_cells, logo_image, logo_insta_image, uniq
             # 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}")
+                logger.info(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:
@@ -367,12 +386,6 @@ def create_back_image(h, w, h_cells, w_cells, logo_image, logo_insta_image, uniq
             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, :, :]
@@ -388,9 +401,9 @@ def create_back_image(h, w, h_cells, w_cells, logo_image, logo_insta_image, uniq
             back_image[:, :, start_insta_h-(number_size//8):start_insta_h-(number_size//8)+h_insta, start_insta_w:start_insta_w+w_insta] = logo_insta_image_resized[:, :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")
+        logger.debug(f"Adding content to cells took {time.time() - cell_content_time:.4f} seconds")
+        logger.debug(f"Created back image of shape {back_image.shape}")
+        logger.debug(f"Total back image creation took {time.time() - start_time:.4f} seconds")
     return back_image
 
 
@@ -404,25 +417,43 @@ def image_to_pdf_core(input_image, file_name, logo_image, outputfolder, h_cells,
     # Load image
     t1 = time.time()
     if not isinstance(input_image, torch.Tensor):
-        image = load_image(input_image, debug=debug)
+        if input_image in pre_loaded_images:
+            image = pre_loaded_images[input_image]
+            logger.info(f"Loaded image from cache: {input_image}")
+        else:
+            image = load_image(input_image, debug=debug)
+            pre_loaded_images[input_image] = image
     else:
         image = input_image
     if debug:
-        print(f"Image loading took {time.time() - t1:.4f} seconds")
+        logger.debug(f"Image loading took {time.time() - t1:.4f} seconds")
     
     _, c, h, w = image.shape
-    print(f"Image shape: {image.shape}")
+    logger.info(f"Image shape: {image.shape}")
 
     t1_2 = time.time()
-    logo_image = load_image(logo_image, debug=debug)
+    if logo_image in pre_loaded_images:
+        logo_image = pre_loaded_images[logo_image]
+        logger.info(f"Loaded logo copaint image from cache: {logo_image}")
+    else:
+        logo_image = load_image(logo_image, debug=debug)
+        pre_loaded_images[logo_image] = logo_image
 
     if debug:
-        print(f"Logo copaint Image loading took {time.time() - t1_2:.4f} seconds")
+        logger.debug(f"Logo copaint Image loading took {time.time() - t1_2:.4f} seconds")
     
     t1_3 = time.time()
-    logo_insta_image = load_image("./copaint/static/logo_instagram.png", debug=debug)
+    logo_insta_path = "./copaint/static/logo_instagram.png"
+
+    if logo_insta_path in pre_loaded_images:
+        logo_insta_image = pre_loaded_images[logo_insta_path]
+        logger.info(f"Loaded logo instagram image from cache: {logo_insta_path}")
+    else:
+        logo_insta_image = load_image(logo_insta_path, debug=debug)
+        pre_loaded_images[logo_insta_path] = logo_insta_image
+        
     if debug:
-        print(f"Logo instagram Image loading took {time.time() - t1_3:.4f} seconds")
+        logger.debug(f"Logo instagram Image loading took {time.time() - t1_3:.4f} seconds")
     
     # # Quick check that the greatest dimension corresponds to the greatest number of cells
     # if h > w and h_cells < w_cells:
@@ -439,12 +470,12 @@ def image_to_pdf_core(input_image, file_name, logo_image, outputfolder, h_cells,
     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")
+    logger.info(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, logo_insta_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")
+        logger.debug(f"Back image creation and saving took {time.time() - t2:.4f} seconds")
     
     # Save to PDF
     t3 = time.time()
@@ -455,14 +486,14 @@ def image_to_pdf_core(input_image, file_name, logo_image, outputfolder, h_cells,
     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}")
+        logger.info(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}")
+        logger.debug(f"Image shape: {image.shape}")
+        logger.debug(f"Back image shape: {back_image.shape}")
     
     # Only resize back image if not high-res
     if not high_res:
@@ -479,11 +510,11 @@ def image_to_pdf_core(input_image, file_name, logo_image, outputfolder, h_cells,
     
     scale = (scale_1 , scale_2, scale_3, scale_4)     
     if debug:
-        print(f"PDF creation took {time.time() - t3:.4f} seconds")
+        logger.debug(f"PDF creation took {time.time() - t3:.4f} seconds")
     
     # concatenate pdfs
     t4 = time.time()
-    print("Concatenating PDFs")
+    logger.info("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)
@@ -491,10 +522,10 @@ def image_to_pdf_core(input_image, file_name, logo_image, outputfolder, h_cells,
     os.remove(output_path_front)
     os.remove(output_path_back)
     if debug:
-        print(f"PDF concatenation and cleanup took {time.time() - t4:.4f} seconds")
+        logger.debug(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}")
+    logger.info(f"Total processing time: {time.time() - overall_start_time:.4f} seconds")
+    logger.info(f"Done! Output saved to {output_path}")
     return output_path, scale
     
     
@@ -502,7 +533,7 @@ def image_to_pdf(input_image, logo_image, outputfolder, h_cells, w_cells, unique
     """
     Create a copaint PDF from an image and a logo.
     """
-    print(f"h_cells: {h_cells}, w_cells: {w_cells}, a4: {a4}")
+    logger.info(f"h_cells: {h_cells}, w_cells: {w_cells}, a4: {a4}")
 
     image = load_image(input_image, debug=debug)
     _, c, h, w = image.shape  
@@ -517,7 +548,7 @@ def image_to_pdf(input_image, logo_image, outputfolder, h_cells, w_cells, unique
     # 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")
+        logger.info("Using A4 format")
         W, H = 8.27, 11.69 # the unit is inch
     
     margin = 0.25 # hardcoded margin
@@ -532,8 +563,8 @@ def image_to_pdf(input_image, logo_image, outputfolder, h_cells, w_cells, unique
         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}")
+        logger.info(f"img_small_side_in_pt: {img_small_side_in_pt}, img_large_side_in_pt: {img_large_side_in_pt}")
+        logger.info(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
         
@@ -541,13 +572,13 @@ def image_to_pdf(input_image, logo_image, outputfolder, h_cells, w_cells, unique
             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}")            
+        logger.info(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}")
+    logger.info(f"divide_factor_h: {divide_factor_h}, divide_factor_w: {divide_factor_w}")
     copaint_pdfs = []
     scale = None
     for i in range(divide_factor_h):
@@ -558,7 +589,7 @@ def image_to_pdf(input_image, logo_image, outputfolder, h_cells, w_cells, unique
             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}")
+            logger.info(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}"
@@ -584,7 +615,7 @@ def image_to_pdf(input_image, logo_image, outputfolder, h_cells, w_cells, unique
     for pdf in copaint_pdfs:
         os.remove(pdf)
     
-    print(f"Done! Final output saved to {output_path}")
+    logger.info(f"Done! Final output saved to {output_path}")
     return output_path
 
 

copaint/gradio_ui.py

@@ -3,6 +3,7 @@
 import gradio as gr
 import shutil
 import tempfile
+import logging
 
 from gradio_pdf import PDF
 from importlib.resources import files
@@ -12,6 +13,14 @@ from copaint.copaint import image_to_pdf
 import torchvision
 import torch
 
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S'
+)
+logger = logging.getLogger(__name__)
+
 fromPIltoTensor = torchvision.transforms.ToTensor()
 fromTensortoPIL = torchvision.transforms.ToPILImage()
 
@@ -20,10 +29,14 @@ 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
+    
+    # Calculate average image brightness
+    avg_brightness = image.mean()
+    # Use white grid for dark images, dark blue for bright ones
+    grid_color = torch.tensor([255,255,255]).unsqueeze(1).unsqueeze(1) / 255.0 if avg_brightness < 0.3 else 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)
+    logger.debug(f"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
@@ -36,52 +49,54 @@ def add_grid_to_image(image, h_cells, w_cells):
     return image
 
 
-def canvas_ratio(image, h_cells, w_cells):
-    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"]
+def get_canvas_ratio_message(h_cells, w_cells):
+    # Calculate aspect ratio
+    ratio = h_cells / w_cells if h_cells > w_cells else w_cells / h_cells
+    closest_ratio = None
+    closest_ratio_str = None
     min_diff = float('inf')
-    closest_ratio_idx = None
-    for idx, ratio in enumerate(predefined_aspect_ratios):
-        diff = abs(aspect_ratio - ratio)
+    
+    # Common aspect ratios
+    ratios = {
+        "1:1": 1,
+        "5:6": 5/6,
+        "3:4": 3/4,
+        "2:3": 2/3
+    }
+    
+    # Find closest ratio
+    for ratio_str, r in ratios.items():
+        diff = abs(ratio - r)
         if diff < min_diff:
             min_diff = diff
-            closest_ratio_idx = idx
-    closest_ratio_str = predefined_aspect_ratios_str[closest_ratio_idx]
+            closest_ratio = r
+            closest_ratio_str = ratio_str
     
-    if min_diff > 0.1:
-        return None
-    else:
-
-        example_str = ""
-
-        if closest_ratio_str == "1:1":
-            if h_cells == 2 and h_cells == 2:
-                example_str = " (for example, a 6” by 6” canvas)"
-            if h_cells == 3 and h_cells == 3:
-                example_str = " (for example, an 8” by 8” canvas)"
-        elif closest_ratio_str == "5:6":
-                example_str = " (for example, a 10” by 12” canvas)"
-        elif closest_ratio_str == "3:4":
-            if (h_cells == 3 and w_cells == 4) or (h_cells == 4 and w_cells == 3):
-                example_str = " (for example, a 6” by 8” canvas)"
-            if (h_cells == 4 and w_cells == 6) or (h_cells == 6 and w_cells == 4):
-                example_str = " (for example, an 18” by 24”, or a 12” by 16” canvas)"
-        elif closest_ratio_str == "2:3" and ((h_cells == 6 and w_cells == 9) or (h_cells == 9 and w_cells == 6)):
-            example_str = " (for example, a 24” by 36” canvas)"
-
-        return f"Preparing your canvas: *choose a canvas with a {closest_ratio_str} ratio to respect your design’s size{example_str}.*"
-
+    example_str = ""
+    
+    if closest_ratio_str == "1:1":
+        if h_cells == 2 and h_cells == 2:
+            example_str = ' (for example, a 6" by 6" canvas)'
+        if h_cells == 3 and h_cells == 3:
+            example_str = ' (for example, an 8" by 8" canvas)'
+    elif closest_ratio_str == "5:6":
+        example_str = ' (for example, a 10" by 12" canvas)'
+    elif closest_ratio_str == "3:4":
+        if (h_cells == 3 and w_cells == 4) or (h_cells == 4 and w_cells == 3):
+            example_str = ' (for example, a 6" by 8" canvas)'
+        if (h_cells == 4 and w_cells == 6) or (h_cells == 6 and w_cells == 4):
+            example_str = ' (for example, an 18" by 24", or a 12" by 16" canvas)'
+    elif closest_ratio_str == "2:3" and ((h_cells == 6 and w_cells == 9) or (h_cells == 9 and w_cells == 6)):
+        example_str = ' (for example, a 24" by 36" canvas)'
+
+    return_str = f"Your grid has <b>{h_cells}x{w_cells} cells</b>, which is a <b>{h_cells*w_cells}-cell CopainT</b>.\n\n"
+    return_str += f"Preparing your canvas: <b>choose a canvas with a {closest_ratio_str} ratio</b> to respect your design's size{example_str}."
+    return f"<div style='font-size: 1.2em; line-height: 1.5;'>{return_str}</div>"
 
 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, h_cells, w_cells))
+    return add_grid_to_image(image, h_cells, w_cells), gr.update(visible=True, value=get_canvas_ratio_message(h_cells, w_cells))
 
 
 def process_copaint(
@@ -95,7 +110,7 @@ def process_copaint(
     copaint_name="",
     copaint_logo=None,
 ):
-    """Process the input and generate CoPaint PDF"""
+    """Process the input and generate CopainT PDF"""
     # Create temporary directories for processing
     temp_input_dir = tempfile.mkdtemp()
     temp_output_dir = tempfile.mkdtemp()
@@ -147,10 +162,10 @@ def process_copaint(
 
 def build_gradio_ui():
     # Create Gradio Interface
-    with gr.Blocks(title="CoPaint Generator", theme='NoCrypt/miku') as demo:
+    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. 🎨🖌️")
+        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):
@@ -185,7 +200,8 @@ def build_gradio_ui():
 
                     # 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)
+                    
+                    output_image = gr.Image(label=None, show_label=False,  show_fullscreen_button=False, interactive=False, show_download_button=False)
 
                     # canvas ratio message
                     canvas_msg =  gr.Markdown(label="Canvas Ratio", visible=False)
@@ -229,7 +245,7 @@ def build_gradio_ui():
         
         with gr.Row():
             with gr.Column(scale=1):
-                output_pdf = PDF(label="PDF Preview")
+                output_pdf = PDF(label="PDF Preview", show_label=False, show_fullscreen_button=False, interactive=False, show_download_button=False)
 
         # Update output_image: trigger update when any input changes
         for component in [input_image, h_cells, w_cells]: