Colored Emoji - Windows

style_20250128.css

@@ -0,0 +1,127 @@
+.interface-wrapper {
+    max-width: 1024px;
+    margin: 0 auto;
+}
+
+.centered {
+    margin: 0 auto;
+    display: block;
+}
+
+.solid {
+    opacity: 1.0 !important;
+    height: auto !important;
+}
+
+.intro {
+    font-size: 1.2em !important;
+    font-weight: bold;
+    text-align: center;
+    background-color: rgba(242, 218, 163, 0.62);
+}
+
+.dark .gradio-container.gradio-container-5-12-0 .contain .intro {
+    background-color: rgba(41, 18, 5, 0.38) !important;
+}
+
+.small {
+    font-size: smaller !important;
+    text-align: center;
+}
+
+.imgcontainer img {
+    object-fit: contain !important;
+}
+
+#examples {
+    font-weight: bolder;
+}
+
+--background-fill-primary: #FBCE50 !important;
+#col-container {
+    max-width: 1024px;
+    margin-left: auto;
+    margin-right: auto;
+}
+
+a {
+    text-decoration-line: underline;
+    font-weight: 600;
+}
+
+#btn-generate {
+    background-image: linear-gradient(to right bottom, rgb(157, 255, 157), rgb(229, 255, 235));
+}
+
+    #btn-generate:hover {
+        background-image: linear-gradient(to right bottom, rgb(229, 255, 229), rgb(255, 255, 255));
+    }
+
+    #btn-generate:active {
+        background-image: linear-gradient(to right bottom, rgb(229, 255, 235), rgb(157, 255, 157));
+    }
+
+#versions {
+    margin-top: 1em;
+    width: 100%;
+    text-align: center;
+}
+
+.small-btn {
+    max-width: 75px;
+}
+
+#gallery .thumbnails {
+    flex-direction: column !important;
+    display: inline-flex !important;
+    flex-wrap: wrap !important;
+    position: relative !important;
+}
+
+#gallery caption.caption {
+    flex-direction: row !important;
+    display: inline-flex !important;
+    flex-wrap: wrap;
+    white-space: unset !important;
+}
+
+#gallery .image-button img.with-caption {
+    object-fit: cover !important;
+    object-position: center !important;
+}
+
+#gallery button.preview {
+    position: relative !important;
+}
+
+.gradio-container::before {
+    content: ' ';
+    display: block;
+    position: absolute;
+    left: 0;
+    top: 0;
+    width: 100%;
+    height: 100%;
+    opacity: 0.25;
+    background-image: url('gradio_api/file=./images/logo.png');
+    background-repeat: no-repeat;
+    background-position: 50% 0;
+    background-size: cover;
+    background-color: rgba(0,0,0,0.9);
+}
+
+#component-0, #component-1 {
+    opacity: 0.9;
+}
+
+#excluded_colors {
+    width: 95%;
+    margin: 0 auto;
+    font-size: smaller;
+}
+
+@media only screen and (min-width: 1920px) {
+    .gradio-container, .gradio-container::before {
+        max-width: 1920px !important;
+    }
+}

utils/hex_grid.py

@@ -0,0 +1,414 @@
+# utils/hex_grid.py
+import os
+import math
+from PIL import Image
+import cairocffi as cairo
+import pangocffi
+import pangocairocffi
+from PIL import Image, ImageDraw, ImageChops, ImageFont #, ImageColor
+#from pilmoji import Pilmoji  # Import Pilmoji for handling emojis
+from utils.excluded_colors import (
+    excluded_color_list,
+)
+from utils.image_utils import multiply_and_blend_images
+from utils.color_utils import update_color_opacity, parse_hex_color, draw_text_with_emojis, hex_to_rgb
+import random  # For random text options
+import utils.constants as constants  # Import constants
+import ast
+
+def calculate_font_size(hex_size, padding=0.6, size_ceil=20, min_font_size=8):
+    """
+    Calculate the font size based on the hexagon size.
+
+    Parameters:
+        hex_size (int): The size of the hexagon side.
+        padding (float): The fraction of the hex size to use for font size.
+
+    Returns:
+        int or None: The calculated font size or None if hex is too small.
+    """
+    font_size = int(hex_size * padding)
+    if font_size < min_font_size:
+        return None  # Hex is too small for text
+    return min(font_size, size_ceil)
+
+def generate_hexagon_grid(hex_size, border_size, input_image=None, image_width=0, image_height=0, start_x=0, start_y=0, end_x=0, end_y=0, rotation=0, background_color="#ede9ac44", border_color="#12165380", fill_hex=True, excluded_color_list=excluded_color_list, filter_color=False, x_spacing=0, y_spacing=0):
+    if input_image:
+        image_width, image_height = input_image.size
+    # Use half hex_size, thus do not double border size
+    # Calculate the dimensions of the grid before rotation
+    if rotation != 0:
+        # Calculate rotated dimensions
+        # modified to rotate input image and process to reduce calculation errors at edge conditions
+        rotated_input_image = input_image.rotate(rotation, expand=True)
+        rotated_image_width, rotated_image_height = rotated_input_image.size
+        #rotated_image_height = abs(math.ceil((image_height ) * math.sin(math.radians(90 - rotation)) + (image_width ) * math.cos(math.radians(90 - rotation))))
+        #rotated_image_width = abs(math.ceil((image_width ) * math.sin(math.radians(90 - rotation)) + (image_height ) * math.cos(math.radians(90 - rotation))))
+        # Adjust hexagon size, spacing adjustments and border for rotation
+        hex_size = abs(math.ceil((hex_size // 2) * math.sin(math.radians(90 - abs(rotation))) + (hex_size // 2) * math.cos(math.radians(90 - abs(rotation)))))
+        hex_border_size = math.ceil(border_size * math.sin(math.radians(90 - abs(rotation))) + border_size * math.cos(math.radians(90 - abs(rotation))))
+        x_spacing = math.ceil(x_spacing * math.sin(math.radians(90 - abs(rotation))) + x_spacing * math.cos(math.radians(90 - abs(rotation))))
+        y_spacing = math.ceil(y_spacing * math.sin(math.radians(90 - abs(rotation))) + y_spacing * math.cos(math.radians(90 - abs(rotation))))
+        # Calculate additional width and height due to rotation
+        additional_width = rotated_image_width - image_width
+        additional_height = rotated_image_height - image_height
+        #rotated_input_image.show()
+    else:
+        rotated_input_image = input_image
+        rotated_image_width = image_width 
+        rotated_image_height = image_height
+        hex_size = hex_size // 2
+        hex_border_size = border_size
+        additional_width = 0
+        additional_height = 0
+    # Create a new image with white background (adjusted for rotation)
+    image = Image.new("RGBA", (rotated_image_width, rotated_image_height), background_color)
+    draw = ImageDraw.Draw(image, mode="RGBA")
+    hex_width = hex_size * 2
+    hex_height = hex_size * 2
+    hex_horizontal_spacing = (hex_width ) + (hex_border_size if hex_border_size < 0 else 0) + x_spacing #* 0.8660254
+    hex_vertical_spacing = hex_height + (hex_border_size if hex_border_size < 0 else 0) + y_spacing
+    col = 0
+    row = 0
+    def draw_hexagon(x, y, color="#FFFFFFFF", rotation=0, outline_color="#12165380", outline_width=0, sides=6):
+        side_length = (hex_size * 2) / math.sqrt(3)
+        points = [(x + side_length * math.cos(math.radians(angle + rotation)), y + side_length * math.sin(math.radians(angle + rotation))) for angle in range(0, 360, (360 // sides))]
+        draw.polygon(points, fill=color, outline=outline_color, width=max(-5, outline_width))
+    # Function to range a floating number
+    def frange(start, stop, step):
+        i = start
+        while i < stop:
+            yield i
+            i += step
+    # Draw hexagons 
+    for y in frange(start_y, max(image_height + additional_height, image_height, rotated_image_height) + (end_y - start_y), hex_vertical_spacing):
+        row += 1
+        col = 0 
+        for x in frange(start_x, max(image_width + additional_width, image_width, rotated_image_width) + (end_x - start_x), hex_horizontal_spacing):
+            col += 1
+            x_offset = hex_width // 2
+            y_offset = (hex_height // 2) #* 1.15470054342517
+            # Adjust y_offset for columns 1 and 3 to overlap
+            if col % 2 == 1:
+                y_offset -= (hex_height // 2) #* 0.8660254
+            if rotated_input_image:
+                # Sample the colors of the pixels in the hexagon, if fill_hex is True
+                if fill_hex:
+                    sample_size = max(2, math.ceil(math.sqrt(hex_size)))
+                    sample_x = int(x + x_offset)
+                    sample_y = int(y + y_offset)
+                    sample_colors = []
+                    for i in range(-sample_size // 2, sample_size // 2 + 1):
+                        for j in range(-sample_size // 2, sample_size // 2 + 1):
+                            print(f"    Progress : {str(min(rotated_image_width - 1,max(1,sample_x + i)))}  {str(min(rotated_image_height - 1,max(1,sample_y + j)))}", end="\r")
+                            sample_colors.append(rotated_input_image.getpixel((min(rotated_image_width - 1,max(1,sample_x + i)), min(rotated_image_height - 1,max(1,sample_y + j)))))
+                    if filter_color:
+                        # Filter out the excluded colors
+                        filtered_colors = [color for color in sample_colors if color not in excluded_color_list]
+                        # Ensure there are colors left after filtering
+                        if filtered_colors:
+                            # Calculate the average color of the filtered colors
+                            avg_color = tuple(int(sum(channel) / len(filtered_colors)) for channel in zip(*filtered_colors))
+                        else:
+                            avg_color = excluded_color_list[0] if excluded_color_list else (0,0,0,0)
+                    else:
+                        avg_color = tuple(int(sum(channel) / len(sample_colors)) for channel in zip(*sample_colors))
+                    if avg_color in excluded_color_list:
+                        print(f"color excluded: {avg_color}")
+                        avg_color = (0,0,0,0)
+                    else:
+                        print(f"color found: {avg_color}")
+                        #draw_hexagon(x + x_offset, y + y_offset, color="#{:02x}{:02x}{:02x}{:02x}".format(*avg_color if fill_hex else (0,0,0,0)), outline_color=border_color, outline_width=hex_border_size)
+                        draw_hexagon(x + x_offset, y + y_offset, color="#{:02x}{:02x}{:02x}{:02x}".format(*avg_color), outline_color=border_color, outline_width=hex_border_size)
+                else:
+                    draw_hexagon(x + x_offset, y + y_offset, color="#000000", outline_color=border_color, outline_width=hex_border_size)
+            else:
+                color = "#%02x%02x%02x%02x" % (128, math.ceil(y) % 255, math.ceil(x) % 255, 255) if fill_hex else (0,0,0,0)
+                draw_hexagon(x + x_offset, y + y_offset, color=color, outline_color=border_color, outline_width=hex_border_size)
+    if rotation != 0:
+        #image.show()
+        # Rotate the final image
+        rotated_image = image.rotate(-rotation, expand=True)
+        #rotated_image.show()
+        bbox = rotated_image.split()[3].getbbox(False)
+        if bbox:
+            final_image = rotated_image.crop(bbox).resize((image_width,image_height))
+        else:
+            final_image = rotated_image.resize((image_width,image_height))
+    else:
+        final_image = image
+    return final_image
+
+def generate_hexagon_grid_with_text(hex_size, border_size, input_image=None, image_width=0, image_height=0, start_x=0, start_y=0, end_x=0, end_y=0, rotation=0, background_color="#ede9ac44", border_color="#12165380", fill_hex=True, excluded_color_list=excluded_color_list, filter_color=False, x_spacing=0, y_spacing=0, 
+        add_hex_text_option=None, custom_text_list=None, custom_text_color_list=None):
+
+    if input_image:
+        image_width, image_height = input_image.size
+    # Use half hex_size, thus do not double border size
+    # Calculate the dimensions of the grid before rotation
+    if rotation != 0:
+        # Calculate rotated dimensions
+        # modified to rotate input image and process to reduce calculation errors at edge conditions
+        rotated_input_image = input_image.rotate(rotation, expand=True)
+        rotated_image_width, rotated_image_height = rotated_input_image.size
+        #rotated_image_height = abs(math.ceil((image_height ) * math.sin(math.radians(90 - rotation)) + (image_width ) * math.cos(math.radians(90 - rotation))))
+        #rotated_image_width = abs(math.ceil((image_width ) * math.sin(math.radians(90 - rotation)) + (image_height ) * math.cos(math.radians(90 - rotation))))
+        # Adjust hexagon size, spacing adjustments and border for rotation
+        hex_size = abs(math.ceil((hex_size // 2) * math.sin(math.radians(90 - abs(rotation))) + (hex_size // 2) * math.cos(math.radians(90 - abs(rotation)))))
+        hex_border_size = math.ceil(border_size * math.sin(math.radians(90 - abs(rotation))) + border_size * math.cos(math.radians(90 - abs(rotation))))
+        x_spacing = math.ceil(x_spacing * math.sin(math.radians(90 - abs(rotation))) + x_spacing * math.cos(math.radians(90 - abs(rotation))))
+        y_spacing = math.ceil(y_spacing * math.sin(math.radians(90 - abs(rotation))) + y_spacing * math.cos(math.radians(90 - abs(rotation))))
+        # Calculate additional width and height due to rotation
+        additional_width = rotated_image_width - image_width
+        additional_height = rotated_image_height - image_height
+        #rotated_input_image.show()
+    else:
+        rotated_input_image = input_image
+        rotated_image_width = image_width 
+        rotated_image_height = image_height
+        hex_size = hex_size // 2
+        hex_border_size = border_size
+        additional_width = 0
+        additional_height = 0
+    # Create a new image with white background (adjusted for rotation)
+    image = Image.new("RGBA", (rotated_image_width, rotated_image_height), background_color)
+    font_image = Image.new("RGBA", (rotated_image_width, rotated_image_height), (0,0,0,0))
+    draw = ImageDraw.Draw(image, mode="RGBA")
+    hex_width = hex_size * 2
+    hex_height = hex_size * 2
+    hex_horizontal_spacing = (hex_width ) + (hex_border_size if hex_border_size < 0 else 0) + x_spacing #* 0.8660254
+    hex_vertical_spacing = hex_height + (hex_border_size if hex_border_size < 0 else 0) + y_spacing
+    col = 0
+    row = 0
+    ## Function to draw optional text
+    if add_hex_text_option != "None":
+        # Load the emoji font
+        font_name = "Segoe UI Emoji"
+        if os.name == 'nt':  # Windows
+            font_path = "./fonts/seguiemj.ttf"
+        else:  # Other OS (Linux, macOS, etc.)
+            font_path = "./fonts/seguiemj.ttf"
+        if not os.path.exists(font_path):
+            raise FileNotFoundError("Emoji font not found in './fonts' directory.")
+        # Prepare the text and color lists
+        text_list = []
+        color_list = []
+        if add_hex_text_option == "Row-Column Coordinates":
+            pass  # Coordinates will be generated dynamically
+        elif add_hex_text_option == "Playing Cards Sequential":
+            text_list = constants.cards
+            color_list = constants.card_colors
+        elif add_hex_text_option == "Playing Cards Alternate Red and Black":
+            text_list = constants.cards_alternating
+            color_list = constants.card_colors_alternating
+        elif add_hex_text_option == "Custom List":
+            if custom_text_list:
+                #text_list = [text.strip() for text in custom_text_list.split(",")]
+                text_list = ast.literal_eval(custom_text_list) if custom_text_list else None                
+            if custom_text_color_list:
+                #color_list = [color.strip() for color in custom_text_color_list.split(",")]
+                color_list = ast.literal_eval(custom_text_color_list) if custom_text_color_list else None
+        else:
+            text_list = []
+            color_list = []
+    hex_index = -1  # Initialize hex index
+    def draw_hexagon(x, y, color="#FFFFFFFF", rotation=0, outline_color="#12165380", outline_width=0, sides=6):
+        side_length = (hex_size * 2) / math.sqrt(3)
+        points = [(x + side_length * math.cos(math.radians(angle + rotation)), y + side_length * math.sin(math.radians(angle + rotation))) for angle in range(0, 360, (360 // sides))]
+        draw.polygon(points, fill=color, outline=outline_color, width=max(-5, outline_width))
+    # Function to range a floating number
+    def frange(start, stop, step):
+        i = start
+        while i < stop:
+            yield i
+            i += step
+    # Draw hexagons 
+    for y in frange(start_y, max(image_height + additional_height, image_height, rotated_image_height) + (end_y - start_y), hex_vertical_spacing):
+        row += 1
+        col = 0 
+        for x in frange(start_x, max(image_width + additional_width, image_width, rotated_image_width) + (end_x - start_x), hex_horizontal_spacing):
+            col += 1
+            hex_index += 1  # Increment hex index
+            x_offset = hex_width // 2
+            y_offset = (hex_height // 2) #* 1.15470054342517
+            # Adjust y_offset for columns 1 and 3 to overlap
+            if col % 2 == 1:
+                y_offset -= (hex_height // 2) #* 0.8660254
+            if rotated_input_image:
+                # Sample the colors of the pixels in the hexagon, if fill_hex is True
+                if fill_hex:
+                    sample_size = max(2, math.ceil(math.sqrt(hex_size)))
+                    sample_x = int(x + x_offset)
+                    sample_y = int(y + y_offset)
+                    sample_colors = []
+                    for i in range(-sample_size // 2, sample_size // 2 + 1):
+                        for j in range(-sample_size // 2, sample_size // 2 + 1):
+                            print(f"    Progress : {str(min(rotated_image_width - 1,max(1,sample_x + i)))}  {str(min(rotated_image_height - 1,max(1,sample_y + j)))}", end="\r")
+                            sample_colors.append(rotated_input_image.getpixel((min(rotated_image_width - 1,max(1,sample_x + i)), min(rotated_image_height - 1,max(1,sample_y + j)))))
+                    if filter_color:
+                        # Filter out the excluded colors
+                        filtered_colors = [color for color in sample_colors if color not in excluded_color_list]
+                        # Ensure there are colors left after filtering
+                        if filtered_colors:
+                            # Calculate the average color of the filtered colors
+                            avg_color = tuple(int(sum(channel) / len(filtered_colors)) for channel in zip(*filtered_colors))
+                        else:
+                            avg_color = excluded_color_list[0] if excluded_color_list else (0,0,0,0)
+                    else:
+                        avg_color = tuple(int(sum(channel) / len(sample_colors)) for channel in zip(*sample_colors))
+                    if avg_color in excluded_color_list:
+                        print(f"color excluded: {avg_color}")
+                        avg_color = (0,0,0,0)
+                    else:
+                        print(f"color found: {avg_color}")
+                        #draw_hexagon(x + x_offset, y + y_offset, color="#{:02x}{:02x}{:02x}{:02x}".format(*avg_color if fill_hex else (0,0,0,0)), outline_color=border_color, outline_width=hex_border_size)
+                        draw_hexagon(x + x_offset, y + y_offset, color="#{:02x}{:02x}{:02x}{:02x}".format(*avg_color), outline_color=border_color, outline_width=hex_border_size)
+                else:
+                    draw_hexagon(x + x_offset, y + y_offset, color="#00000000", outline_color=border_color, outline_width=hex_border_size)
+            else:
+                color = "#%02x%02x%02x%02x" % (128, math.ceil(y) % 255, math.ceil(x) % 255, 255) if fill_hex else (0,0,0,0)
+                draw_hexagon(x + x_offset, y + y_offset, color=color, outline_color=border_color, outline_width=hex_border_size)
+            # Draw text in hexagon
+            if add_hex_text_option != None:
+                font_size = calculate_font_size(hex_size, 0.333, 20, 7)
+                # Skip drawing text if font size is too small
+                if font_size:
+                    font = ImageFont.truetype(font_path, font_size)
+                    # Determine the text to draw
+                    if add_hex_text_option == "Row-Column Coordinates":
+                        text = f"{col},{row}"
+                    elif text_list:
+                        text = text_list[hex_index % len(text_list)]
+                    else:
+                        text = ""
+                    # Determine the text color
+                    if color_list:
+                        # Extract the opacity from the border color and add to the color_list
+                        if isinstance(border_color, str):
+                            opacity = int(border_color[-2:], 16)
+                        elif isinstance(border_color, tuple) and len(border_color) == 4:
+                            opacity = border_color[3]
+                        else:
+                            opacity = 255  # Default to full opacity if format is unexpected
+                        text_color = update_color_opacity(hex_to_rgb(color_list[hex_index % len(color_list)]), opacity)
+                    else:
+                        # Use border color and opacity
+                        text_color = border_color 
+                        #text_color = "#{:02x}{:02x}{:02x}{:02x}".format(*text_color)
+                    # Skip if text is empty
+                    if text != "":
+                        print(f"Drawing Text: {text} color: {text_color} size: {font_size}")
+                        # Calculate text size using Pango
+                        # Create a temporary surface to calculate text size
+                        # temp_surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 1, 1)
+                        # temp_context = cairo.Context(temp_surface)
+                        # temp_layout = pangocairocffi.create_layout(temp_context)
+                        # temp_layout._set_text(text)
+                        # temp_desc = pangocffi.FontDescription()
+                        # temp_desc._set_family(font_name)
+                        # temp_desc._set_size(pangocffi.units_from_double(font_size))
+                        # temp_layout._set_font_description(temp_desc)
+                        # pangocairocffi.show_layout(temp_context, temp_layout)
+                        # ink_rect, logical_rect = temp_layout.get_extents()
+                        # text_width = logical_rect.width
+                        # text_height = logical_rect.height                
+                        # Calculate position to center text in hexagon
+                        # text_x = x + x_offset - (text_width / 2)
+                        # text_y = y + y_offset - (text_height / 2)
+                        # Calculate position to center text in hexagon
+                        text_x = x + x_offset - (hex_size / 1.75)
+                        text_y = y + y_offset - (hex_size / 1.25)
+                        # Draw the text directly onto the image
+                        font_image = draw_text_with_emojis(
+                            image=font_image,
+                            text=text,
+                            font_color=update_color_opacity(text_color,255),
+                            offset_x=text_x,
+                            offset_y=text_y,
+                            font_name=font_name,
+                            font_size=font_size
+                        )                        
+                        # # Use Pilmoji to draw text with emojis
+                        # with Pilmoji(image) as pilmoji:
+                        #     # Calculate text size
+                        #     w, h = pilmoji.getsize(text, font=font)
+                        #     # Calculate position to center text in hexagon
+                        #     text_x = x + x_offset - w / 2
+                        #     text_y = y + y_offset - h / 2
+                        #     # Draw text
+                        #     pilmoji.text(
+                        #         (text_x, text_y),
+                        #         text,
+                        #         font=font,
+                        #         fill=text_color
+                        #     )
+    image.paste(font_image, (0, 0), font_image)
+    if rotation != 0:
+        # Rotate the final image
+        rotated_image = image.rotate(-rotation, expand=True, fillcolor=background_color)
+        bbox = rotated_image.split()[3].getbbox(alpha_only=False)
+
+        if bbox:
+            # Calculate the size of the rotated image
+            rotated_width, rotated_height = rotated_image.size
+
+            # Calculate the size of the cropped area
+            box_width = bbox[2] - bbox[0]
+            box_height = bbox[3] - bbox[1]
+
+            box_width_adjust = (box_width - image_width) / 2
+            bbox_height_adjust = (box_height - image_height) / 2
+
+            print(f"\nbbox: {bbox}: size: {(image_width, image_height)} estimated size: {(box_width, box_height)}")
+
+            # Calculate adjusted box coordinates
+            left = bbox[0] + box_width_adjust
+            upper = bbox[1] + bbox_height_adjust
+            right = bbox[2] - box_width_adjust
+            lower = bbox[3] - bbox_height_adjust
+
+            # Ensure coordinates are within image bounds
+            left = max(0, min(left, rotated_width))
+            upper = max(0, min(upper, rotated_height))
+            right = max(0, min(right, rotated_width))
+            lower = max(0, min(lower, rotated_height))
+
+            # Ensure the box has positive width and height
+            if right > left and lower > upper:
+                # Crop the image using the adjusted box
+                cropped_image = rotated_image.crop((left, upper, right, lower))
+                # Resize the cropped image to the desired size
+                final_image = cropped_image.resize((image_width, image_height))
+            else:
+                # If the box is invalid, resize the entire rotated image
+                final_image = rotated_image.resize((image_width, image_height))
+        else:
+            final_image = rotated_image.resize((image_width, image_height))
+    else:
+        final_image = image
+    return final_image
+
+def generate_hexagon_grid_interface(hex_size, border_size, image, start_x, start_y, end_x, end_y, rotation, background_color, border_color, fill_hex, excluded_color_list, filter_color, x_spacing, y_spacing, add_hex_text_option=None, custom_text_list=None, custom_text_color_list=None):
+    print(f"Generating Hexagon Grid with Parameters: Hex Size: {hex_size}, Border Size: {border_size}, Start X: {start_x}, Start Y: {start_y}, End X: {end_x}, End Y: {end_y}, Rotation: {rotation}, Background Color: {background_color}, Border Color: {border_color}, Fill Hex: {fill_hex}, Excluded Color List: {excluded_color_list}, Filter Color: {filter_color}, X Spacing: {x_spacing}, Y Spacing: {y_spacing}, add Text Option {add_hex_text_option}\n")
+    hexagon_grid_image = generate_hexagon_grid_with_text(
+        hex_size=abs(hex_size),
+        border_size=border_size,
+        input_image=image,
+        start_x=start_x,
+        start_y=start_y,
+        end_x=end_x,
+        end_y=end_y,
+        rotation=rotation,
+        background_color=background_color,
+        border_color=border_color,
+        fill_hex = fill_hex,
+        excluded_color_list = excluded_color_list,
+        filter_color = filter_color, 
+        x_spacing = x_spacing if abs(hex_size) > abs(x_spacing) else (hex_size if x_spacing >= 0 else -hex_size), 
+        y_spacing = y_spacing if abs(hex_size) > abs(y_spacing) else (hex_size if y_spacing >= 0 else -hex_size),
+        add_hex_text_option = add_hex_text_option,
+        custom_text_list = custom_text_list,
+        custom_text_color_list= custom_text_color_list
+    )
+    overlay_image = multiply_and_blend_images(image, hexagon_grid_image, 50)
+    return hexagon_grid_image, overlay_image

utils/image_utils.py

@@ -0,0 +1,578 @@
+# utils/image_utils.py
+import os
+from io import BytesIO
+import base64
+import numpy as np
+#from decimal import ROUND_CEILING
+from PIL import Image, ImageChops, ImageDraw, ImageEnhance, ImageFilter, ImageDraw, ImageOps, ImageMath
+from typing import List, Union
+#import numpy as np
+#import math
+from utils.constants import default_lut_example_img
+from utils.color_utils import (
+    detect_color_format,
+    update_color_opacity
+)
+from utils.misc import (pause)
+
+def open_image(image_path):
+    """
+    Opens an image from a file path or URL, or decodes a DataURL string into an image.
+
+    Parameters:
+        image_path (str): The file path, URL, or DataURL string of the image to open.
+
+    Returns:
+        Image: A PIL Image object of the opened image.
+
+    Raises:
+        Exception: If there is an error opening the image.
+    """
+    import requests
+    try:
+        # Strip leading and trailing double quotation marks, if present
+        image_path = image_path.strip('"')
+        if image_path.startswith('http'):
+            # If the image path is a URL, download the image using requests
+            response = requests.get(image_path)
+            img = Image.open(BytesIO(response.content))
+        elif image_path.startswith('data'):
+            # If the image path is a DataURL, decode the base64 string
+            encoded_data = image_path.split(',')[1]
+            decoded_data = base64.b64decode(encoded_data)
+            img = Image.open(BytesIO(decoded_data))
+        else:
+            # Assume that the image path is a file path
+            img = Image.open(image_path)
+    except Exception as e:
+        raise Exception(f'Error opening image: {e}')
+    return img
+
+def build_prerendered_images(images_list):
+    """
+    Opens a list of images from file paths, URLs, or DataURL strings.
+
+    Parameters:
+        images_list (list): A list of file paths, URLs, or DataURL strings of the images to open.
+
+    Returns:
+        list: A list of PIL Image objects of the opened images.
+    """
+    return [open_image(image) for image in images_list]
+
+def build_encoded_images(images_list):
+    """
+    Encodes a list of images to base64 strings.
+
+    Parameters:
+        images_list (list): A list of file paths, URLs, DataURL strings, or PIL Image objects of the images to encode.
+
+    Returns:
+        list: A list of base64-encoded strings of the images.
+    """
+    return [image_to_base64(image) for image in images_list]
+
+def image_to_base64(image):
+    """
+    Encodes an image to a base64 string.
+
+    Parameters:
+        image (str or PIL.Image.Image): The file path, URL, DataURL string, or PIL Image object of the image to encode.
+
+    Returns:
+        str: A base64-encoded string of the image.
+    """
+    buffered = BytesIO()
+    if type(image) is str:
+        image = open_image(image)
+    image.save(buffered, format="PNG")
+    return "data:image/png;base64," + base64.b64encode(buffered.getvalue()).decode()
+
+def change_color(image, color, opacity=0.75):
+    """
+    Changes the color of an image by overlaying it with a specified color and opacity.
+
+    Parameters:
+        image (str or PIL.Image.Image): The file path, URL, DataURL string, or PIL Image object of the image to change.
+        color (str or tuple): The color to overlay on the image.
+        opacity (float): The opacity of the overlay color (0.0 to 1.0).
+
+    Returns:
+        PIL.Image.Image: The image with the color changed.
+    """
+    if type(image) is str:
+        image = open_image(image)
+    try:
+        # Convert the color to RGBA format
+        rgba_color = detect_color_format(color)
+        rgba_color = update_color_opacity(rgba_color, opacity)
+    
+        # Convert the image to RGBA mode
+        image = image.convert("RGBA")
+    
+        # Create a new image with the same size and mode
+        new_image = Image.new("RGBA", image.size, rgba_color)
+    
+        # Composite the new image with the original image
+        result = Image.alpha_composite(image, new_image)
+    except Exception as e:
+        print(f"Error changing color: {e}")
+        return image
+    return result
+
+def convert_str_to_int_or_zero(value):
+    """
+    Converts a string to an integer, or returns zero if the conversion fails.
+
+    Parameters:
+        value (str): The string to convert.
+
+    Returns:
+        int: The converted integer, or zero if the conversion fails.
+    """
+    try:
+        return int(value)
+    except ValueError:
+        return 0
+
+def upscale_image(image, scale_factor):
+    """
+    Upscales an image by a given scale factor using the LANCZOS filter.
+
+    Parameters:
+        image (PIL.Image.Image): The input image to be upscaled.
+        scale_factor (float): The factor by which to upscale the image.
+
+    Returns:
+        PIL.Image.Image: The upscaled image.
+    """
+    # Calculate the new size
+    new_width = int(image.width * scale_factor)
+    new_height = int(image.height * scale_factor)
+    
+    # Upscale the image using the LANCZOS filter
+    upscaled_image = image.resize((new_width, new_height), Image.LANCZOS)
+    
+    return upscaled_image
+
+def crop_and_resize_image(image, width, height):
+    """
+    Crops the image to a centered square and resizes it to the specified width and height.
+
+    Parameters:
+        image (PIL.Image.Image): The input image to be cropped and resized.
+        width (int): The desired width of the output image.
+        height (int): The desired height of the output image.
+
+    Returns:
+        PIL.Image.Image: The cropped and resized image.
+    """
+    # Get original dimensions
+    original_width, original_height = image.size
+
+    # Determine the smaller dimension to make a square crop
+    min_dim = min(original_width, original_height)
+    
+    # Calculate coordinates for cropping to a centered square
+    left = (original_width - min_dim) // 2
+    top = (original_height - min_dim) // 2
+    right = left + min_dim
+    bottom = top + min_dim
+
+    # Crop the image
+    cropped_image = image.crop((left, top, right, bottom))
+    
+    # Resize the image to the desired dimensions
+    resized_image = cropped_image.resize((width, height), Image.LANCZOS)
+    
+    return resized_image
+
+def resize_image_with_aspect_ratio(image, target_width, target_height):
+    """
+    Resizes the image to fit within the target dimensions while maintaining aspect ratio.
+    If the aspect ratio does not match, the image will be padded with black pixels.
+
+    Parameters:
+        image (PIL.Image.Image): The input image to be resized.
+        target_width (int): The target width.
+        target_height (int): The target height.
+
+    Returns:
+        PIL.Image.Image: The resized image.
+    """
+    # Calculate aspect ratios
+    original_width, original_height = image.size
+    target_aspect = target_width / target_height
+    original_aspect = original_width / original_height
+
+    # Decide whether to fit width or height
+    if original_aspect > target_aspect:
+        # Image is wider than target aspect ratio
+        new_width = target_width
+        new_height = int(target_width / original_aspect)
+    else:
+        # Image is taller than target aspect ratio
+        new_height = target_height
+        new_width = int(target_height * original_aspect)
+
+    # Resize the image
+    resized_image = image.resize((new_width, new_height), Image.LANCZOS)
+
+    # Create a new image with target dimensions and black background
+    new_image = Image.new("RGB", (target_width, target_height), (0, 0, 0))
+    # Paste the resized image onto the center of the new image
+    paste_x = (target_width - new_width) // 2
+    paste_y = (target_height - new_height) // 2
+    new_image.paste(resized_image, (paste_x, paste_y))
+
+    return new_image
+
+def lerp_imagemath(img1, img2, alpha_percent: int = 50):
+    """
+    Performs linear interpolation (LERP) between two images based on the given alpha value.
+
+    Parameters:
+        img1 (str or PIL.Image.Image): The first image or its file path.
+        img2 (str or PIL.Image.Image): The second image or its file path.
+        alpha (int): The interpolation factor (0 to 100).
+
+    Returns:
+        PIL.Image.Image: The interpolated image.
+    """
+    if isinstance(img1, str):
+        img1 = open_image(img1)
+    if isinstance(img2, str):
+        img2 = open_image(img2)
+
+    # Ensure both images are in the same mode (e.g., RGBA)
+    img1 = img1.convert('RGBA')
+    img2 = img2.convert('RGBA')
+
+    # Convert images to NumPy arrays
+    arr1 = np.array(img1, dtype=np.float32)
+    arr2 = np.array(img2, dtype=np.float32)
+
+    # Perform linear interpolation
+    alpha = alpha_percent / 100.0
+    result_arr = (arr1 * (1 - alpha)) + (arr2 * alpha)
+
+    # Convert the result back to a PIL image
+    result_img = Image.fromarray(np.uint8(result_arr))
+
+    #result_img.show()
+    return result_img
+
+def shrink_and_paste_on_blank(current_image, mask_width, mask_height, blank_color:tuple[int, int, int, int] = (0,0,0,0)):
+    """
+    Decreases size of current_image by mask_width pixels from each side,
+    then adds a mask_width width transparent frame,
+    so that the image the function returns is the same size as the input.
+
+    Parameters:
+        current_image (PIL.Image.Image): The input image to transform.
+        mask_width (int): Width in pixels to shrink from each side.
+        mask_height (int): Height in pixels to shrink from each side.
+        blank_color (tuple): The color of the blank frame (default is transparent).
+
+    Returns:
+        PIL.Image.Image: The transformed image.
+    """
+    # calculate new dimensions
+    width, height = current_image.size
+    new_width = width - (2 * mask_width)
+    new_height = height - (2 * mask_height)
+
+    # resize and paste onto blank image
+    prev_image = current_image.resize((new_width, new_height))
+    blank_image = Image.new("RGBA", (width, height), blank_color)
+    blank_image.paste(prev_image, (mask_width, mask_height))
+
+    return blank_image
+
+def multiply_and_blend_images(base_image, image2, alpha_percent=50):
+    """
+    Multiplies two images and blends the result with the original image.
+
+    Parameters:
+        image1 (PIL.Image.Image): The first input image.
+        image2 (PIL.Image.Image): The second input image.
+        alpha (float): The blend factor (0.0 to 100.0) for blending the multiplied result with the original image.
+
+    Returns:
+        PIL.Image.Image: The blended image.
+    """
+    alpha = alpha_percent / 100.0
+    if isinstance(base_image, str):
+        base_image = open_image(base_image)
+    if isinstance(image2, str):
+        image2 = open_image(image2)
+    # Ensure both images are in the same mode and size
+    base_image = base_image.convert('RGBA')
+    image2 = image2.convert('RGBA')
+    image2 = image2.resize(base_image.size)
+
+    # Multiply the images
+    multiplied_image = ImageChops.multiply(base_image, image2)
+
+    # Blend the multiplied result with the original
+    blended_image = Image.blend(base_image, multiplied_image, alpha)
+
+    return blended_image
+
+def alpha_composite_with_control(base_image, image_with_alpha, alpha_percent=100):
+    """
+    Overlays image_with_alpha onto base_image with controlled alpha transparency.
+
+    Parameters:
+        base_image (PIL.Image.Image): The base image.
+        image_with_alpha (PIL.Image.Image): The image to overlay with an alpha channel.
+        alpha_percent (float): The multiplier for the alpha channel (0.0 to 100.0).
+
+    Returns:
+        PIL.Image.Image: The resulting image after alpha compositing.
+    """
+    alpha_multiplier = alpha_percent / 100.0
+    if isinstance(base_image, str):
+        base_image = open_image(base_image)
+    if isinstance(image_with_alpha, str):
+        image_with_alpha = open_image(image_with_alpha)
+
+    # Ensure both images are in RGBA mode
+    base_image = base_image.convert('RGBA')
+    image_with_alpha = image_with_alpha.convert('RGBA')
+
+    # Extract the alpha channel and multiply by alpha_multiplier
+    alpha_channel = image_with_alpha.split()[3]
+    alpha_channel = alpha_channel.point(lambda p: p * alpha_multiplier)
+
+    # Apply the modified alpha channel back to the image
+    image_with_alpha.putalpha(alpha_channel)
+
+    # Composite the images
+    result = Image.alpha_composite(base_image, image_with_alpha)
+
+    return result
+
+def apply_alpha_mask(image, mask_image, invert = False):
+    """
+    Applies a mask image as the alpha channel of the input image.
+
+    Parameters:
+        image (PIL.Image.Image): The image to apply the mask to.
+        mask_image (PIL.Image.Image): The alpha mask to apply.
+        invert (bool): Whether to invert the mask (default is False).
+
+    Returns:
+        PIL.Image.Image: The image with the applied alpha mask.
+    """
+    # Resize the mask to match the current image size
+    mask_image = resize_and_crop_image(mask_image, image.width, image.height).convert('L') # convert to grayscale
+    if invert:
+        mask_image = ImageOps.invert(mask_image)
+    # Apply the mask as the alpha layer of the current image
+    result_image = image.copy() 
+    result_image.putalpha(mask_image) 
+    return result_image
+
+def resize_and_crop_image(image: Image, new_width: int = 512, new_height: int = 512) -> Image:
+    """
+    Resizes and crops an image to a specified width and height. This ensures that the entire new_width and new_height 
+    dimensions are filled by the image, and the aspect ratio is maintained.
+
+    Parameters:
+        image (PIL.Image.Image): The image to be resized and cropped.
+        new_width (int): The desired width of the new image (default is 512).
+        new_height (int): The desired height of the new image (default is 512).
+
+    Returns:
+        PIL.Image.Image: The resized and cropped image.
+    """
+    # Get the dimensions of the original image
+    orig_width, orig_height = image.size
+    # Calculate the aspect ratios of the original and new images
+    orig_aspect_ratio = orig_width / float(orig_height)
+    new_aspect_ratio = new_width / float(new_height)
+    # Calculate the new size of the image while maintaining aspect ratio
+    if orig_aspect_ratio > new_aspect_ratio:
+        # The original image is wider than the new image, so we need to crop the sides
+        resized_width = int(new_height * orig_aspect_ratio)
+        resized_height = new_height
+        left_offset = (resized_width - new_width) // 2
+        top_offset = 0
+    else:
+        # The original image is taller than the new image, so we need to crop the top and bottom
+        resized_width = new_width
+        resized_height = int(new_width / orig_aspect_ratio)
+        left_offset = 0
+        top_offset = (resized_height - new_height) // 2
+    # Resize the image with Lanczos resampling filter
+    resized_image = image.resize((resized_width, resized_height), resample=Image.Resampling.LANCZOS)
+    # Crop the image to fill the entire height and width of the new image
+    cropped_image = resized_image.crop((left_offset, top_offset, left_offset + new_width, top_offset + new_height))
+    return cropped_image
+
+##################################################### LUTs ############################################################
+
+def is_3dlut_row(row: List[str]) -> bool:
+    """
+    Check if one line in the file has exactly 3 numeric values.
+
+    Parameters:
+        row (list): A list of strings representing the values in a row.
+
+    Returns:
+        bool: True if the row has exactly 3 numeric values, False otherwise.
+    """
+    try:
+        row_values = [float(val) for val in row]
+        return len(row_values) == 3
+    except ValueError:
+        return False
+
+
+def read_lut(path_lut: Union[str, os.PathLike], num_channels: int = 3) -> ImageFilter.Color3DLUT:
+    """
+    Read LUT from a raw file.
+
+    Each line in the file is considered part of the LUT table. The function
+    reads the file, parses the rows, and constructs a Color3DLUT object.
+
+    Args:
+        path_lut: A string or os.PathLike object representing the path to the LUT file.
+        num_channels: An integer specifying the number of color channels in the LUT (default is 3).
+
+    Returns:
+        An instance of ImageFilter.Color3DLUT representing the LUT.
+
+    Raises:
+        FileNotFoundError: If the LUT file specified by path_lut does not exist.
+    """
+    with open(path_lut) as f:
+        lut_raw = f.read().splitlines()
+
+    size = round(len(lut_raw) ** (1 / 3))
+    row2val = lambda row: tuple([float(val) for val in row.split(" ")])
+    lut_table = [row2val(row) for row in lut_raw if is_3dlut_row(row.split(" "))]
+
+    return ImageFilter.Color3DLUT(size, lut_table, num_channels)
+
+def apply_lut(img: Image, lut_path: str = "", lut: ImageFilter.Color3DLUT = None) -> Image:
+    """
+    Apply a LUT to an image and return a PIL Image with the LUT applied.
+
+    The function applies the LUT to the input image using the filter() method of the PIL Image class.
+
+    Args:
+        img: A PIL Image object to which the LUT should be applied.
+        lut_path: A string representing the path to the LUT file (optional if lut argument is provided).
+        lut: An instance of ImageFilter.Color3DLUT representing the LUT (optional if lut_path is provided).
+
+    Returns:
+        A PIL Image object with the LUT applied.
+
+    Raises:
+        ValueError: If both lut_path and lut arguments are not provided.
+    """
+    if lut is None:
+        if lut_path == "":
+            raise ValueError("Either lut_path or lut argument must be provided.")
+        lut = read_lut(lut_path)
+
+    return img.filter(lut)
+
+def show_lut(lut_filename: str, lut_example_image: Image = default_lut_example_img) -> Image:
+    if lut_filename is not None:        
+        try:
+            lut_example_image = apply_lut(lut_example_image, lut_filename)
+        except Exception as e:
+            print(f"BAD LUT: Error applying LUT {str(e)}.")
+    else:
+        lut_example_image = open_image(default_lut_example_img)
+    return lut_example_image
+
+def convert_rgb_to_rgba_safe(image: Image) -> Image:
+    """
+    Converts an RGB image to RGBA by adding an alpha channel.
+    Ensures that the original image remains unaltered.
+
+    Parameters:
+        image (PIL.Image.Image): The RGB image to convert.
+
+    Returns:
+        PIL.Image.Image: The converted RGBA image.
+    """
+    if image.mode != 'RGB':
+        if image.mode == 'RGBA':
+            return image
+        elif image.mode == 'P':
+            # Convert palette image to RGBA
+            image = image.convert('RGB')
+        else:
+            raise ValueError("Unsupported image mode for conversion to RGBA.")
+
+    # Create a copy of the image to avoid modifying the original
+    rgba_image = image.copy()
+
+    # Optionally, set a default alpha value (e.g., fully opaque)
+    alpha = Image.new('L', rgba_image.size, 255)  # 255 for full opacity
+    rgba_image.putalpha(alpha)
+    
+    return rgba_image
+
+def apply_lut_to_image_path(lut_filename: str, image_path: str) -> Image:
+    """
+    Apply a LUT to an image and return the result.
+
+    Args:
+        lut_filename: A string representing the path to the LUT file.
+        image_path: A string representing the path to the input image.
+
+    Returns:
+        A PIL Image object with the LUT applied.
+    """
+    img = open_image(image_path)
+    # Handle specific file formats by converting to appropriate modes
+    if image_path.lower().endswith(('.gif', '.webp')):
+        # Convert to RGBA to preserve transparency
+        img = img.convert('RGBA')
+    elif image_path.lower().endswith(('.jpg', '.jpeg')):
+        # Convert to RGB since JPEG doesn't support transparency
+        img = convert_rgb_to_rgba_safe(img)
+    
+    # For other formats like PNG, retain the existing mode
+    # Apply the LUT if provided
+    if lut_filename is not None:
+        try:
+            img = apply_lut(img, lut_filename)
+        except Exception as e:
+            print(f"BAD LUT: Error applying LUT {str(e)}.")
+    return img
+
+
+def convert_to_rgba_png(file_path: str) -> None:
+    """
+    Converts an image to RGBA PNG format and saves it with the same base name and a .png extension.
+
+    Args:
+        file_path (str): The path to the input image file.
+
+    Raises:
+        ValueError: If the input file extension is not a supported image format.
+        Exception: If there is an error during the conversion or saving process.
+    """
+    try:
+        # Open the original image
+        img = open_image(file_path)
+        
+        # Convert the image to RGBA
+        rgba_img = convert_rgb_to_rgba_safe(img)        
+        # Generate the new file name with .png extension
+        base_name = os.path.splitext(file_path)[0]
+        new_file_path = f"{base_name}.png"        
+        # Save the RGBA image as PNG
+        rgba_img.save(new_file_path, format='PNG')        
+        print(f"Image saved as {new_file_path}")        
+    except ValueError as ve:
+        print(f"ValueError: {ve}")
+    except Exception as e:
+        print(f"Error converting image: {e}")

utils/misc.py

@@ -0,0 +1,69 @@
+# misc.py file contains miscellaneous utility functions
+import math
+import sys
+
+def pause():
+    """
+    Pauses the execution until any key is pressed.
+    """
+    if sys.platform.startswith('win'):
+        import msvcrt
+        print("Press any key to continue...")
+        msvcrt.getch()
+    else:
+        import termios
+        import tty
+        print("Press any key to continue...")
+        fd = sys.stdin.fileno()
+        old_settings = termios.tcgetattr(fd)
+        try:
+            tty.setraw(fd)
+            sys.stdin.read(1)
+        finally:
+            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+
+
+def install(package):
+    import subprocess
+    subprocess.check_call([sys.executable, "-m", "pip", "install", package])
+
+def get_filename(file):
+    filename = None
+    if file is not None:
+        filename = file.name
+    return filename
+
+def get_extension(file):
+    extension = None
+    if file is not None:
+        extension = file.name.split(".")[-1]
+    return extension
+
+
+def convert_ratio_to_dimensions(ratio, height=512, rotate90=False):
+    """
+    Calculate pixel dimensions based on a given aspect ratio and base height.
+
+    This function computes the width and height in pixels for an image, ensuring that both dimensions are divisible by 16. The height is adjusted upwards to the nearest multiple of 16 if necessary, and the width is calculated based on the adjusted height and the provided aspect ratio. Additionally, it ensures that both width and height are at least 16 pixels to avoid extremely small dimensions.
+
+    Parameters:
+        ratio (float): The aspect ratio of the image (width divided by height).
+        height (int, optional): The base height in pixels. Defaults to 512.
+
+    Returns:
+        tuple: A tuple containing the calculated (width, height) in pixels, both divisible by 16.
+    """
+    base_height = 512
+    # Scale the height based on the provided height parameter
+    # Ensure the height is at least base_height
+    scaled_height = max(height, base_height)
+    # Adjust the height to be divisible by 16
+    adjusted_height = math.ceil(scaled_height / 16) * 16
+    # Calculate the width based on the ratio
+    calculated_width = int(adjusted_height * ratio)
+    # Adjust the width to be divisible by 16
+    adjusted_width = math.ceil(calculated_width / 16) * 16
+    if rotate90:
+        adjusted_width, adjusted_height = adjusted_height, adjusted_width
+    return adjusted_width, adjusted_height
+