tile

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.ttf filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,138 @@
+fonts/
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+# Usually these files are written by a python script from a template
+# before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+venv/
+ENV/
+env/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/

README.md

@@ -1,7 +1,7 @@
 ---
-title: Tiles
+title: Xin Cpu Test
 emoji: 😻
-colorFrom: gray
+colorFrom: indigo
 colorTo: blue
 sdk: gradio
 sdk_version: 4.22.0

app.py

@@ -0,0 +1,619 @@
+import gradio as gr
+import os
+from PIL import Image, ImageFont
+
+from typing import List
+from setting_names import names_mapping
+from utils import (
+    PixelColorPalette,
+    Painting,
+    ColorSelection,
+    ImageBoarder,
+    ImageText,
+    image_paste_methods,
+    HexagonGrid,
+    ColorPalette,
+    ImageManipulation
+)
+
+langangue = 'cn'
+abs_path_font = os.path.abspath(__file__).split(os.sep)[:-1]
+font_abs_path = os.sep.join(abs_path_font + ["fonts"])
+
+names = dict((label_name, lan[langangue]) for label_name, lan in names_mapping.items())
+def get_image_examples():
+    examples=[
+        os.path.join(os.path.dirname(__file__), "images/dam_01.png"),
+        os.path.join(os.path.dirname(__file__), "images/dam_02.png"),
+        os.path.join(os.path.dirname(__file__), "images/dam_03.png"),
+        os.path.join(os.path.dirname(__file__), "images/dam_04.png"),
+        os.path.join(os.path.dirname(__file__), "images/dam_05.png"),
+        os.path.join(os.path.dirname(__file__), "images/dam_06.png"),
+    ]
+    return examples
+
+
+# step1 reduce image colors
+def pixel_palette_image(raw_image: Image.Image,
+                transformation_method: str,
+                rgb_palette: str,
+                max_colors: int,
+                distance_strategy: str,) -> List[Image.Image]:
+    """This function will reduce the color into wanted number of colors."""
+    if not rgb_palette:
+        rgb_palette = None
+    print("mapping to colors...")
+    pcp = PixelColorPalette(pil_image=raw_image, 
+                            transformation_method=transformation_method, 
+                            rgb_palette=rgb_palette, 
+                            max_colors=max_colors, 
+                            distance_strategy=distance_strategy
+                            )
+    image = pcp.translate()
+    cp = ColorPalette(
+        pil_image=image, 
+        color_block_size=1,
+    )
+    rgb_string = cp.rgbs_string
+    print("Mapped to limited colors...")
+    return [image, rgb_string]
+    
+# setp2 pixel the image
+def big_tile():
+    return (50, 120, 25, 2, 1)
+def small_tile():
+    return (25, 60, 12, 1, 1)
+def map_tiles(
+        image: Image.Image,
+        painting_width: int,
+        painting_height: int,
+        tile_preset: str,
+        tile_width: int,
+        tile_height: int,
+        tile_height_tip: int,
+        gap_horizontal: int,
+        gap_vertical: int,
+        gap_color: str,
+        color_aggregate_type: str) -> None:
+    print("Creating Tiles...")
+    if tile_preset.startswith("large"):
+        tile_width, tile_height, tile_height_tip, gap_horizontal, gap_vertical = big_tile()
+    elif tile_preset.startswith("small"):
+        tile_width, tile_height, tile_height_tip, gap_horizontal, gap_vertical = small_tile()
+    tiles = Painting(
+        painting_width, 
+        painting_height, 
+        tile_width, 
+        tile_height, 
+        tile_height_tip, 
+        gap_horizontal, 
+        gap_vertical, 
+        gap_color
+    )
+    cs = ColorSelection(image, color_aggregate_type, tiles)
+    pil_image = cs.translate_image_tensor()
+    print("Created tileed image...")
+    return pil_image
+
+
+# step3 apply boarder
+def apply_boarder(image: Image.Image,
+                  left_boarder_dist: int,
+                  right_boarder_dist: int,
+                  top_boarder_dist: int,
+                  bottom_boarder_dist:  int,
+                  line_width: int,
+                  line_color: str,
+                  margin_left: int,
+                  margin_right: int,
+                  margin_top: int,
+                  margin_bottom: int) -> Image.Image:
+    print("Drawing boarder...")
+    ib = ImageBoarder(
+            image=image, 
+            line_distances={"left": left_boarder_dist, "right": right_boarder_dist, "top": top_boarder_dist, "bottom": bottom_boarder_dist}, 
+            line_width=line_width, 
+            line_color=line_color, 
+            margin_widths={"left": margin_left, "right": margin_right, "top": margin_top, "bottom": margin_bottom}
+    )
+    image = ib.add_custom_lines()
+    return image
+
+
+# step4 create header text
+def create_header_text(
+        image: Image.Image,
+        width: int,
+        height: int,
+        bg_color: str,
+        font_name: str,
+        font_size: int,
+        text_color: str, 
+        x_pos: int,
+        y_pos: int,
+        text: str,
+        onto_position_x: int,
+        onto_position_y: int
+        ) -> Image.Image:
+    print("Drawing header text...")
+    ti = ImageText(
+        width=width,
+        height=height, 
+        background_color=bg_color, 
+        text=text, 
+        font_name=font_name, 
+        font_size=font_size, 
+        text_color=text_color, 
+        text_position=(x_pos, y_pos),
+        abs_path=font_abs_path
+    )
+    text_image = ti.create_text_image()
+    image_paste = image_paste_methods(text_image, image, "no-resize", onto_position_x, onto_position_y, None, None)
+    result_image, result_mask = image_paste.paste_onto()
+    return result_image
+    
+
+# step5 color grid
+def create_color_grid(
+        image: Image.Image,
+        color_list: str,
+        hex_width: int,
+        hex_height: int, 
+        tip_height: int, 
+        bg_color: str,
+        onto_position_x: int,
+        onto_position_y: int
+        ) -> Image.Image:
+    print("Drawing color grid...")
+    hg = HexagonGrid(
+        colors=color_list, 
+        width=hex_width, 
+        hex_height=hex_height, 
+        tip_height=tip_height,
+        bg_color=bg_color
+    )
+    grid = hg.create_color_hexagon_grid()
+    image_paste = image_paste_methods(grid, image, "no-resize", onto_position_x, onto_position_y, None, None)
+    result_image, result_mask = image_paste.paste_onto()
+    return result_image
+
+
+# step6 top edge label
+def top_edge_label(
+        image: Image.Image,
+        width: int,
+        height: int,
+        bg_color: str,
+        font_name: str,
+        font_size: int,
+        text_color: str, 
+        x_pos: int,
+        y_pos: int,
+        text: str,
+        onto_position_x: int,
+        onto_position_y: int
+        ) -> Image.Image:
+    print("Drawing top label...")
+    ti = ImageText(
+        width=width,
+        height=height, 
+        background_color=bg_color, 
+        text=text, 
+        font_name=font_name, 
+        font_size=font_size, 
+        text_color=text_color, 
+        text_position=(x_pos, y_pos),
+        abs_path=font_abs_path
+        
+    )
+    text_image = ti.create_text_image()
+    image_paste = image_paste_methods(text_image, image, "no-resize", onto_position_x, onto_position_y, None, None)
+    result_image, result_mask = image_paste.paste_onto()
+    return result_image
+
+
+# step7 left edge label
+def left_edge_label(
+        image: Image.Image,
+        width: int,
+        height: int,
+        bg_color: str,
+        font_name: str,
+        font_size: int,
+        text_color: str, 
+        x_pos: int,
+        y_pos: int,
+        text: str,
+        onto_position_x: int,
+        onto_position_y: int
+        ) -> Image.Image:
+    print("Drawing left label...")
+    ti = ImageText(
+        width=width,
+        height=height, 
+        background_color=bg_color, 
+        text=text, 
+        font_name=font_name, 
+        font_size=font_size, 
+        text_color=text_color, 
+        text_position=(x_pos, y_pos),
+        abs_path=font_abs_path
+    )
+    text_image = ti.create_text_image()
+    im = ImageManipulation(text_image)
+    text_image = im.rotation(90)
+    image_paste = image_paste_methods(text_image, image, "no-resize", onto_position_x, onto_position_y, None, None)
+    result_image, result_mask = image_paste.paste_onto()
+    
+    return result_image
+
+
+# step8 right edge label
+def right_edge_label(
+        image: Image.Image,
+        width: int,
+        height: int,
+        bg_color: str,
+        font_name: str,
+        font_size: int,
+        text_color: str, 
+        x_pos: int,
+        y_pos: int,
+        text: str,
+        onto_position_x: int,
+        onto_position_y: int
+        ) -> Image.Image:
+    print("Drawing right label...")
+    ti = ImageText(
+        width=width,
+        height=height, 
+        background_color=bg_color, 
+        text=text, 
+        font_name=font_name, 
+        font_size=font_size, 
+        text_color=text_color, 
+        text_position=(x_pos, y_pos),
+        abs_path=font_abs_path
+    )
+    text_image = ti.create_text_image()
+    im = ImageManipulation(text_image)
+    text_image = im.rotation(90)
+    image_paste = image_paste_methods(text_image, image, "no-resize", onto_position_x, onto_position_y, None, None)
+    result_image, result_mask = image_paste.paste_onto()
+    return result_image
+
+
+# step8 bot edge label
+def bot_edge_label(
+        image: Image.Image,
+        width: int,
+        height: int,
+        bg_color: str,
+        font_name: str,
+        font_size: int,
+        text_color: str, 
+        x_pos: int,
+        y_pos: int,
+        text: str,
+        onto_position_x: int,
+        onto_position_y: int
+        ) -> Image.Image:
+    print("Drawing bottom label...")
+    ti = ImageText(
+        width=width,
+        height=height, 
+        background_color=bg_color, 
+        text=text, 
+        font_name=font_name, 
+        font_size=font_size, 
+        text_color=text_color, 
+        text_position=(x_pos, y_pos),
+        abs_path=font_abs_path
+    )
+    text_image = ti.create_text_image()
+    image_paste = image_paste_methods(text_image, image, "no-resize", onto_position_x, onto_position_y, None, None)
+    result_image, result_mask = image_paste.paste_onto()
+    return result_image
+
+with gr.Blocks() as demo:
+    gr.Markdown(names["page_header"])
+    with gr.Row(equal_height=False):
+        with gr.Column():
+            with gr.Accordion(open=True, label=names['raw_image']):
+                raw_image = gr.Image(type="pil")
+            btn = gr.Button(names['run'], variant="primary")
+
+            # parameters for image color reduce
+            with gr.Accordion(open=True, label=names["image_color_reduce_settings"]):
+                transformation_method = gr.Dropdown(
+                ["original", 
+                "lab_color", 
+                "lab_lightness", 
+                "lab_red_green", 
+                "lab_blue_yellow",
+                "brightness",
+                "hsv_color",
+                "hue",
+                "saturation",
+                "value"], label=names["transformation_method"], value="original")
+                max_colors = gr.Slider(minimum=1, maximum=30, step=1, value=16, label=names["max_colors"])
+                distance_strategy = gr.Dropdown(["euclidean", "cosine"], label=names["distance_strategy"], value="euclidean")
+                rgb_palette = gr.Textbox(placeholder=names["rgb_palette_place_holder"], label=names["rgb_palette"])
+                color_list = gr.Textbox(label=names["color_list"])
+
+            # parameters for tile settings
+            with gr.Accordion(open=False, label=names["tile_settings"]):
+                painting_width = gr.Number(precision=0, minimum=1, maximum=9999, step=1, label=names['painting_width'], value=4800)
+                painting_height = gr.Number(precision=0, minimum=1, maximum=9999, step=1, label=names['painting_height'], value=7000)
+                tile_preset = gr.Dropdown(["large(50*120)", "small(25*60)", "customize"], label=names["tile_preset"], value="large(50*120)")
+                tile_width = gr.Number(precision=0, minimum=1, maximum=999, step=1, label=names['tile_width'], value=50)
+                tile_height = gr.Number(precision=0, minimum=1, maximum=999, step=1, label=names['tile_height'], value=120)
+                tile_height_tip = gr.Number(precision=0, minimum=1, maximum=999, step=1, label=names['tile_height_tip'], value=25)
+                gap_horizontal = gr.Number(precision=0, minimum=0, maximum=99, step=1, label=names['gap_horizontal'], value=2)
+                gap_vertical = gr.Number(precision=0, minimum=0, maximum=99, step=1, label=names['gap_vertical'], value=1)
+                gap_color = gr.Dropdown(['black', 'white'], label=names["gap_color"], value='black')
+                color_aggregate_type = gr.Dropdown(['average', 'marjority'], label=names["color_aggregate_type"], value='marjority')
+
+            # parameters for boarder settings
+            with gr.Accordion(open=False, label=names["boader_settings"]):
+                left_boarder_dist = gr.Number(precision=0, minimum=-999, maximum=999, step=1, label=names['left_boarder_dist'], value=0)
+                right_boarder_dist = gr.Number(precision=0, minimum=-999, maximum=999, step=1, label=names['right_boarder_dist'], value=-11)
+                top_boarder_dist = gr.Number(precision=0, minimum=-999, maximum=999, step=1, label=names['top_boarder_dist'], value=-30)
+                bottom_boarder_dist = gr.Number(precision=0, minimum=-999, maximum=999, step=1, label=names['bottom_boarder_dist'], value=0)
+                line_width = gr.Number(precision=0, minimum=1, maximum=99, step=1, label=names['line_width'], value=10)
+                line_color = gr.Dropdown(['red', 'blue'], label=names["line_color"], value='red')
+                margin_left = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['margin_left'], value=350)
+                margin_right = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['margin_right'], value=350)
+                margin_top = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['margin_top'], value=700)
+                margin_bottom = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['margin_bottom'], value=200)
+
+            # parameters for header text settings
+            with gr.Accordion(open=False, label=names["header_text_settings"]):
+                header_text_width = gr.Number(precision=0, minimum=1, maximum=9999, step=1, label=names['text_width'], value=3000)
+                header_text_height = gr.Number(precision=0, minimum=1, maximum=9999, step=1, label=names['text_height'], value=400)
+                header_text_bg_color = gr.Dropdown(['black', 'white'], label=names["text_bg_color"], value='white')
+                header_font_name = gr.Dropdown(['华文细黑.ttf'], label=names["font_name"], value='华文细黑.ttf')
+                header_font_size = gr.Slider(minimum=1, maximum=999, step=1, value=80, label=names["font_size"])
+                header_text_color = gr.Dropdown(['black', 'white'], label=names["text_color"], value='black')
+                header_text_x_pos = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['text_x_pos'], value=0)
+                header_text_y_pos = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['text_y_pos'], value=0)
+                header_text_value = (
+                    "户尺寸： W4800*H7000MM (产品尺寸：W4800*H7066MM)\n"
+                    "格：33*80MM单颗粒密拼带边小鳞光\n"
+                    "工艺：手工注浆\n"
+                    "备注：颜色参��（16个色）"
+                )
+                header_text = gr.Text(value=header_text_value, label=names["text"])
+                header_onto_position_x = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['onto_position_x'], value=300)
+                header_onto_position_y = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['onto_position_y'], value=150)
+
+            # parameters for grid settings
+            with gr.Accordion(open=False, label=names["grid_settings"]):
+                hex_width = gr.Number(precision=0, minimum=1, maximum=999, step=1, label=names['hex_width'], value=100)
+                hex_height = gr.Number(precision=0, minimum=1, maximum=999, step=1, label=names['hex_height'], value=150)
+                tip_height = gr.Number(precision=0, minimum=1, maximum=999, step=1, label=names['tip_height'], value=50)
+                grid_bg_color = gr.Dropdown(['black', 'white'], label=names["grid_bg_color"], value='white')
+                grid_onto_position_x = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['onto_position_x'], value=2000)
+                grid_onto_position_y = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['onto_position_y'], value=300)
+
+            # parameters for top edge text settings
+            with gr.Accordion(open=False, label=names["top_edge_text_setting"]):
+                top_text_width = gr.Number(precision=0, minimum=1, maximum=9999, step=1, label=names['text_width'], value=300)
+                top_text_height = gr.Number(precision=0, minimum=1, maximum=9999, step=1, label=names['text_height'], value=80)
+                top_text_bg_color = gr.Dropdown(['black', 'white'], label=names["text_bg_color"], value='white')
+                top_font_name = gr.Dropdown(['华文细黑.ttf'], label=names["font_name"], value='华文细黑.ttf')
+                top_font_size = gr.Slider(minimum=1, maximum=999, step=1, value=60, label=names["font_size"])
+                top_text_color = gr.Dropdown(['black', 'white'], label=names["text_color"], value='black')
+                top_text_x_pos = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['text_x_pos'], value=0)
+                top_text_y_pos = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['text_y_pos'], value=0)
+                top_text_value = (
+                    "4800mm"
+                )
+                top_text = gr.Text(value=top_text_value, label=names["text"])
+                top_onto_position_x = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['onto_position_x'], value=2500)
+                top_onto_position_y = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['onto_position_y'], value=600)
+
+            # parameters for left edge text settings
+            with gr.Accordion(open=False, label=names["left_edge_text_setting"]):
+                left_text_width = gr.Number(precision=0, minimum=1, maximum=9999, step=1, label=names['text_width'], value=300)
+                left_text_height = gr.Number(precision=0, minimum=1, maximum=9999, step=1, label=names['text_height'], value=80)
+                left_text_bg_color = gr.Dropdown(['black', 'white'], label=names["text_bg_color"], value='white')
+                left_font_name = gr.Dropdown(['华文细黑.ttf'], label=names["font_name"], value='华文细黑.ttf')
+                left_font_size = gr.Slider(minimum=1, maximum=999, step=1, value=60, label=names["font_size"])
+                left_text_color = gr.Dropdown(['black', 'white'], label=names["text_color"], value='black')
+                left_text_x_pos = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['text_x_pos'], value=0)
+                left_text_y_pos = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['text_y_pos'], value=0)
+                left_text_value = (
+                    "7066mm"
+                )
+                left_text = gr.Text(value=left_text_value, label=names["text"])
+                left_onto_position_x = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['onto_position_x'], value=200)
+                left_onto_position_y = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['onto_position_y'], value=3500)
+
+            # parameters for right edge text settings
+            with gr.Accordion(open=False, label=names["right_edge_text_setting"]):
+                right_text_width = gr.Number(precision=0, minimum=1, maximum=9999, step=1, label=names['text_width'], value=300)
+                right_text_height = gr.Number(precision=0, minimum=1, maximum=9999, step=1, label=names['text_height'], value=80)
+                right_text_bg_color = gr.Dropdown(['black', 'white'], label=names["text_bg_color"], value='white')
+                right_font_name = gr.Dropdown(['华文细黑.ttf'], label=names["font_name"], value='华文细黑.ttf')
+                right_font_size = gr.Slider(minimum=1, maximum=999, step=1, value=60, label=names["font_size"])
+                right_text_color = gr.Dropdown(['black', 'white'], label=names["text_color"], value='black')
+                right_text_x_pos = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['text_x_pos'], value=0)
+                right_text_y_pos = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['text_y_pos'], value=0)
+                right_text_value = (
+                    "7000mm"
+                )
+                right_text = gr.Text(value=right_text_value, label=names["text"])
+                right_onto_position_x = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['onto_position_x'], value=5200)
+                right_onto_position_y = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['onto_position_y'], value=3500)
+
+            # parameters for bot edge text settings
+            with gr.Accordion(open=False, label=names["bot_edge_text_setting"]):
+                bot_text_width = gr.Number(precision=0, minimum=1, maximum=9999, step=1, label=names['text_width'], value=300)
+                bot_text_height = gr.Number(precision=0, minimum=1, maximum=9999, step=1, label=names['text_height'], value=80)
+                bot_text_bg_color = gr.Dropdown(['black', 'white'], label=names["text_bg_color"], value='white')
+                bot_font_name = gr.Dropdown(['华文细黑.ttf'], label=names["font_name"], value='华文细黑.ttf')
+                bot_font_size = gr.Slider(minimum=1, maximum=999, step=1, value=60, label=names["font_size"])
+                bot_text_color = gr.Dropdown(['black', 'white'], label=names["text_color"], value='black')
+                bot_text_x_pos = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['text_x_pos'], value=0)
+                bot_text_y_pos = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['text_y_pos'], value=0)
+                bot_text_value = (
+                    "4800mm"
+                )
+                bot_text = gr.Text(value=bot_text_value, label=names["text"])
+                bot_onto_position_x = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['onto_position_x'], value=2500)
+                bot_onto_position_y = gr.Number(precision=0, minimum=0, maximum=9999, step=1, label=names['onto_position_y'], value=7700)
+
+        with gr.Column():
+            final_image = gr.Image(type="pil", label=names['output_image'])
+            gr.Examples(
+                    examples=get_image_examples(),
+                    inputs=[raw_image],
+                    fn=None,
+                    outputs=[final_image],
+                    cache_examples=False,
+                    label=names['examples']
+                )
+    btn.click(
+        fn=pixel_palette_image, 
+        inputs=[
+            raw_image,
+            transformation_method,
+            rgb_palette,
+            max_colors,
+            distance_strategy
+        ],
+        outputs=[final_image, color_list]
+    ).then(
+        fn=map_tiles,
+        inputs=[
+            final_image,
+            painting_width,
+            painting_height,
+            tile_preset,
+            tile_width,
+            tile_height,
+            tile_height_tip,
+            gap_horizontal,
+            gap_vertical,
+            gap_color,
+            color_aggregate_type
+        ],
+        outputs=final_image
+    ).then(
+        fn=apply_boarder,
+        inputs=[
+            final_image,
+            left_boarder_dist,
+            right_boarder_dist,
+            top_boarder_dist,
+            bottom_boarder_dist,
+            line_width,
+            line_color,
+            margin_left,
+            margin_right,
+            margin_top,
+            margin_bottom
+        ],
+        outputs=final_image
+    ).then(
+        fn=create_header_text,
+        inputs=[
+            final_image,
+            header_text_width,
+            header_text_height,
+            header_text_bg_color,
+            header_font_name,
+            header_font_size,
+            header_text_color, 
+            header_text_x_pos,
+            header_text_y_pos,
+            header_text,
+            header_onto_position_x,
+            header_onto_position_y
+        ],
+        outputs=final_image
+    ).then(
+        fn=create_color_grid,
+        inputs=[
+            final_image,
+            color_list,
+            hex_width,
+            hex_height, 
+            tip_height, 
+            grid_bg_color,
+            grid_onto_position_x,
+            grid_onto_position_y
+        ],
+        outputs=final_image
+    ).then(
+        fn=top_edge_label,
+        inputs=[
+            final_image,
+            top_text_width,
+            top_text_height,
+            top_text_bg_color,
+            top_font_name,
+            top_font_size,
+            top_text_color, 
+            top_text_x_pos,
+            top_text_y_pos,
+            top_text,
+            top_onto_position_x,
+            top_onto_position_y
+        ],
+        outputs=final_image
+    ).then(
+        fn=left_edge_label,
+        inputs=[
+            final_image,
+            left_text_width,
+            left_text_height,
+            left_text_bg_color,
+            left_font_name,
+            left_font_size,
+            left_text_color, 
+            left_text_x_pos,
+            left_text_y_pos,
+            left_text,
+            left_onto_position_x,
+            left_onto_position_y
+        ],
+        outputs=final_image
+    ).then(
+        fn=left_edge_label,
+        inputs=[
+            final_image,
+            right_text_width,
+            right_text_height,
+            right_text_bg_color,
+            right_font_name,
+            right_font_size,
+            right_text_color, 
+            right_text_x_pos,
+            right_text_y_pos,
+            right_text,
+            right_onto_position_x,
+            right_onto_position_y
+        ],
+        outputs=final_image
+    ).then(
+        fn=bot_edge_label,
+        inputs=[
+            final_image,
+            bot_text_width,
+            bot_text_height,
+            bot_text_bg_color,
+            bot_font_name,
+            bot_font_size,
+            bot_text_color, 
+            bot_text_x_pos,
+            bot_text_y_pos,
+            bot_text,
+            bot_onto_position_x,
+            bot_onto_position_y
+        ],
+        outputs=final_image
+    )
+
+demo.launch(share=False)

gitignore

@@ -0,0 +1,136 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+# Usually these files are written by a python script from a template
+# before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+venv/
+ENV/
+env/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/

requirements.txt

@@ -0,0 +1,9 @@
+torch==2.2.1
+torchvision==0.17.1
+langchain==0.1.11
+faiss-cpu==1.8.0
+pillow==10.2.0
+chardet==5.2.0
+scikit-image==0.22.0
+scikit-learn==1.4.1.post1
+emoji==2.10.1

setting_names.py

@@ -0,0 +1,236 @@
+names_mapping = {
+    'page_header': {
+        "en": "Upload an image or select an example to start",
+        'cn':  "上传图片或者从右侧选择案列以开始"
+    },
+
+    'raw_image': {
+        "en":  "Raw image",
+        'cn':  "原图"
+    },
+
+
+    "image_color_reduce_settings": {
+        "en":  "Image Color Reduce Settings",
+        'cn':  "图片颜色数量设置",
+    },
+    'input_image':  {
+        "en":  "Input Image",
+        'cn':  "输入图片",
+    },
+    "transformation_method": {
+        "en":  "Transformation Method",
+        'cn':  "转换方法",
+    },
+    "distance_strategy":  {
+        "en":  "Distance Strategy",
+        'cn':  "距离方法",
+    },
+    "max_colors": {
+        "en":  "Max Colors",
+        'cn':  "最大颜色数量",
+    },
+    "rgb_palette": {
+        "en":  "RBG Palette",
+        'cn':  "RBG色板",
+    },
+    "rgb_palette_place_holder": {
+        "en": "RGBs for mapping, if empty, it will find colors automatically with max colors",
+        'cn': "目标RBG参数，可不填，则默认自动找到最大颜色数量的颜色",
+    },
+    "color_list": {
+        "en": "RBG list of reduced color image",
+        'cn':  "保留的RGB颜色",
+    },
+
+    "tile_settings": {
+        "en": "Tile Settings",
+        'cn':  "砖块设置",
+    },
+    "painting_width": {
+        "en": "Final Image Width",
+        'cn':  "墙面宽度",
+    },
+    "painting_height": {
+        "en": "Final Image Height",
+        'cn':  "墙面高度",
+    },
+    "tile_preset": {
+        "en": "Tile Preset",
+        'cn':  "砖块预设",
+    },
+    "tile_width": {
+        "en": "Tile Width",
+        'cn':  "砖块宽度",
+    },
+    "tile_height": {
+        "en": "Tile Height(Total)",
+        'cn':  "砖块高度(包括尖部)",
+    },
+    "tile_height_tip": {
+        "en": "Tile Tip Height",
+        'cn':  "尖部高度",
+    },
+    "gap_horizontal": {
+        "en": "Horizontal Gap",
+        'cn':  "横向缝隙",
+    },
+    "gap_vertical": {
+        "en": "Veritcal Gap",
+        'cn':  "纵向缝隙",
+    },
+    "gap_color": {
+        "en": "Gap Color",
+        'cn':  "缝隙颜色",
+    },
+    "color_aggregate_type": {
+        "en": "Aggregate Color Method",
+        'cn':  "颜色聚敛方法",
+    },
+
+    "boader_settings": {
+        "en": "Boarder Settings",
+        'cn':  "边框设定",
+    },
+    'left_boarder_dist': {
+        "en": "Left Line Distance",
+        'cn':  "左边框距离",
+    },
+    'right_boarder_dist': {
+        "en": "Right Line Distance",
+        'cn':  "右边框距离",
+    },
+    'top_boarder_dist': {
+        "en": "Top Line Distance",
+        'cn':  "上边框距离",
+    },
+    'bottom_boarder_dist':  {
+        "en": "Bottom Line Distance",
+        'cn':  "下边框距离",
+    },
+    'line_width': {
+        "en": "Line Width",
+        'cn':  "边框粗细",
+    },
+    'line_color': {
+        "en": "Line Color",
+        'cn':  "边框颜色",
+    },
+    'margin_left': {
+        "en": "Left Margin",
+        'cn':  "左留白",
+    },
+    'margin_right': {
+        "en": "Right Margin",
+        'cn':  "右留白",
+    },
+    'margin_top': {
+        "en": "Top Margin",
+        'cn':  "上留白",
+    },
+    'margin_bottom': {
+        "en": "Bottom Margin",
+        'cn':  "下留白",
+    },
+
+    "header_text_settings": {
+        "en": "Header Text Settings",
+        'cn':  "主要文字说明",
+    },
+    'text_width': {
+        "en": 'Text Image Width',
+        'cn':  "文字图片宽度",
+    },
+    'text_height': {
+        "en": 'Text Image Height',
+        'cn':  "文字图片高度",
+    },
+    'text_bg_color': {
+        "en": 'Text Image BG Color',
+        'cn':  "文字图片背景颜色",
+    },
+    'font_name': {
+        "en": 'Font Type',
+        'cn':  "字体",
+    },
+    'font_size': {
+        "en": 'Font Size',
+        'cn':  "字号",
+    },
+    'text_color': {
+        "en": 'Font Color', 
+        'cn':  "字体颜色",
+    },
+    'text_x_pos': {
+        "en": 'Text Pos in Text Image X',
+        'cn':  "文字在图片位置X",
+    },
+    'text_y_pos': {
+        "en": 'Text Pos in Text Image Y',
+        'cn':  "文字在图片位置Y",
+    },
+    'text': {
+        "en": 'Text Value',
+        'cn':  "文字",
+    },
+    "onto_position_x": {
+        "en": "Paste to X",
+        'cn':  "文字图片在原图位置X",
+    },
+    "onto_position_y": {
+        "en": "Paste to Y",
+        'cn':  "文字图片在原图位置Y",
+    },
+
+    "grid_settings": {
+        "en": "Color Grid Settings",
+        'cn':  "颜色网格设定",
+    },
+    'hex_width': {
+        "en": 'Hex Width',
+        'cn':  "六边形宽度",
+    },
+    'hex_height': {
+        "en": 'Hex Height(Middle Only)', 
+        'cn':  "六边形高度(仅腰部)",
+    },
+    'tip_height': {
+        "en": 'Hex Tip Height', 
+        'cn':  "六边形尖部高度",
+    },
+    'grid_bg_color': {
+        "en": 'Hex Grid BG Color',
+        'cn':  "六边形图片背景颜色",
+    },
+
+    "top_edge_text_setting": {
+        "en": "Top Label",
+        'cn':  "上边缘标记",
+    },
+    "left_edge_text_setting": {
+        "en": "Left Label",
+        'cn':  "左边缘标记",
+    },
+    "right_edge_text_setting": {
+        "en": "Right Label",
+        'cn':  "右边缘标记",
+    },
+    "bot_edge_text_setting": {
+        "en": "Bottom Label",
+        'cn':  "下边缘标记",
+    },
+
+    "output_image": {
+        "en": "Output Image",
+        'cn':  "输入图片",
+    },
+
+    "run": {
+        "en": "Run",
+        'cn':  "运行",
+    },
+    "examples": {
+        "en": "Examples",
+        'cn':  "案例",
+    },
+}

utils/__init__.py

@@ -0,0 +1,21 @@
+from .pixel_color_palette import PixelColorPalette
+from .utils_haxagon_pixel import Tile, Painting, ColorSelection
+from .utils_image_boarder import ImageBoarder
+from .utils_image_text import ImageText
+from .image_combine import image_paste_methods
+from .utils_haxagon_color_grid import HexagonGrid
+from .utils_image_color_distribution import ColorPalette
+from .utils_image_modification import ImageManipulation
+
+__all__ = [
+    "PixelColorPalette",
+    "Tile",
+    "Painting",
+    "ColorSelection",
+    "ImageBoarder",
+    "ImageText",
+    "image_paste_methods",
+    "HexagonGrid",
+    "ColorPalette",
+    "ImageManipulation"
+]

utils/image_combine.py

@@ -0,0 +1,299 @@
+from PIL import Image
+from torch import Tensor 
+from torchvision import transforms
+import torch
+
+from typing import Union
+
+
+class image_paste_methods:
+    def __init__(
+            self, 
+            pil_image1: Image.Image, 
+            pil_image2: Image.Image, 
+            resize_mode: str, 
+            x: int,
+            y: int,
+            image1_mask: Union[Tensor, None], 
+            image2_mask: Union[Tensor, None]
+            ) -> None:
+        self.image1 = pil_image1
+        self.image1_alpha = None
+
+        self.image2 = pil_image2
+        self.image2_alpha = None
+
+        if image1_mask is not None:
+            self.image1_alpha = self.transform_tensor_to_pil(image1_mask.unsqueeze(-1))
+        
+        if image2_mask is not None:
+            self.image2_alpha = self.transform_tensor_to_pil(image2_mask.unsqueeze(-1))
+
+        self.resize_mode = resize_mode
+        self.x = x
+        self.y = y
+
+    @staticmethod
+    def transform_pil_to_tensor(pil_image: Image) -> Tensor:
+        """Conver pil image into tensor."""
+        # transform PIL into tensor
+        transform = transforms.Compose([
+            transforms.ToTensor(),  # Convert the image to a tensor
+        ])
+        image_tensor = transform(pil_image)
+        image_tensor = image_tensor.unsqueeze(0)
+        image_tensor = image_tensor.permute(0, 2, 3, 1)
+        return image_tensor
+    
+    @staticmethod
+    def transform_tensor_to_pil(image_tensor: Tensor) -> Image:
+        """Convert tensor image into PIL."""
+        # Ensure the tensor is in the correct shape (C, H, W)
+        if image_tensor.dim() == 4:
+            # Assuming the tensor shape is [B, H, W, C], 
+            # permute it to [B, C, H, W] then remove the batch dimension
+            image_tensor = image_tensor.permute(0, 3, 1, 2).squeeze(0)
+        elif image_tensor.dim() == 3:
+            # If the tensor is [H, W, C], permute it to [C, H, W]
+            image_tensor = image_tensor.permute(2, 0, 1)
+
+        to_pil_image = transforms.ToPILImage()
+        pil_image = to_pil_image(image_tensor)
+        return pil_image
+    
+    @staticmethod
+    def paste_by_alpha(base_image: Image, 
+                       source_image: Image, 
+                       source_image_alpha: Image, 
+                       x: int, 
+                       y: int
+                       ) -> Image:
+        if source_image_alpha:
+            base_image.paste(source_image, (x, y), source_image_alpha)
+        else:
+            base_image.paste(source_image, (x, y))
+        return base_image
+    
+    @staticmethod
+    def update_mask_with_content(base_mask: Image, source_image: Image, x: int, y: int) -> Image:
+        """Update the base mask by clearing areas where the source image has actual content."""
+        source_image_data = source_image.convert("RGBA").getdata()
+        base_mask_data = base_mask.getdata()
+
+        for row in range(source_image.height):
+            for col in range(source_image.width):
+                src_pixel_index = row * source_image.width + col
+                base_pixel_index = (row + y) * base_mask.width + (col + x)
+
+                # Check if the source image pixel is not transparent
+                if source_image_data[src_pixel_index][3] > 0:
+                    # Update the base mask to remove the mask at this pixel
+                    base_mask_data[base_pixel_index] = 0
+
+        base_mask.putdata(list(base_mask_data))
+        return base_mask
+    
+    @staticmethod
+    def combine_masks(base_mask: Image, source_mask: Image, x: int, y: int) -> Image:
+        """Combine two masks, only for onto paste type."""
+        # Determine the dimensions required to fit both masks
+        source_left = x
+        source_top = y
+        source_right = x + source_mask.width
+        source_bot =  y + source_mask.height
+
+        base_left = 0
+        base_top = 0
+        base_right = base_mask.width
+        base_bot = base_mask.height
+
+        minx = min([source_left, base_left])
+        maxx = max([source_right, base_right])
+
+        miny = min([source_top, base_top])
+        maxy = max([source_bot, base_bot])
+
+        new_width = maxx - minx
+        new_height = maxy - miny
+
+        combined_mask = Image.new('L', (new_width, new_height), 0)
+        if source_left < base_left:
+            if source_top < base_top:    
+                combined_mask.paste(base_mask, (-x, -y))
+                combined_mask.paste(source_mask, (0, 0), source_mask)
+            else:
+                combined_mask.paste(base_mask, (-x, 0))
+                combined_mask.paste(source_mask, (0, y), source_mask)
+
+        else:
+            if source_top < base_top:    
+                combined_mask.paste(base_mask, (0, -y))
+                combined_mask.paste(source_mask, (x, 0), source_mask)
+            else:
+                combined_mask.paste(base_mask, (0, 0))
+                combined_mask.paste(source_mask, (x, y), source_mask)
+        return image_paste_methods.transform_pil_to_tensor(combined_mask).squeeze(-1)
+
+
+    def paste_horizontal(self) -> Image:
+        """Paste 2 images horizontally with optional resizing."""
+        image1 = self.image1
+        image2 = self.image2
+
+        width1, height1 = image1.size
+        width2, height2 = image2.size
+
+        if self.resize_mode != "no-resize":
+            if self.resize_mode == 'to-big':
+                new_height = max(height1, height2)
+            elif self.resize_mode == 'to-small':
+                new_height = min(height1, height2)
+            image1 = image1.resize((int(width1 * new_height / height1), new_height))
+            image2 = image2.resize((int(width2 * new_height / height2), new_height))
+            if self.image1_alpha:
+                self.image1_alpha = self.image1_alpha.resize((int(width1 * new_height / height1), new_height))
+            if self.image2_alpha:
+                self.image2_alpha = self.image2_alpha.resize((int(width2 * new_height / height2), new_height))
+
+        if self.image1_alpha is not None:
+            if self.image2_alpha is not None:
+                new_mask = self.combine_masks(
+                    self.image2_alpha, 
+                    self.image1_alpha,
+                    0-image1.width, 
+                    0)
+            else:
+                new_mask = self.combine_masks(
+                    self.transform_tensor_to_pil(torch.zeros(1, image2.height, image2.width).unsqueeze(-1)), 
+                    self.image1_alpha,
+                    0-image1.width, 
+                    0)
+        else:
+            if self.image2_alpha is not None:
+                new_mask = self.combine_masks(
+                    self.image2_alpha, 
+                    self.transform_tensor_to_pil(torch.zeros(1, image1.height, image1.width).unsqueeze(-1)),
+                    0-image1.width, 
+                    0)
+            else:
+                new_mask = self.combine_masks(
+                    self.transform_tensor_to_pil(torch.zeros(1, image2.height, image2.width).unsqueeze(-1)), 
+                    self.transform_tensor_to_pil(torch.zeros(1, image1.height, image1.width).unsqueeze(-1)),
+                    0-image1.width, 
+                    0)
+
+        result_width = image1.width + image2.width
+        result_height = max(image1.height, image2.height)
+        result_image = Image.new('RGB', (result_width, result_height))
+
+        result_image = self.paste_by_alpha(result_image, image1, self.image1_alpha, 0, 0)
+        result_image = self.paste_by_alpha(result_image, image2, self.image2_alpha, image1.width, 0)
+
+        return result_image, new_mask
+    
+
+    def paste_vertical(self) -> Image:
+        """Paste 2 images vertically with optional resizing."""
+        image1 = self.image1
+        image2 = self.image2
+
+        width1, height1 = image1.size
+        width2, height2 = image2.size
+
+
+        if self.resize_mode != "no-resize":
+            if self.resize_mode == 'to-big':
+                new_width = max(width1, width2)
+            elif self.resize_mode == 'to-small':
+                new_width = min(width1, width2)
+            image1 = image1.resize((new_width, int(height1 * new_width / width1)))
+            image2 = image2.resize((new_width, int(height2 * new_width / width2)))
+
+            if self.image1_alpha:
+                self.image1_alpha = self.image1_alpha.resize((new_width, int(height1 * new_width / width1)))
+            if self.image2_alpha:
+                self.image2_alpha = self.image2_alpha.resize((new_width, int(height2 * new_width / width2)))
+
+
+        if self.image1_alpha is not None:
+            if self.image2_alpha is not None:
+                new_mask = self.combine_masks(
+                    self.image2_alpha, 
+                    self.image1_alpha,
+                    0, 
+                    0-image1.height)
+            else:
+                new_mask = self.combine_masks(
+                    self.transform_tensor_to_pil(torch.zeros(1, image2.height, image2.width).unsqueeze(-1)), 
+                    self.image1_alpha,
+                    0, 
+                    0-image1.height)
+                
+        else:
+            if self.image2_alpha is not None:
+                new_mask = self.combine_masks(
+                    self.image2_alpha, 
+                    self.transform_tensor_to_pil(torch.zeros(1, image1.height, image1.width).unsqueeze(-1)),
+                    0, 
+                    0-image1.height)
+            else:
+                new_mask = self.combine_masks(
+                    self.transform_tensor_to_pil(torch.zeros(1, image2.height, image2.width).unsqueeze(-1)), 
+                    self.transform_tensor_to_pil(torch.zeros(1, image1.height, image1.width).unsqueeze(-1)),
+                    0, 
+                    0-image1.height)
+
+        result_width = max(image1.width, image2.width)
+        result_height = image1.height + image2.height
+        result_image = Image.new('RGB', (result_width, result_height))
+
+        result_image = self.paste_by_alpha(result_image, image1, self.image1_alpha, 0, 0)
+        result_image = self.paste_by_alpha(result_image, image2, self.image2_alpha, 0, image1.height)
+        return result_image, new_mask
+
+
+    def paste_onto(self) -> Image:
+        """Paste image1 onto image2 at position (x, y), creating a new image that fits both."""
+        image1 = self.image1
+        image2 = self.image2
+
+        width1, height1 = image1.size
+        width2, height2 = image2.size
+        # Calculate new image size
+        new_width = max(width1 + max(0, self.x), width2 + max(0, -self.x))
+        new_height = max(height1 + max(0, self.y), height2 + max(0, -self.y))
+        # create new empty image, that can contain both 1 and 2
+        new_image = Image.new('RGBA', (new_width, new_height), (255, 255, 255, 0))
+        # calculate location
+        image1_position = (max(0, self.x), max(0, self.y))
+        image2_position = (max(0, -self.x), max(0, -self.y))
+
+
+        # paste both onto new empty image
+        new_image = self.paste_by_alpha(new_image, image2, self.image2_alpha, image2_position[0], image2_position[1])
+        new_image = self.paste_by_alpha(new_image, image1, self.image1_alpha, image1_position[0], image1_position[1])
+
+        if self.image1_alpha is not None:
+            if self.image2_alpha is not None:
+                new_mask = self.combine_masks(self.image2_alpha, 
+                                   self.image1_alpha,
+                                   self.x, 
+                                   self.y)
+            else:
+                new_mask = self.combine_masks(self.transform_tensor_to_pil(torch.zeros(1, height2, width2).unsqueeze(-1)), 
+                                   self.image1_alpha,
+                                   self.x, 
+                                   self.y)
+                
+        else:
+            if self.image2_alpha is not None:
+                new_mask = self.combine_masks(self.image2_alpha, 
+                                   self.transform_tensor_to_pil(torch.zeros(1, height1, width1).unsqueeze(-1)),
+                                   self.x, 
+                                   self.y)
+            else:
+                new_mask = self.combine_masks(self.transform_tensor_to_pil(torch.zeros(1, height2, width2).unsqueeze(-1)), 
+                                   self.transform_tensor_to_pil(torch.zeros(1, height1, width1).unsqueeze(-1)),
+                                   self.x, 
+                                   self.y)
+        return new_image, new_mask

utils/pixel_color_palette.py

@@ -0,0 +1,220 @@
+import ast
+import colorsys
+from PIL import Image
+import numpy as np
+from typing import List, Tuple, Union, Callable, Any
+from tqdm import tqdm
+from sklearn.cluster import KMeans
+from langchain_community.vectorstores.utils import DistanceStrategy
+from torch import Tensor 
+import torchvision.transforms as transforms
+from skimage import color
+from .utils_vector_store import FaissVectorStore, MockEmbedding
+import os
+os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
+
+class RGBTransformation:
+    @staticmethod
+    def original(rgbs: List[Tuple]) -> List[Tuple]:
+        return rgbs
+
+    @staticmethod
+    def lab_color(rgbs: List[Tuple]) -> List[Tuple]:
+        """Convert rgb to lab color."""
+        return color.rgb2lab(np.array(rgbs)/255).tolist()
+    
+    @staticmethod
+    def lab_lightness(rgbs: List[Tuple]) -> List[Tuple]:
+        """Convert rgb to lightness color."""
+        return color.rgb2lab(np.array(rgbs)/255)[:,0].reshape(-1, 1).tolist()    
+
+    @staticmethod
+    def lab_red_green(rgbs: List[Tuple]) -> List[Tuple]:
+        """Convert rgb to red green color."""
+        return color.rgb2lab(np.array(rgbs)/255)[:,1].reshape(-1, 1).tolist()    
+
+    @staticmethod
+    def lab_blue_yellow(rgbs: List[Tuple]) -> List[Tuple]:
+        """Convert rgb to blue yellow color."""
+        return color.rgb2lab(np.array(rgbs)/255)[:,2].reshape(-1, 1).tolist()    
+
+    @staticmethod
+    def brightness(rgbs: List[Tuple]) -> List[Tuple]:
+        """Convert rgb to brightness"""
+        return (np.array(rgbs)/3).sum(axis=1).reshape(-1, 1).tolist()
+    
+
+    @staticmethod
+    def hsv_color(rgbs: List[Tuple]) -> List[Tuple]:
+        """Convert rgb to hsv"""
+        return [list(colorsys.rgb_to_hsv(*rgb)) for rgb in rgbs]
+    
+    
+    @staticmethod
+    def hue(rgbs: List[Tuple]) -> List[Tuple]:
+        """Convert rgb to hue"""
+        return [[colorsys.rgb_to_hsv(*rgb)[0]] for rgb in rgbs]
+    
+
+    @staticmethod
+    def saturation(rgbs: List[Tuple]) -> List[Tuple]:
+        """Convert rgb to saturation"""
+        return [[colorsys.rgb_to_hsv(*rgb)[1]] for rgb in rgbs]
+    
+
+    @staticmethod
+    def value(rgbs: List[Tuple]) -> List[Tuple]:
+        """Convert rgb to value"""
+        return [[colorsys.rgb_to_hsv(*rgb)[2]] for rgb in rgbs]
+    
+
+    def call_method(self, method_name: str) -> Callable[..., Any]:
+        """Get the corresponding method by name"""
+        method = getattr(self, method_name, lambda: "method not exist.")
+        return method
+
+
+class PixelColorPalette:
+    def __init__(
+            self,
+            pil_image: Image.Image,
+            transformation_method: str,
+            rgb_palette: Union[str, None],
+            max_colors: int, # will be overwrite by rgb_palette,
+            distance_strategy: str
+    ) -> None:
+        """Initialize translation."""
+        self.pil_image = pil_image
+        self.pixels = self.pil_image.load()
+        self.transformation_method = transformation_method
+        self.rgb_palette = rgb_palette
+        self.max_colors = max_colors
+        self.transformation_function = RGBTransformation().call_method(transformation_method)
+        if distance_strategy == "cosine":
+            distance_strategy =DistanceStrategy.COSINE
+        elif distance_strategy == "euclidean":
+            distance_strategy =DistanceStrategy.EUCLIDEAN_DISTANCE
+
+        self.width = self.pil_image.size[0]
+        self.height = self.pil_image.size[1]
+    
+        self.original_rgbs = []
+        for px in range(self.width):
+            for py in range(self.height):
+                self.original_rgbs.append(self.pixels[px, py])
+        self.color_maps = self.transformation_function(self.original_rgbs)
+
+        # if specied palette we create our vector db for color map
+        if self.rgb_palette:
+            all_rgb_doc = []
+            metadatas = []
+            self.color_palette = self.parse_string_to_tuples(self.rgb_palette)
+            self.color_space = self.transformation_function(self.color_palette)
+            for (r, g, b), colormap in zip(self.color_palette, self.color_space):
+                all_rgb_doc.append(('', colormap))
+                metadatas.append({'r': r, "g": g, "b": b})
+            self.faiss_db = FaissVectorStore(all_rgb_doc, 
+                                            metadatas, 
+                                            MockEmbedding(), 
+                                            distance_strategy=distance_strategy)
+        else:
+            all_rgb_doc = []
+            metadatas = []
+            for (r, g, b), colormap in zip(self.original_rgbs, self.color_maps):
+                all_rgb_doc.append(('', colormap))
+                metadatas.append({'r': r, "g": g, "b": b})
+            self.faiss_db = FaissVectorStore(all_rgb_doc, 
+                                            metadatas, 
+                                            MockEmbedding(), 
+                                            distance_strategy=distance_strategy)
+            self.clustering_color_group()
+
+    @staticmethod
+    def parse_string_to_tuples(s: str) -> List[Tuple]:
+        # Remove spaces to avoid issues with ast.literal_eval
+        s_cleaned = ''.join(s.split())
+        # Wrap the string in brackets to make it a list literal
+        s_list_literal = f'[{s_cleaned}]'
+        try:
+            # Safely evaluate the string as a Python literal
+            result = ast.literal_eval(s_list_literal)
+        except ValueError:
+            # Handle the case where the string could not be parsed
+            result = []
+        return result
+
+
+    @staticmethod
+    def transform_pil_to_tensor(pil_image: Image) -> Tensor:
+        """Conver pil image into tensor."""
+        # transform PIL into tensor
+        transform = transforms.Compose([
+            transforms.ToTensor(),  # Convert the image to a tensor
+        ])
+        image_tensor = transform(pil_image)
+        image_tensor = image_tensor.unsqueeze(0)
+        image_tensor = image_tensor.permute(0, 2, 3, 1)
+        return image_tensor
+    
+    @staticmethod
+    def transform_tensor_to_pil(image_tensor: Tensor) -> Image:
+        """Convert tensor image into PIL."""
+        # Ensure the tensor is in the correct shape (C, H, W)
+        if image_tensor.dim() == 4:
+            # Assuming the tensor shape is [B, H, W, C], 
+            # permute it to [B, C, H, W] then remove the batch dimension
+            image_tensor = image_tensor.permute(0, 3, 1, 2).squeeze(0)
+        elif image_tensor.dim() == 3:
+            # If the tensor is [H, W, C], permute it to [C, H, W]
+            image_tensor = image_tensor.permute(2, 0, 1)
+
+        to_pil_image = transforms.ToPILImage()
+        pil_image = to_pil_image(image_tensor)
+        return pil_image
+    
+    def clustering_color_group(self) -> None:
+        """Get the color groups using Kmean"""
+        X = np.array(self.color_maps)
+        self.kmeans = KMeans(n_clusters=self.max_colors, random_state=0, n_init=self.max_colors).fit(X)
+        center_rgbs = []
+        for center in self.kmeans.cluster_centers_.tolist():
+            rgb_metadata = self.faiss_db.db.similarity_search_by_vector(center)[0].metadata
+            given_r = rgb_metadata['r']
+            given_g = rgb_metadata['g']
+            given_b = rgb_metadata['b']   
+            center_rgbs.append([given_r, given_g, given_b])
+        self.center_rgbs = np.array(center_rgbs)
+        
+    def translate_image_vector_db(self) -> Image.Image:   
+        """Get the image with new mapped colors."""     
+        processed_img_final = Image.new('RGB', (self.width, self.height), (255, 255, 255))
+        for ix, px in enumerate(tqdm(range(self.width))):
+            for iy, py in enumerate(range(self.height)):
+                color_transformed = self.color_maps[ix * self.height + iy]
+                rgb_metadata = self.faiss_db.db.similarity_search_by_vector(color_transformed)[0].metadata
+                given_r = rgb_metadata['r']
+                given_g = rgb_metadata['g']
+                given_b = rgb_metadata['b']   
+                processed_img_final.putpixel((px, py), (given_r, given_g, given_b))
+        return processed_img_final
+
+
+    def translate_image_kmean(self) -> Image.Image:
+        """Get the image with new clustered colors."""     
+        mapped_rgb_colors = self.center_rgbs[self.kmeans.labels_]
+        processed_img_final = Image.new('RGB', (self.width, self.height), (255, 255, 255))
+        for ix, px in enumerate(tqdm(range(self.width))):
+            for iy, py in enumerate(range(self.height)):
+                rgb_transformed = mapped_rgb_colors[ix * self.height + iy]
+                given_r = rgb_transformed[0]
+                given_g = rgb_transformed[1]
+                given_b = rgb_transformed[2]   
+                processed_img_final.putpixel((px, py), (given_r, given_g, given_b))
+        return processed_img_final
+    
+    def translate(self) -> Tensor:
+        """Return final image tensor."""
+        if self.rgb_palette:
+            return self.translate_image_vector_db()
+        else:
+            return self.translate_image_kmean()

utils/utils_haxagon_color_grid.py

@@ -0,0 +1,68 @@
+import ast
+from PIL import Image, ImageDraw
+from typing import Tuple, List
+
+
+class HexagonGrid:
+    def __init__(self, colors: str, width: int, hex_height: int, tip_height: int, bg_color=str):
+        self.width = width
+        self.hex_height = hex_height
+        self.tip_height = tip_height
+        self.colors = self.parse_string_to_tuples(colors)
+        self.bg_color = bg_color
+
+    @staticmethod
+    def parse_string_to_tuples(s: str) -> List[Tuple]:
+        # Remove spaces to avoid issues with ast.literal_eval
+        s_cleaned = ''.join(s.split())
+        # Wrap the string in brackets to make it a list literal
+        s_list_literal = f'[{s_cleaned}]'
+        try:
+            # Safely evaluate the string as a Python literal
+            result = ast.literal_eval(s_list_literal)
+        except ValueError:
+            # Handle the case where the string could not be parsed
+            result = []
+        return result
+
+
+    @staticmethod
+    def calculate_hexagon_points(center: Tuple, width: int, hex_height: int, tip_height: int) -> List[Tuple]:
+        """Calculate the points of a hexagon based on the width, total height, and tip height."""
+        # These points define the hexagon starting from the top-middle point, clockwise.
+        return [
+            (center[0], center[1] - hex_height / 2 - tip_height),  # Top
+            (center[0] + width/2, center[1] - hex_height / 2),  # Top right
+            (center[0] + width/2, center[1] + hex_height / 2),  # Bottom right
+            (center[0], center[1] + hex_height / 2 + tip_height),  # Bottom
+            (center[0] - width/2, center[1] + hex_height / 2),  # Bottom left
+            (center[0] - width/2, center[1] - hex_height / 2),  # Top left
+        ]
+
+    def create_color_hexagon_grid(self) -> Image.Image:
+        """
+        Create an image of a row of colored hexagons with specified width, height, and tip height.
+
+        :param colors: List of RGB color tuples for the hexagons.
+        :param width: The full width of each hexagon.
+        :param hex_height: The full height of each hexagon.
+        :param tip_height: The height of the top and bottom triangles (tips) of each hexagon.
+        :return: A PIL image with the hexagon grid.
+        """
+        # Calculate the necessary image width and height
+        image_width = self.width * len(self.colors)
+        image_height = self.hex_height + 2 * self.tip_height
+
+        # Create a new image
+        image = Image.new('RGB', (image_width, image_height), self.bg_color)
+        draw = ImageDraw.Draw(image)
+        
+        # Draw each hexagon
+        for i, color in enumerate(self.colors):
+            # Calculate the center of the hexagon
+            center_x = self.width * i + self.width / 2
+            center = (center_x, self.hex_height / 2 + self.tip_height)
+            # Get the points for the hexagon
+            hexagon_points = self.calculate_hexagon_points(center, self.width, self.hex_height, self.tip_height)
+            draw.polygon(hexagon_points, fill=color)
+        return image

utils/utils_haxagon_pixel.py

@@ -0,0 +1,313 @@
+import ast
+from skimage import color
+from langchain_community.vectorstores import FAISS
+from langchain.embeddings.base import Embeddings
+from typing import List, Tuple, Dict, Union
+from PIL import Image
+import numpy as np
+from tqdm import tqdm
+from langchain_community.vectorstores.utils import DistanceStrategy
+from torch import Tensor 
+import torchvision.transforms as transforms
+from collections import Counter
+import os
+os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
+from typing import (
+    Dict,
+    Iterable,
+    List,
+    Tuple,
+)
+
+
+class FaissVectorStore:
+    """In memory faiss vector store."""
+
+    def __init__(
+        self,
+        documents: List[Tuple[str, List[float]]],
+        metadatas: List[Dict],
+        embedding: Embeddings,
+        distance_strategy: DistanceStrategy,
+        **kwargs
+    ):
+        """
+        Initialize the in-memory FAISS data retriever.
+        Documents can also be text (and corresponding embedding). In
+        this case, we will use the provided vectors, but metadata needs
+        to be provided as a list of dictionaries.
+        """
+
+        self.db = self.__create_vectorstore_from_embeddings(
+            text_embeddings=documents,
+            embedding=embedding,
+            metadatas=metadatas,
+            distance_strategy=distance_strategy
+        )
+
+    def __create_vectorstore_from_embeddings(
+        self,
+        text_embeddings: Iterable[Tuple[str, List[float]]],
+        embedding: Embeddings,
+        metadatas: Iterable[dict],
+        distance_strategy: DistanceStrategy
+    ) -> FAISS:
+        """Create vector store with text and embeddings."""
+        db = FAISS.from_embeddings(text_embeddings=text_embeddings,
+                                   embedding=embedding,
+                                   metadatas=metadatas,
+                                   distance_strategy=distance_strategy)
+        return db
+
+class MockEmbedding(Embeddings):
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Embed search docs."""
+
+    def embed_query(self, text: str) -> List[float]:
+        """Embed query text."""
+
+
+class Tile:
+    """Data Definition of a tile"""
+    def __init__(
+            self,
+            x_center: Union[int, float],
+            y_center: Union[int, float],
+            width: Union[int, float],
+            height_total: Union[int, float],
+            height_tip: Union[int, float]
+    ):
+        self.width = width 
+        self.half_width = width / 2
+        self.height_tip = height_tip 
+        self.height_middle = (height_total - height_tip * 2)
+        self.x_center = x_center
+        self.y_center = y_center
+
+        self.x_left = x_center - self.half_width 
+        self.x_right = x_center + self.half_width 
+        self.y_top = y_center + height_total/2 
+        self.y_bottom = y_center - height_total/2
+        self.y_box_top = self.y_top - self.height_tip
+        self.y_box_bottom = self.y_bottom + self.height_tip
+
+
+    def contains_coord(self, x, y):
+        """
+            Given the coordinate of a 2-dimentional point (x, y),
+            determine if the point lies in the tile.
+            This approach checks conditions on the cartesian coordinates; can also use geometry approach by checking the angles
+        """
+        diagonal_slope =  self.height_tip / self.half_width
+
+        return (
+            self.x_left <= x <= self.x_right
+        ) and (
+            self.y_bottom <= y <= self.y_top
+        ) and not (
+            (
+                y > self.y_box_top and (
+                    (x < self.x_center and y > self.y_box_top + diagonal_slope * (x - self.x_left)) or 
+                    (x > self.x_center and y > self.y_box_top - diagonal_slope * (x - self.x_right))
+                )
+            ) or (
+                y < self.y_box_bottom and (
+                    (x < self.x_center and y < self.y_box_bottom - diagonal_slope * (x - self.x_left)) or 
+                    (x > self.x_center and y < self.y_box_bottom + diagonal_slope * (x - self.x_right))
+                )
+            )
+        )  
+
+
+    def coords_contained(self):
+        """
+            Produce a list of all (x, y) coordinates where x and y are integers, and (x, y) is contained within the tile
+        """
+        coords = []
+        for x in range(int(self.x_left), int(self.x_right)+1):
+            for y in range(int(self.y_bottom), int(self.y_top)+1):
+                if self.contains_coord(x, y):
+                    coords.append((x, y))
+        return coords
+    
+
+class Painting:
+    def __init__(
+        self,
+        width: int,
+        height: int,
+        tile_width: int,
+        tile_height: int,
+        tile_height_tip: int,
+        gap_horizontal: int,
+        gap_vertical: int,
+        gap_color: str,
+    ):
+        self.width = width 
+        self.height = height 
+        self.tile_width = tile_width
+        self.tile_height = tile_height
+        self.tile_height_tip = tile_height_tip
+        self.gap_horizontal = gap_horizontal
+        self.gap_vertical = gap_vertical
+        self.gap_color = gap_color
+
+        self.tile_height_middle = tile_height - tile_height_tip * 2
+
+        x_centers, idx_alternating = [0, tile_width/2 + gap_horizontal / 2], 1
+        y_center = tile_height/2  # the y-center of the top row of tiles
+
+        self.tiles = []
+        self.tile_pixels = []
+        
+        while y_center-tile_height/2 < self.height:
+            idx_alternating = (idx_alternating + 1) % 2
+            x_center = x_centers[idx_alternating]
+            
+            while x_center-tile_width/2 < self.width:
+                tile = Tile(x_center, y_center, tile_width, tile_height, tile_height_tip)
+                self.tiles.append(tile)
+                self.tile_pixels.append(tile.coords_contained())
+                x_center += (self.tile_width + self.gap_horizontal)
+            
+            y_center += (self.tile_height_middle + self.tile_height_tip + self.gap_vertical)
+
+
+class Translation:
+    def __init__(
+            self,
+            painting: Painting,
+            colors: str,
+            lab_space: str,
+            distance_strategy: str
+    ) -> None:
+        """Initialize translation."""
+        self.painting = painting
+        self.colors = self.parse_string_to_tuples(colors)
+        self.lab_space = lab_space
+        all_rgb_doc = []
+        metadatas = []
+        for (r, g, b) in self.colors:
+            all_rgb_doc.append(('', list(self.rgb2lab((r, g, b)))))
+            metadatas.append({'r': r, "g": g, "b": b})
+
+        if distance_strategy.startswith('c'):
+            distance_strategy=DistanceStrategy.COSINE
+        else:
+            distance_strategy=DistanceStrategy.EUCLIDEAN_DISTANCE
+        self.faiss_db = FaissVectorStore(all_rgb_doc, 
+                                         metadatas, 
+                                         MockEmbedding(), 
+                                         distance_strategy=distance_strategy)
+
+    def rgb2lab(self, rgb: Tuple) -> Tuple:
+        """Convert rgb to lab color."""
+        if self.lab_space == 'true':
+            r, g, b = rgb
+            lab = color.rgb2lab((r/255, g/255, b/255))
+            return tuple(lab)
+        else:
+            return rgb
+
+    @staticmethod
+    def parse_string_to_tuples(s: str) -> List[Tuple]:
+        # Remove spaces to avoid issues with ast.literal_eval
+        s_cleaned = ''.join(s.split())
+        # Wrap the string in brackets to make it a list literal
+        s_list_literal = f'[{s_cleaned}]'
+        try:
+            # Safely evaluate the string as a Python literal
+            result = ast.literal_eval(s_list_literal)
+        except ValueError:
+            # Handle the case where the string could not be parsed
+            result = []
+        return result
+
+    def transform_pil_to_tensor(self, pil_image: Image) -> Tensor:
+        """Conver pil image into tensor."""
+        # transform PIL into tensor
+        transform = transforms.Compose([
+            transforms.ToTensor(),  # Convert the image to a tensor
+        ])
+        image_tensor = transform(pil_image)
+        image_tensor = image_tensor.unsqueeze(0)
+        image_tensor = image_tensor.permute(0, 2, 3, 1)
+        return image_tensor
+    
+    def translate_image_tensor(self, image_tensor: Tensor) -> Tensor:
+        image_tensor = image_tensor.squeeze(0).permute(2, 0, 1)
+        # Convert the tensor to a PIL Image
+        to_pil_image = transforms.ToPILImage()
+        original_image = to_pil_image(image_tensor)
+
+        new_size = (self.painting.width, self.painting.height)
+        upscaled_image = original_image.resize(new_size)
+        pixels = upscaled_image.load()
+
+        if self.painting.gap_color == "white":
+            new_img_bg = (255, 255, 255)
+        elif self.painting.gap_color == "black":
+            new_img_bg = (0, 0, 0)
+
+        processed_img_final = Image.new('RGB', new_size, new_img_bg)
+        
+        for corresponding_coords in tqdm(self.painting.tile_pixels):
+            coords_pixels = np.array([pixels[x, y] for x, y in corresponding_coords if 0 <= x < self.painting.width and 0 <= y < self.painting.height])
+            if len(coords_pixels.shape) == 1:
+                    continue
+            r, g, b = int(np.mean(coords_pixels[:, 0])), int(np.mean(coords_pixels[:, 1])), int(np.mean(coords_pixels[:, 2]))            
+            rgb_metadata = self.faiss_db.db.similarity_search_by_vector(list(self.rgb2lab((r, g, b))))[0].metadata
+            given_r = rgb_metadata['r']
+            given_g = rgb_metadata['g']
+            given_b = rgb_metadata['b']   
+
+            for x, y in corresponding_coords:
+                if 0 <= x < self.painting.width and 0 <= y < self.painting.height:
+                    processed_img_final.putpixel((x, y), (given_r, given_g, given_b))
+        
+        return self.transform_pil_to_tensor(processed_img_final)
+
+
+
+class ColorSelection:
+    def __init__(
+            self,
+            pil_image: Image.Image,
+            selection_type: str,
+            painting: Painting,
+    ) -> None:
+        """Initialize translation."""
+        self.selection_type = selection_type
+        self.pil_image = pil_image
+        self.painting = painting
+
+    @staticmethod
+    def rgb_vote(rgbs: List[Tuple]) -> Tuple:
+        """Select the most common rgb of a tile."""
+        counter = Counter(rgbs)
+        most_common_tuple, count = counter.most_common(1)[0]
+        return most_common_tuple
+
+    def translate_image_tensor(self) -> Image.Image:
+        new_size = (self.painting.width, self.painting.height)
+        upscaled_image = self.pil_image.resize(new_size)
+        pixels = upscaled_image.load()
+
+        if self.painting.gap_color == "white":
+            new_img_bg = (255, 255, 255)
+        elif self.painting.gap_color == "black":
+            new_img_bg = (0, 0, 0)
+        processed_img_final = Image.new('RGB', new_size, new_img_bg)
+        for corresponding_coords in self.painting.tile_pixels:
+            coords_pixels = [pixels[x, y] for x, y in corresponding_coords if 0 <= x < self.painting.width and 0 <= y < self.painting.height]
+            if not coords_pixels:
+                continue
+            if self.selection_type.startswith("average"):
+                coords_pixels = np.array(coords_pixels) 
+                r, g, b = int(np.mean(coords_pixels[:, 0])), int(np.mean(coords_pixels[:, 1])), int(np.mean(coords_pixels[:, 2]))            
+            elif self.selection_type.startswith("marjority"):
+                r, g, b = self.rgb_vote(coords_pixels)
+            for x, y in corresponding_coords:
+                if 0 <= x < self.painting.width and 0 <= y < self.painting.height:
+                    processed_img_final.putpixel((x, y), (r, g, b))
+        return processed_img_final

utils/utils_image_boarder.py

@@ -0,0 +1,41 @@
+from PIL import Image, ImageDraw
+from typing import Tuple, Dict
+
+class ImageBoarder:
+    def __init__(self, image: Image.Image, line_distances:Dict, line_width: int, line_color: str, margin_widths: Dict) -> None:
+        self.image = image
+        self.line_distances = line_distances
+        self.line_width = line_width
+        self.line_color = line_color
+        self.margin_widths = margin_widths
+
+
+    def add_custom_lines(self) -> Image.Image:
+        """
+        image, line_distances, line_width=5, line_color="red", margin_widths: int
+        """
+        # Calculate new image dimensions considering line distances
+        left_extend = max(self.line_distances['left'], 0)
+        right_extend = max(self.line_distances['right'], 0)
+        top_extend = max(self.line_distances['top'], 0)
+        bottom_extend = max(self.line_distances['bottom'], 0)
+
+        new_width = self.image.width + left_extend + right_extend
+        new_height = self.image.height + top_extend + bottom_extend
+
+        # Create a new image with additional space for lines
+        new_image = Image.new("RGB", (new_width, new_height), "white")
+        new_image.paste(self.image, (left_extend, top_extend))
+
+        draw = ImageDraw.Draw(new_image)
+
+        # Draw lines
+        draw.line([(left_extend - self.line_distances['left'], top_extend), (left_extend - self.line_distances['left'], new_height - bottom_extend)], fill=self.line_color, width=self.line_width)
+        draw.line([(new_width - right_extend + self.line_distances['right'], top_extend), (new_width - right_extend + self.line_distances['right'], new_height - bottom_extend)], fill=self.line_color, width=self.line_width)
+        draw.line([(left_extend, top_extend - self.line_distances['top']), (new_width - right_extend, top_extend - self.line_distances['top'])], fill=self.line_color, width=self.line_width)
+        draw.line([(left_extend, new_height - bottom_extend + self.line_distances['bottom']), (new_width - right_extend, new_height - bottom_extend + self.line_distances['bottom'])], fill=self.line_color, width=self.line_width)
+
+        # Add margins
+        final_image = Image.new("RGB", (new_image.width + self.margin_widths['left'] + self.margin_widths['right'], new_image.height + self.margin_widths['top'] + self.margin_widths['bottom']), "white")
+        final_image.paste(new_image, (self.margin_widths['left'], self.margin_widths['top']))
+        return final_image

utils/utils_image_color_distribution.py

@@ -0,0 +1,76 @@
+import math
+from PIL import Image, ImageDraw
+import numpy as np
+import matplotlib.pyplot as plt
+from collections import Counter
+import io
+
+class ColorPalette:
+    def __init__(
+            self,
+            pil_image: Image.Image,
+            color_block_size: int,
+    ) -> None:
+        """Initialize translation."""
+        self.pil_image = pil_image
+        self.pixels = self.pil_image.load()
+        self.color_block_size = color_block_size
+        self.image_rgbs = []
+        self.rgbs = []
+
+        self.width = self.pil_image.size[0]
+        self.height = self.pil_image.size[1]
+        for px in range(self.width):
+            for py in range(self.height):
+                self.rgbs.append(self.pixels[px, py])
+
+        color_counts = Counter(self.rgbs)
+        sorted_colors = sorted(color_counts.items(), key=lambda x: x[1], reverse=True)
+        self.rgb_list, self.counts = zip(*sorted_colors)
+        self.rgbs_string =  f"{self.rgb_list}".strip()[1: -1]
+        self.total_colors = len(set(self.rgbs))
+
+    def create_color_blocks(self) -> Image.Image:
+        """
+        Create an image consisting of square color blocks for each RGB value in the list,
+        arranged in an n by m grid.
+        - An Image object containing all the color blocks arranged in an n by m grid.
+        """
+        # Calculate the number of rows and columns to make the grid as square as possible
+        num_colors = len(self.rgb_list)
+        grid_cols = int(math.ceil(math.sqrt(num_colors)))
+        grid_rows = int(math.ceil(num_colors / grid_cols))
+        # Calculate the overall image size based on the grid
+        img_width = self.color_block_size * grid_cols
+        img_height = self.color_block_size * grid_rows
+        # Create a new blank image
+        img = Image.new('RGB', (img_width, img_height), 'white')
+        # Create a draw object to draw on the image
+        draw = ImageDraw.Draw(img)
+        # Loop through each RGB value and draw a color block in the grid
+        for i, color in enumerate(self.rgb_list):
+            row = i // grid_cols
+            col = i % grid_cols
+            # Calculate the top left corner of the current block
+            top_left = (col * self.color_block_size, row * self.color_block_size)
+            # Calculate the bottom right corner of the current block
+            bottom_right = ((col + 1) * self.color_block_size, (row + 1) * self.color_block_size)
+            # Draw the rectangle with the current color
+            draw.rectangle([top_left, bottom_right], fill=color)
+            # [1, -1] is to remove the [ and ] of the list
+        return img
+    
+    def create_color_dist(self) -> Image.Image:
+        """Create a distribution plot of colors."""
+        plt.figure(figsize=(15, 8))
+        bars = plt.bar(range(len(self.counts)), self.counts, color=np.array(self.rgb_list)/255.0, edgecolor='black')
+        plt.xlabel('Colors')
+        plt.ylabel('Counts')
+        plt.title('Color Distribution')
+        color_labels = [f'{color}' for color in self.rgb_list]
+        plt.xticks(range(len(self.counts)), color_labels, rotation=90, ha='right')
+        buf = io.BytesIO()
+        plt.savefig(buf, format='png')
+        buf.seek(0)
+        pil_image = Image.open(buf)
+        return pil_image

utils/utils_image_modification.py

@@ -0,0 +1,51 @@
+from PIL import Image
+from torch import Tensor 
+from torchvision import transforms
+
+
+class ImageManipulation:
+    def __init__(self, pil_image: Image.Image) -> None:
+        self.pil_image = pil_image
+
+    @staticmethod
+    def transform_pil_to_tensor(pil_image: Image) -> Tensor:
+        """Conver pil image into tensor."""
+        # transform PIL into tensor
+        transform = transforms.Compose([
+            transforms.ToTensor(),  # Convert the image to a tensor
+        ])
+        image_tensor = transform(pil_image)
+        image_tensor = image_tensor.unsqueeze(0)
+        image_tensor = image_tensor.permute(0, 2, 3, 1)
+        return image_tensor
+    
+    @staticmethod
+    def transform_tensor_to_pil(image_tensor: Tensor) -> Image:
+        """Convert tensor image into PIL."""
+        # Ensure the tensor is in the correct shape (C, H, W)
+        if image_tensor.dim() == 4:
+            # Assuming the tensor shape is [B, H, W, C], 
+            # permute it to [B, C, H, W] then remove the batch dimension
+            image_tensor = image_tensor.permute(0, 3, 1, 2).squeeze(0)
+        elif image_tensor.dim() == 3:
+            # If the tensor is [H, W, C], permute it to [C, H, W]
+            image_tensor = image_tensor.permute(2, 0, 1)
+
+        to_pil_image = transforms.ToPILImage()
+        pil_image = to_pil_image(image_tensor)
+        return pil_image
+
+    def flip(self, flip_side: str) -> Image:
+        if flip_side == "horizontal":
+            image_flipped_horizontal = self.pil_image.transpose(Image.FLIP_LEFT_RIGHT)
+            return image_flipped_horizontal
+        
+        if flip_side == "vertical":
+            image_flipped_vertical = self.pil_image.transpose(Image.FLIP_TOP_BOTTOM)
+            return image_flipped_vertical
+
+    def rotation(self, degree: int) -> Image:
+        image_rotated = self.pil_image.rotate(degree, expand=True)
+        return image_rotated
+
+

utils/utils_image_text.py

@@ -0,0 +1,27 @@
+from PIL import Image, ImageDraw, ImageFont
+from typing import Tuple
+import os
+
+class ImageText:
+    def __init__(self, width: int, height: int, background_color: str, text: str, font_name: str, font_size: int, text_color: str, text_position: Tuple, abs_path: str) -> None:
+        self.width = width
+        self.height = height
+        self.background_color = background_color
+        self.text = text
+        self.abs_path = abs_path
+        self.font_name = font_name
+        self.font_size = font_size
+        self.text_color = text_color
+        self.text_position = text_position
+
+    def create_text_image(self) -> Image.Image:
+        image = Image.new('RGB', (self.width, self.height), color=self.background_color)
+        draw = ImageDraw.Draw(image)
+        try:
+            font = ImageFont.truetype(os.path.join(self.abs_path, self.font_name), self.font_size)
+        except IOError:
+            print(f"Font '{self.font_name}' not found. Using default font.")
+            font = ImageFont.load_default()
+        
+        draw.text(self.text_position, self.text, fill=self.text_color, font=font)
+        return image

utils/utils_vector_store.py

@@ -0,0 +1,61 @@
+from typing import List, Tuple, Dict
+from langchain_community.vectorstores.utils import DistanceStrategy
+import os
+
+from typing import (
+    Dict,
+    Iterable,
+    List,
+    Tuple,
+)
+
+from langchain_community.vectorstores import FAISS
+from langchain.embeddings.base import Embeddings
+os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
+
+
+class FaissVectorStore:
+    """In memory faiss vector store."""
+
+    def __init__(
+        self,
+        documents: List[Tuple[str, List[float]]],
+        metadatas: List[Dict],
+        embedding: Embeddings,
+        distance_strategy: DistanceStrategy,
+        **kwargs
+    ):
+        """
+        Initialize the in-memory FAISS data retriever.
+        Documents can also be text (and corresponding embedding). In
+        this case, we will use the provided vectors, but metadata needs
+        to be provided as a list of dictionaries.
+        """
+
+        self.db = self.__create_vectorstore_from_embeddings(
+            text_embeddings=documents,
+            embedding=embedding,
+            metadatas=metadatas,
+            distance_strategy=distance_strategy
+        )
+
+    def __create_vectorstore_from_embeddings(
+        self,
+        text_embeddings: Iterable[Tuple[str, List[float]]],
+        embedding: Embeddings,
+        metadatas: Iterable[dict],
+        distance_strategy: DistanceStrategy
+    ) -> FAISS:
+        """Create vector store with text and embeddings."""
+        db = FAISS.from_embeddings(text_embeddings=text_embeddings,
+                                   embedding=embedding,
+                                   metadatas=metadatas,
+                                   distance_strategy=distance_strategy)
+        return db
+
+class MockEmbedding(Embeddings):
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Embed search docs."""
+
+    def embed_query(self, text: str) -> List[float]:
+        """Embed query text."""