init commit.

.gitignore

@@ -0,0 +1,156 @@
+.vs
+.vscode
+# 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/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# 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
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .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
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.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
+.venv
+env/
+venv/
+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/
+
+# PyCharm
+#  JetBrains specific template is maintainted in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+tmp/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Eren
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,8 +1,8 @@
 ---
 title: AdenzuMangaPanelExtractor
-emoji: 📉
-colorFrom: red
-colorTo: pink
+emoji: 🕮
+colorFrom: green
+colorTo: indigo
 sdk: gradio
 sdk_version: 5.35.0
 app_file: app.py
@@ -11,3 +11,99 @@ short_description: Adenzu Manga/Comics Panel Extractor (WebUI)
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+___
+
+# Adenzu Manga/Comics Panel Extractor (WebUI)  
+
+Upload your manga or comic book images. This tool will automatically analyze the panels on each page,
+crop them into individual image files, and package them into a single ZIP file for you to download.
+ 
+The core panel detection is created by **adenzu** ([Original Project](https://github.com/adenzu/Manga-Panel-Extractor)).
+
+___
+
+# Manga Panel Extractor
+
+A simple program that takes manga pages and outputs panels on them. The current way of working of this program was inspired from this [paper](related-paper.pdf). Thanks to Xufang Pang, Ying Cao, Rynson W.H. Lau, and Antoni B. Chan for their work.
+
+Please read [report](reports/internal/report.pdf) for detailed explanation of the implemented algorithm(s).
+
+- Please note that this program is designed specifically for manga and may not work correctly with manhwas or other similar formats.
+
+## Installation
+
+Visit the [Releases](https://github.com/adenzu/Manga-Panel-Extractor/releases) section of the repository and download the executable for Windows. Currently, only the Windows7+ versions are supported. However, you can build for other platforms using the provided source code.
+
+## Usage
+
+### Website
+1. Go to the website https://adenzu.github.io/Manga-Panel-Extractor/
+2. Select image files of manga pages you want to extract panels of
+3. Click `Start`
+4. Click `Cancel` to cancel panel extraction process whenever you want to
+5. Click `Download` to download a zip file containing all the panels
+
+- **Note:** Too many images may cause computer lag.
+
+### Executable
+
+0. You can check examples in advance to see if this program can help you with your images, see examples [here](tests/data/test_performance/README.md#what-it-does).
+1. [Download the latest executable](https://github.com/adenzu/Manga-Panel-Extractor/releases/latest) for your operating system.
+2. Execute the downloaded executable.
+3. Select the input directory containing the manga page images. Each image should represent one manga page.
+4. Choose the output directory where the extracted panels will be saved.
+5. You can check the checkbox named "Split Joint Panels" to split joint panels. **This slows down the process up to ten fold.**
+6. You can check the checkbox named "Fallback" for fallback method to be applied in case of a failed extraction.
+7. You can check the checkbox named "Output to Separate Folders" to extract each image's panels into their respective folder.
+8. Click "Start" to initiate the panel extraction process. You can monitor the progress in the bottom left corner of the program window.
+9. To cancel the process, click "Cancel".
+
+- Please note that this program is designed specifically for manga and may not work correctly with manhwas or other similar formats.
+
+### CLI - Input and Output Directories
+
+```bash
+python main.py [input_dir] [output_dir] [-s] [-f] [-g]
+```
+
+or
+
+```bash
+python main.py [input_img_path] [-s] [-f] [-g]
+```
+
+- `[input_img_path]`: Input image path.
+- `[input_dir]`: Input directory.
+- `[output_dir]` (optional): Output directory.
+- `-s` or `--split-joint-panels` (optional): Split joint panels.
+- `-f` or `--fallback` (optional): Fallback to a more aggressive method if the first one fails.
+- `-g` or `--gui` (optional): Use GUI.
+
+## Program Explanation and Examples
+
+See explanation and examples [here](tests/data/test_performance/README.md).
+
+## Features
+
+The key feature of Manga Panel Extractor is its ability to analyze manga pages and extract panels from them.
+
+## Configuration
+
+Manga Panel Extractor does not require any additional configuration. It is ready to use out of the box.
+
+## Contributing
+
+Currently, there is limited community involvement in this project. Feel free to contribute by submitting bug reports or feature requests through the [Issues](https://github.com/adenzu/Manga-Panel-Extractor/issues) section.
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+## Troubleshooting
+
+- If the extraction process is unsuccessful, the output image may resemble the input manga page image itself.
+
+## Contact
+
+If you have any questions, issues, or suggestions, please open an issue in the [Issues](https://github.com/adenzu/Manga-Panel-Extractor/issues) section.

ai-models/2024-11-00/best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5e5004af64c6c18d98cec26804cb7ca4f7ee1b1fe44f7aa385a4cc025e31f34
+size 14367976

app.py

@@ -0,0 +1,233 @@
+"""
+adenzu Eren Manga/Comics Panel Extractor (WebUI)
+Copyright (C) 2025 avan
+
+This program is a web interface for the adenzu library.
+The core logic is based on adenzu Eren, the Manga Panel Extractor.
+Copyright (c) 2023 Eren
+"""
+import gradio as gr
+import os
+import cv2
+import numpy as np
+import tempfile
+import shutil
+from tqdm import tqdm
+
+from image_processing.panel import generate_panel_blocks, generate_panel_blocks_by_ai
+
+# --- UI Description ---
+DESCRIPTION = """
+# adenzu Eren Manga/Comics Panel Extractor (WebUI)
+Upload your manga or comic book images. This tool will automatically analyze and extract each panel.
+You can choose between a Traditional algorithm or a AI-based model for processing.
+Finally, all extracted panels are packaged into a single ZIP file for you to download.
+
+The Core package author: **adenzu Eren** ([Original Project](https://github.com/adenzu/Manga-Panel-Extractor)).
+"""
+
+def process_images(
+    input_files,
+    method,
+    separate_folders,
+    # Traditional method params
+    merge_mode,
+    split_joint,
+    fallback,
+    output_mode,
+    # AI method params (currently only merge_mode is used)
+    # This structure allows for future AI-specific params
+    progress=gr.Progress(track_tqdm=True)
+):
+    """
+    Main processing function called by Gradio.
+    It takes uploaded files and settings, processes them, and returns a zip file.
+    """
+    if not input_files:
+        raise gr.Error("No images uploaded. Please upload at least one image.")
+
+    # Create a temporary directory to store the processed panels
+    with tempfile.TemporaryDirectory() as temp_panel_dir:
+        print(f"Created temporary directory for panels: {temp_panel_dir}")
+
+        for image_file in tqdm(input_files, desc="Processing Images"):
+            try:
+                # The image_file object from gr.Files has a .name attribute with the temp path
+                original_filename = os.path.basename(image_file.name)
+                filename_no_ext, file_ext = os.path.splitext(original_filename)
+
+                # Read the image using OpenCV
+                image = cv2.imread(image_file.name)
+                if image is None:
+                    print(f"Warning: Could not read image {original_filename}. Skipping.")
+                    continue
+
+                # Select the processing function based on the chosen method
+                if method == "Traditional":
+                    panel_blocks = generate_panel_blocks(
+                        image=image,
+                        split_joint_panels=split_joint,
+                        fallback=fallback,
+                        mode=output_mode,
+                        merge=merge_mode
+                    )
+                elif method == "AI":
+                    panel_blocks = generate_panel_blocks_by_ai(
+                        image=image,
+                        merge=merge_mode
+                    )
+                else:
+                    # Should not happen with Radio button selection
+                    panel_blocks = []
+
+                if not panel_blocks:
+                    print(f"Warning: No panels found in {original_filename}.")
+                    continue
+
+                # Determine the output path for the panels of this image
+                if separate_folders:
+                    # Create a sub-directory for each image
+                    image_output_folder = os.path.join(temp_panel_dir, filename_no_ext)
+                    os.makedirs(image_output_folder, exist_ok=True)
+                else:
+                    # Output all panels to the root of the temp directory
+                    image_output_folder = temp_panel_dir
+
+                # Save each panel block
+                for i, panel in enumerate(panel_blocks):
+                    if separate_folders:
+                        # e.g., /tmp/xyz/image1/panel_0.png
+                        panel_filename = f"panel_{i}{file_ext if file_ext else '.png'}"
+                    else:
+                        # e.g., /tmp/xyz/image1_panel_0.png
+                        panel_filename = f"{filename_no_ext}_panel_{i}{file_ext if file_ext else '.png'}"
+
+                    output_path = os.path.join(image_output_folder, panel_filename)
+                    cv2.imwrite(output_path, panel)
+
+            except Exception as e:
+                print(f"Error processing {original_filename}: {e}")
+                raise gr.Error(f"Failed to process {original_filename}: {e}")
+
+        # After processing all images, check if any panels were generated
+        if not os.listdir(temp_panel_dir):
+            raise gr.Error("Processing complete, but no panels were extracted from any of the images.")
+            
+        # --- Create a zip file ---
+        
+        # Create a separate temporary directory to hold the final zip file.
+        # Gradio will handle cleaning this up after serving the file to the user.
+        zip_output_dir = tempfile.mkdtemp()
+        
+        # Define the base name for our archive (path + filename without extension)
+        zip_path_base = os.path.join(zip_output_dir, "adenzu_output")
+        
+        # Create the zip file. shutil.make_archive will add the '.zip' extension.
+        # The first argument is the full path for the output file (minus extension).
+        # The third argument is the directory to be zipped.
+        final_zip_path = shutil.make_archive(
+            base_name=zip_path_base,
+            format='zip',
+            root_dir=temp_panel_dir
+        )
+        
+        print(f"Created ZIP file at: {final_zip_path}")
+        # The function returns the full path to the created zip file.
+        # Gradio takes this path and provides it as a download link.
+        return final_zip_path
+
+
+def main():
+    """
+    Defines and launches the Gradio interface.
+    """
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        gr.Markdown(DESCRIPTION)
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                # --- Input Components ---
+                input_files = gr.Files(
+                    label="Upload Manga Pages",
+                    file_types=["image"],
+                    file_count="multiple"
+                )
+
+                method = gr.Radio(
+                    label="Processing Method",
+                    choices=["Traditional", "AI"],
+                    value="Traditional",
+                    interactive=True
+                )
+
+                # --- Output Options ---
+                gr.Markdown("### Output Options")
+                separate_folders = gr.Checkbox(
+                    label="Create a separate folder for each image inside the ZIP",
+                    value=True,
+                    info="If unchecked, all panels will be in the root of the ZIP, with filenames prefixed by the original image name."
+                )
+
+                # --- Shared Parameters ---
+                gr.Markdown("### Shared Parameters")
+                merge_mode = gr.Dropdown(
+                    label="Merge Mode",
+                    choices=['none', 'vertical', 'horizontal'],
+                    value='none',
+                    info="How to merge detected panels before saving."
+                )
+
+                # --- Method-specific Parameters ---
+                with gr.Group(visible=True) as traditional_params:
+                    gr.Markdown("### Traditional Method Parameters")
+                    split_joint = gr.Checkbox(label="Split Joint Panels", value=False)
+                    fallback = gr.Checkbox(label="Fallback to Threshold Extraction", value=True)
+                    output_mode = gr.Dropdown(
+                        label="Output Mode",
+                        choices=['bounding', 'masked'],
+                        value='bounding'
+                    )
+
+                with gr.Group(visible=False) as ai_params:
+                    gr.Markdown("### AI Method Parameters")
+                    gr.Markdown("_(Currently, only the shared 'Merge Mode' parameter is used by the AI method.)_")
+
+                # --- UI Logic to show/hide parameter groups ---
+                def toggle_parameter_visibility(selected_method):
+                    if selected_method == "Traditional":
+                        return gr.update(visible=True), gr.update(visible=False)
+                    elif selected_method == "AI":
+                        return gr.update(visible=False), gr.update(visible=True)
+                
+                method.change(
+                    fn=toggle_parameter_visibility,
+                    inputs=method,
+                    outputs=[traditional_params, ai_params]
+                )
+
+                # --- Action Button ---
+                generate_button = gr.Button("Generate Panels", variant="primary")
+
+            with gr.Column(scale=1):
+                # --- Output Component ---
+                output_zip = gr.File(label="Download ZIP")
+
+        # --- Button Click Action ---
+        generate_button.click(
+            fn=process_images,
+            inputs=[
+                input_files,
+                method,
+                separate_folders,
+                merge_mode,
+                split_joint,
+                fallback,
+                output_mode
+            ],
+            outputs=output_zip
+        )
+
+    demo.launch(inbrowser=True)
+
+if __name__ == "__main__":
+    main()

image_processing/image.py

@@ -0,0 +1,155 @@
+import cv2
+import numpy as np
+
+
+def apply_adaptive_threshold(image: np.ndarray) -> np.ndarray:
+    """
+    Applies adaptive threshold to the given image
+    """
+    return cv2.adaptiveThreshold(image, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 5, 0)
+
+
+def is_contour_rectangular(contour: np.ndarray) -> bool:
+    """
+    Returns whether the given contour is rectangular or not
+    """
+    num_sides = 4
+    perimeter = cv2.arcLength(contour, True)
+    approx = cv2.approxPolyDP(contour, 0.01 * perimeter, True)
+    return len(approx) == num_sides
+
+
+def adaptive_vconcat(images: list[np.ndarray], fill_color: tuple[int, int, int] = (255, 255, 255)) -> np.ndarray:
+    max_width = max(img.shape[1] for img in images)
+
+    # Resize each image to match the largest dimensions
+    resized_images = []
+    for img in images:
+        resized_img = cv2.copyMakeBorder(img, 
+                                         top=0, bottom=0, 
+                                         left=0, right=max_width - img.shape[1], 
+                                         borderType=cv2.BORDER_CONSTANT, 
+                                         value=fill_color)  
+        resized_images.append(resized_img)
+
+    # Concatenate vertically
+    return np.vstack(resized_images)
+
+
+def adaptive_hconcat(images: list[np.ndarray], fill_color: tuple[int, int, int] = (255, 255, 255)) -> np.ndarray:
+    max_height = max(img.shape[0] for img in images)
+
+    # Resize each image to match the largest dimensions
+    resized_images = []
+    for img in images:
+        resized_img = cv2.copyMakeBorder(img, 
+                                         top=0, bottom=max_height - img.shape[0], 
+                                         left=0, right=0, 
+                                         borderType=cv2.BORDER_CONSTANT, 
+                                         value=fill_color)  
+        resized_images.append(resized_img)
+
+    # Concatenate horizontally
+    return np.hstack(resized_images)
+
+
+def group_contours_vertically(contours) -> list[list[np.ndarray]]:
+    """
+    Groups the given contours vertically
+    """
+    ERROR_THRESHOLD = 0.05
+    contours = sorted(contours, key=lambda c: cv2.boundingRect(c)[1])
+    grouped_contours = [[contours[0]]]
+    for contour in contours[1:]:
+        found_group = False
+        contour_x, contour_y, contour_w, contour_h = cv2.boundingRect(contour)
+        for group in grouped_contours[::-1]:
+            group_x, group_y, group_w, group_h = cv2.boundingRect(group[-1])
+            y_diff = abs(contour_y - group_y) - group_h
+            if y_diff < 0 or y_diff > min(contour_h, group_h):
+                continue 
+            group_x_center = group_x + group_w / 2
+            contour_x_center = contour_x + contour_w / 2
+            if abs(group_x_center - contour_x_center) < ERROR_THRESHOLD * min(group_w, contour_w):
+                group.append(contour)
+                found_group = True
+                break
+        if not found_group:
+            grouped_contours.append([contour])
+    return grouped_contours
+
+
+def group_contours_horizontally(contours) -> list[list[np.ndarray]]:
+    """
+    Groups the given contours horizontally
+    """
+    ERROR_THRESHOLD = 0.05
+    contours = sorted(contours, key=lambda c: cv2.boundingRect(c)[0])
+    grouped_contours = [[contours[0]]]
+    for contour in contours[1:]:
+        found_group = False
+        contour_x, contour_y, contour_w, contour_h = cv2.boundingRect(contour)
+        for group in grouped_contours[::-1]:
+            group_x, group_y, group_w, group_h = cv2.boundingRect(group[-1])
+            x_diff = abs(contour_x - group_x) - group_w
+            if x_diff < 0 or x_diff > min(contour_w, group_w):
+                continue 
+            group_y_center = group_y + group_h / 2
+            contour_y_center = contour_y + contour_h / 2
+            if abs(group_y_center - contour_y_center) < ERROR_THRESHOLD * min(group_h, contour_h):
+                group.append(contour)
+                found_group = True
+                break
+        if not found_group:
+            grouped_contours.append([contour])
+    return grouped_contours
+
+def group_bounding_boxes_vertically(bounding_boxes) -> list[list[tuple[int, int, int, int]]]:
+    """
+    Groups the given bounding boxes vertically
+    """
+    ERROR_THRESHOLD = 0.05
+    bounding_boxes = sorted(bounding_boxes, key=lambda bb: bb[1])
+    grouped_bounding_boxes = [[bounding_boxes[0]]]
+    for bounding_box in bounding_boxes[1:]:
+        found_group = False
+        bb_x, bb_y, bb_w, bb_h = bounding_box
+        for group in grouped_bounding_boxes[::-1]:
+            group_x, group_y, group_w, group_h = group[-1]
+            y_diff = abs(bb_y - group_y) - group_h
+            if y_diff < 0 or y_diff > min(bb_h, group_h):
+                continue 
+            group_x_center = group_x + group_w / 2
+            bb_x_center = bb_x + bb_w / 2
+            if abs(group_x_center - bb_x_center) < ERROR_THRESHOLD * min(group_w, bb_w):
+                group.append(bounding_box)
+                found_group = True
+                break
+        if not found_group:
+            grouped_bounding_boxes.append([bounding_box])
+    return grouped_bounding_boxes
+
+def group_bounding_boxes_horizontally(bounding_boxes) -> list[list[tuple[int, int, int, int]]]:
+    """
+    Groups the given bounding boxes horizontally
+    """
+    ERROR_THRESHOLD = 0.05
+    bounding_boxes = sorted(bounding_boxes, key=lambda bb: bb[0])
+    grouped_bounding_boxes = [[bounding_boxes[0]]]
+    for bounding_box in bounding_boxes[1:]:
+        found_group = False
+        bb_x, bb_y, bb_w, bb_h = bounding_box
+        for group in grouped_bounding_boxes[::-1]:
+            group_x, group_y, group_w, group_h = group[-1]
+            x_diff = abs(bb_x - group_x) - group_w
+            if x_diff < 0 or x_diff > min(bb_w, group_w):
+                continue 
+            group_y_center = group_y + group_h / 2
+            bb_y_center = bb_y + bb_h / 2
+            if abs(group_y_center - bb_y_center) < ERROR_THRESHOLD * min(group_h, bb_h):
+                group.append(bounding_box)
+                found_group = True
+                break
+        if not found_group:
+            grouped_bounding_boxes.append([bounding_box])
+    return grouped_bounding_boxes

image_processing/model.py

@@ -0,0 +1,33 @@
+class Model:
+    def __init__(self):
+        self.model = None
+        self.imported = False
+    
+    def load(self):
+        if self.model is None:
+            self.__load()
+
+    def __load(self):
+        if not self.imported:
+            self.imported = True
+            import torch
+            import pathlib
+            import sys
+            import os
+            from myutils.respath import resource_path
+
+        # Redirect sys.stderr to a file or a valid stream
+        if sys.stderr is None:
+            sys.stderr = open(os.devnull, 'w')
+
+        temp = pathlib.PosixPath
+        pathlib.PosixPath = pathlib.WindowsPath
+        self.model = torch.hub.load('ultralytics/yolov5', 'custom', path=resource_path('ai-models/2024-11-00/best.pt'))
+        pathlib.PosixPath = temp
+    
+    def __call__(self, *args, **kwds):
+        if self.model is None:
+            self.__load()
+        return self.model(*args, **kwds)
+
+model = Model()

image_processing/panel.py

@@ -0,0 +1,464 @@
+import os
+from typing import Callable
+import cv2
+import warnings
+import numpy as np
+from image_processing.image import is_contour_rectangular, apply_adaptive_threshold, group_contours_horizontally, group_contours_vertically, adaptive_hconcat, adaptive_vconcat, group_bounding_boxes_horizontally, group_bounding_boxes_vertically
+from myutils.myutils import load_images, load_image
+from tqdm import tqdm
+from image_processing.model import model
+
+class OutputMode:
+    BOUNDING = 'bounding'
+    MASKED = 'masked'
+
+    def from_index(index: int) -> str:
+        return [OutputMode.BOUNDING, OutputMode.MASKED][index]
+
+
+class MergeMode:
+    NONE = 'none'
+    VERTICAL = 'vertical'
+    HORIZONTAL = 'horizontal'
+
+    def from_index(index: int) -> str:
+        return [MergeMode.NONE, MergeMode.VERTICAL, MergeMode.HORIZONTAL][index]
+    
+
+def get_background_intensity_range(grayscale_image: np.ndarray, min_range: int = 1) -> tuple[int, int]:
+    """
+    Returns the minimum and maximum intensity values of the background of the image
+    """
+    edges = [grayscale_image[-1, :], grayscale_image[0, :], grayscale_image[:, 0], grayscale_image[:, -1]]
+    sorted_edges = sorted(edges, key=lambda x: np.var(x))
+
+    least_varied_edge = sorted_edges[0]
+
+    max_intensity = max(least_varied_edge)
+    min_intensity = max(min(min(least_varied_edge), max_intensity - min_range), 0)
+
+    return min_intensity, max_intensity
+
+
+def generate_background_mask(grayscale_image: np.ndarray) -> np.ndarray:
+    """
+    Generates a mask by focusing on the largest area of white pixels
+    """
+    WHITE = 255
+    LESS_WHITE, _ = get_background_intensity_range(grayscale_image, 25)
+    LESS_WHITE = max(LESS_WHITE, 240)
+
+    ret, thresh = cv2.threshold(grayscale_image, LESS_WHITE, WHITE, cv2.THRESH_BINARY)
+    nlabels, labels, stats, centroids = cv2.connectedComponentsWithStats(thresh)
+
+    mask = np.zeros_like(thresh)
+
+    PAGE_TO_SEGMENT_RATIO = 1024
+
+    halting_area_size = mask.size // PAGE_TO_SEGMENT_RATIO
+
+    mask_height, mask_width = mask.shape
+    base_background_size_error_threshold = 0.05
+    whole_background_min_width = mask_width * (1 - base_background_size_error_threshold)
+    whole_background_min_height = mask_height * (1 - base_background_size_error_threshold)
+
+    for i in np.argsort(stats[1:, 4])[::-1]:
+        contour_index = i + 1
+        x, y, w, h, area = stats[contour_index]
+        if area < halting_area_size:
+            break
+        if (
+            (w > whole_background_min_width) or
+            (h > whole_background_min_height) or
+            (is_contour_rectangular(cv2.findContours((labels == contour_index).astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[0][0]))
+        ):
+            mask[labels == contour_index] = WHITE
+
+    mask = cv2.dilate(mask, np.ones((3, 3), np.uint8), iterations=2)
+
+    return mask
+
+
+def extract_panels(
+    image: np.ndarray,
+    panel_contours: list[np.ndarray],
+    accept_page_as_panel: bool = True,
+    mode: str = OutputMode.BOUNDING,
+    fill_in_color: tuple[int, int, int] = (0, 0, 0),
+) -> list[np.ndarray]:
+    """
+    Extracts panels from the image using the given contours corresponding to the panels
+    
+    Parameters:
+    - image: The image to extract the panels from
+    - panel_contours: The contours corresponding to the panels
+    - accept_page_as_panel: Whether to accept the whole page as a panel
+    - mode: The mode to use for extraction
+        - 'masked': Extracts the panels by cuting out only the inside of the contours
+        - 'bounding': Extracts the panels by using the bounding boxes of the contours
+    - fill_in_color: The color to fill in the background of the panel images
+    """
+    height, width = image.shape[:2]
+
+    returned_panels = []
+
+    for contour in panel_contours:
+        x, y, w, h = cv2.boundingRect(contour)
+
+        if not accept_page_as_panel and ((w >= width * 0.99) or (h >= height * 0.99)):
+            continue
+
+        if mode == 'masked':
+            mask = np.zeros_like(image)
+            cv2.drawContours(mask, [contour], -1, (255, 255, 255), -1)
+            masked_image = cv2.bitwise_and(image, mask)
+            fitted_panel = masked_image[y:y + h, x:x + w]
+            fitted_panel = cv2.bitwise_or(cv2.bitwise_and(cv2.bitwise_not(mask[y:y + h, x:x + w]), fill_in_color), fitted_panel)
+        else:
+            fitted_panel = image[y:y + h, x:x + w]
+        
+        returned_panels.append(fitted_panel)
+
+    return returned_panels
+
+
+def preprocess_image(grayscale_image: np.ndarray) -> np.ndarray:
+    """
+    Preprocesses the image for panel extraction
+    """
+    processed_image = cv2.GaussianBlur(grayscale_image, (3, 3), 0)
+    processed_image = cv2.Laplacian(processed_image, -1)
+    return processed_image
+
+
+def preprocess_image_with_dilation(grayscale_image: np.ndarray) -> np.ndarray:
+    """
+    Preprocesses the image for panel extraction
+    """
+    processed_image = cv2.GaussianBlur(grayscale_image, (3, 3), 0)
+    processed_image = cv2.Laplacian(processed_image, -1)
+    processed_image = cv2.dilate(processed_image, np.ones((5, 5), np.uint8), iterations=1)
+    processed_image = 255 - processed_image
+    return processed_image
+
+
+def joint_panel_split_extraction(grayscale_image: np.ndarray, background_mask: np.ndarray) -> np.ndarray:
+    """
+    Extracts the panels from the image with splitting the joint panels
+    """
+    pixels_before = np.count_nonzero(background_mask)
+    background_mask = cv2.ximgproc.thinning(background_mask) 
+    
+    up_kernel = np.array([[0, 0, 0], [0, 1, 0], [0, 1, 0]], np.uint8)
+    down_kernel = np.array([[0, 1, 0], [0, 1, 0], [0, 0, 0]], np.uint8)
+    left_kernel = np.array([[0, 0, 0], [0, 1, 1], [0, 0, 0]], np.uint8)
+    right_kernel = np.array([[0, 0, 0], [1, 1, 0], [0, 0, 0]], np.uint8)
+
+    down_right_diagonal_kernel = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 0]], np.uint8)
+    down_left_diagonal_kernel = np.array([[0, 0, 1], [0, 1, 0], [0, 0, 0]], np.uint8)
+    up_left_diagonal_kernel = np.array([[0, 0, 0], [0, 1, 0], [0, 0, 1]], np.uint8)
+    up_right_diagonal_kernel = np.array([[0, 0, 0], [0, 1, 0], [1, 0, 0]], np.uint8)
+    
+    PAGE_TO_JOINT_OBJECT_RATIO = 3
+    image_height, image_width = grayscale_image.shape
+
+    height_based_size = image_height // PAGE_TO_JOINT_OBJECT_RATIO
+    width_based_size = (2 * image_width) // PAGE_TO_JOINT_OBJECT_RATIO
+
+    height_based_size += height_based_size % 2 + 1
+    width_based_size += width_based_size % 2 + 1
+
+    up_dilation_kernel = np.zeros((height_based_size, height_based_size), np.uint8)
+    up_dilation_kernel[height_based_size // 2:, height_based_size // 2] = 1
+
+    down_dilation_kernel = np.zeros((height_based_size, height_based_size), np.uint8)
+    down_dilation_kernel[:height_based_size // 2 + 1, height_based_size // 2] = 1
+
+    left_dilation_kernel = np.zeros((width_based_size, width_based_size), np.uint8)
+    left_dilation_kernel[width_based_size // 2, width_based_size // 2:] = 1
+
+    right_dilation_kernel = np.zeros((width_based_size, width_based_size), np.uint8)
+    right_dilation_kernel[width_based_size // 2, :width_based_size // 2 + 1] = 1
+
+    min_based_size = min(width_based_size, height_based_size)
+
+    down_right_dilation_kernel = np.identity(min_based_size // 2 + 1, dtype=np.uint8)
+    down_right_dilation_kernel = np.pad(down_right_dilation_kernel, ((0, min_based_size // 2), (0, min_based_size // 2)))
+
+    up_left_dilation_kernel = np.identity(min_based_size // 2 + 1, dtype=np.uint8)
+    up_left_dilation_kernel = np.pad(up_left_dilation_kernel, ((min_based_size // 2, 0), (0, min_based_size // 2)))
+
+    up_right_dilation_kernel = np.flip(np.identity(min_based_size // 2 + 1, dtype=np.uint8), axis=1)
+    up_right_dilation_kernel = np.pad(up_right_dilation_kernel, ((min_based_size // 2, 0), (0, min_based_size // 2)))
+
+    down_left_dilation_kernel = np.flip(np.identity(min_based_size // 2 + 1, dtype=np.uint8), axis=1)
+    down_left_dilation_kernel = np.pad(down_left_dilation_kernel, ((0, min_based_size // 2), (min_based_size // 2, 0)))
+
+    match_kernels = [
+        up_kernel,
+        down_kernel,
+        left_kernel,
+        right_kernel,
+        down_right_diagonal_kernel,
+        down_left_diagonal_kernel,
+        up_left_diagonal_kernel,
+        up_right_diagonal_kernel,
+    ]
+
+    dilation_kernels = [
+        up_dilation_kernel,
+        down_dilation_kernel,
+        left_dilation_kernel,
+        right_dilation_kernel,
+        down_right_dilation_kernel,
+        down_left_dilation_kernel,
+        up_left_dilation_kernel,
+        up_right_dilation_kernel,
+    ]
+
+    def get_dots(grayscale_image: np.ndarray, kernel: np.ndarray) -> tuple[np.ndarray, int]:
+        temp = cv2.matchTemplate(grayscale_image, kernel, cv2.TM_CCOEFF_NORMED)
+        _, temp = cv2.threshold(temp, 0.9, 1, cv2.THRESH_BINARY)
+        temp = np.where(temp == 1, 255, 0).astype(np.uint8)
+        pad_height = (kernel.shape[0] - 1) // 2
+        pad_width = (kernel.shape[1] - 1) // 2
+        temp = cv2.copyMakeBorder(temp, pad_height, kernel.shape[0] - pad_height - 1, pad_width, kernel.shape[1] - pad_width - 1, cv2.BORDER_CONSTANT, value=0)
+        return temp
+    
+    for match_kernel, dilation_kernel in zip(match_kernels, dilation_kernels):
+        dots = get_dots(background_mask, match_kernel)
+        lines = cv2.dilate(dots, dilation_kernel, iterations=1)
+        background_mask = cv2.bitwise_or(background_mask, lines)
+
+    pixels_now = np.count_nonzero(background_mask)
+    dilation_size = pixels_before // (4  * pixels_now)
+    dilation_size += dilation_size % 2 + 1
+    background_mask = cv2.dilate(background_mask, np.ones((dilation_size, dilation_size), np.uint8), iterations=1)
+
+    page_without_background = 255 - background_mask
+
+    return page_without_background
+
+
+def is_contour_sufficiently_big(contour: np.ndarray, image_height: int, image_width: int) -> bool:
+    PAGE_TO_PANEL_RATIO = 32
+    image_area = image_width * image_height
+    area_threshold = image_area // PAGE_TO_PANEL_RATIO
+    area = cv2.contourArea(contour)
+    return area > area_threshold
+
+
+def threshold_extraction(
+        image: np.ndarray, 
+        grayscale_image: np.ndarray, 
+        mode: str = OutputMode.BOUNDING,
+) -> list[np.ndarray]:
+    """
+    Extracts panels from the image using thresholding
+    """
+    processed_image = cv2.GaussianBlur(grayscale_image, (3, 3), 0)
+    processed_image = cv2.Laplacian(processed_image, -1)
+    _, thresh = cv2.threshold(processed_image, 8, 255, cv2.THRESH_BINARY)
+    processed_image = apply_adaptive_threshold(processed_image)
+    processed_image = cv2.subtract(processed_image, thresh)
+    processed_image = cv2.dilate(processed_image, np.ones((3, 3), np.uint8), iterations=2)
+    contours, _ = cv2.findContours(processed_image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    contours = list(filter(lambda c: is_contour_sufficiently_big(c, image.shape[0], image.shape[1]), contours))
+    panels = extract_panels(image, contours, False, mode=mode)
+
+    return panels
+
+
+def get_page_without_background(grayscale_image: np.ndarray, background_mask: np.ndarray, split_joint_panels = False) -> np.ndarray:
+    """
+    Returns the page without the background
+    """
+    STRIPE_FORMAT_MASK_AREA_RATIO = 0.3
+
+    mask_area = np.count_nonzero(background_mask)
+    mask_area_ratio = mask_area / background_mask.size
+
+    if STRIPE_FORMAT_MASK_AREA_RATIO > mask_area_ratio and split_joint_panels:
+        page_without_background = joint_panel_split_extraction(grayscale_image, background_mask)
+    else:
+        page_without_background = cv2.subtract(grayscale_image, background_mask)
+
+    return page_without_background
+
+
+def get_fallback_panels(
+        image: np.ndarray, 
+        grayscale_image: np.ndarray, 
+        fallback: bool, 
+        panels: list[np.ndarray],
+        mode: str = OutputMode.BOUNDING,
+) -> list[np.ndarray]:
+    """
+    Checks if the fallback is needed and returns the appropriate panels
+    
+    Parameters:
+    - mode: The mode to use for extraction
+        - 'masked': Extracts the panels by cuting out only the inside of the contours
+        - 'bounding': Extracts the panels by using the bounding boxes of the contours
+    """
+    if fallback and len(panels) < 2:
+        tmp = threshold_extraction(image, grayscale_image, mode=mode)
+        if len(tmp) > len(panels):
+            return tmp
+    
+    return panels
+
+
+def generate_panel_blocks(
+        image: np.ndarray, 
+        background_generator: Callable[[np.ndarray], np.ndarray] = generate_background_mask,
+        split_joint_panels: bool = False,
+        fallback: bool = True,
+        mode: str = OutputMode.BOUNDING,
+        merge: str = MergeMode.NONE
+) -> list[np.ndarray]:
+    """
+    Generates the separate panel images from the base image
+    
+    Parameters:
+    - mode: The mode to use for extraction
+        - 'masked': Extracts the panels by cuting out only the inside of the contours
+        - 'bounding': Extracts the panels by using the bounding boxes of the contours
+    """
+
+    grayscale_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    processed_image = preprocess_image_with_dilation(grayscale_image)
+    background_mask = background_generator(processed_image)
+    page_without_background = get_page_without_background(grayscale_image, background_mask, split_joint_panels)
+    contours, _ = cv2.findContours(page_without_background, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    contours = list(filter(lambda c: is_contour_sufficiently_big(c, image.shape[0], image.shape[1]), contours))
+
+    def get_panels(contours):
+        panels = extract_panels(image, contours, mode=mode)
+        panels = get_fallback_panels(image, grayscale_image, fallback, panels, mode=mode)
+        return panels
+
+    panels = []
+    if merge == MergeMode.NONE:
+        panels = get_panels(contours)
+    elif merge == MergeMode.HORIZONTAL:
+        grouped_contours = group_contours_horizontally(contours)
+        for group in grouped_contours:
+            panels.append(adaptive_hconcat(get_panels(group)))
+    elif merge == MergeMode.VERTICAL:
+        grouped_contours = group_contours_vertically(contours)
+        for group in grouped_contours:
+            panels.append(adaptive_vconcat(get_panels(group)))
+
+    return panels
+
+
+def generate_panel_blocks_by_ai(image: np.ndarray, merge: str = MergeMode.NONE) -> list[np.ndarray]:
+    """
+    Generates the separate panel images from the base image using AI with merge
+    """
+    grayscale_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    processed_image = preprocess_image(grayscale_image)
+
+    warnings.filterwarnings("ignore", category=FutureWarning) # Ignore 'FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.'
+    results = model(processed_image)
+    warnings.filterwarnings("default", category=FutureWarning)
+
+    bounding_boxes = []
+    for detection in results.xyxy[0]:  # Access predictions in (x1, y1, x2, y2, confidence, class) format
+        x1, y1, x2, y2, conf, cls = detection.tolist()  # Convert to Python list
+        x1, y1, x2, y2 = map(int, [x1, y1, x2, y2])
+        bounding_boxes.append((x1, y1, x2 - x1, y2 - y1))
+
+    def get_panels(bounding_boxes):
+        panels = []
+        for x, y, w, h in bounding_boxes:
+            panel = image[y:y + h, x:x + w]
+            panels.append(panel)
+        return panels
+
+    panels = []
+    if merge == MergeMode.NONE:
+        panels = get_panels(bounding_boxes)
+    elif merge == MergeMode.HORIZONTAL:
+        grouped_bounding_boxes = group_bounding_boxes_horizontally(bounding_boxes)
+        for group in grouped_bounding_boxes:
+            panels.append(adaptive_hconcat(get_panels(group)))
+    elif merge == MergeMode.VERTICAL:
+        grouped_bounding_boxes = group_bounding_boxes_vertically(bounding_boxes)
+        for group in grouped_bounding_boxes:
+            panels.append(adaptive_vconcat(get_panels(group)))
+
+    return panels
+
+
+def extract_panels_for_image(
+        image_path: str, 
+        output_dir: str, 
+        fallback: bool = True, 
+        split_joint_panels: bool = False,
+        mode: str = OutputMode.BOUNDING,
+        merge: str = MergeMode.NONE
+        ) -> None:
+    """
+    Extracts panels for a single image
+    """
+    if not os.path.exists(image_path):
+        return
+    image_path = os.path.abspath(image_path)
+    image = load_image(os.path.dirname(image_path), image_path)
+    image_name, image_ext = os.path.splitext(image.image_name)
+    panel_blocks = generate_panel_blocks(image.image, split_joint_panels=split_joint_panels, fallback=fallback, mode=mode, merge=merge)
+    for k, panel in enumerate(tqdm(panel_blocks, total=len(panel_blocks))):
+        out_path = os.path.join(output_dir, f"{image_name}_{k}{image_ext}")
+        cv2.imwrite(out_path, panel)
+
+
+def extract_panels_for_images_in_folder(
+        input_dir: str, 
+        output_dir: str, 
+        fallback: bool = True, 
+        split_joint_panels: bool = False,
+        mode: str = OutputMode.BOUNDING,
+        merge: str = MergeMode.NONE
+        ) -> tuple[int, int]:
+    """
+    Basically the main function of the program,
+    this is written with cli usage in mind
+    """
+    if not os.path.exists(output_dir):
+        return (0, 0)
+    files = os.listdir(input_dir)
+    num_files = len(files)
+    num_panels = 0
+    for _, image in enumerate(tqdm(load_images(input_dir), total=num_files)):
+        image_name, image_ext = os.path.splitext(image.image_name)
+        panel_blocks = generate_panel_blocks(image.image, fallback=fallback, split_joint_panels=split_joint_panels, mode=mode, merge=merge)
+        for j, panel in enumerate(panel_blocks):
+            out_path = os.path.join(output_dir, f"{image_name}_{j}{image_ext}")
+            cv2.imwrite(out_path, panel)
+        num_panels += len(panel_blocks)
+    return (num_files, num_panels)
+
+def extract_panels_for_images_in_folder_by_ai(
+        input_dir: str, 
+        output_dir: str
+        ) -> tuple[int, int]:
+    """
+    Basically the main function of the program,
+    this is written with cli usage in mind
+    """
+    if not os.path.exists(output_dir):
+        return (0, 0)
+    files = os.listdir(input_dir)
+    num_files = len(files)
+    num_panels = 0
+    for _, image in enumerate(tqdm(load_images(input_dir), total=num_files)):
+        image_name, image_ext = os.path.splitext(image.image_name)
+        panel_blocks = generate_panel_blocks_by_ai(image.image)
+        for j, panel in enumerate(panel_blocks):
+            out_path = os.path.join(output_dir, f"{image_name}_{j}{image_ext}")
+            cv2.imwrite(out_path, panel)
+        num_panels += len(panel_blocks)
+    return (num_files, num_panels)
+

myutils/myutils.py

@@ -0,0 +1,71 @@
+import os
+from dataclasses import dataclass
+import cv2
+import numpy as np
+
+supported_types = [
+    ".bmp",
+    ".dib",
+    ".jpeg",
+    ".jpg",
+    ".jpe",
+    ".jp2",
+    ".png",
+    ".webp",
+    ".pbm",
+    ".pgm",
+    ".pp",
+    ".pxm",
+    ".pnm",
+    ".pfm",
+    ".sr",
+    ".ras",
+    ".tiff",
+    ".tif",
+    ".exr",
+    ".hdr",
+    ".pic",
+]
+
+
+@dataclass
+class ImageWithFilename:
+    image: np.ndarray
+    image_name: str
+
+
+def get_file_extension(file_path: str) -> str:
+    """
+    Returns the extension of the given file path
+    """
+    return os.path.splitext(file_path)[1]
+
+
+def load_image(directory_path: str, image_name: str) -> ImageWithFilename:
+    """
+    Returns an ImageWithFilename object from the given image name in the given directory
+    """
+    image = cv2.imread(os.path.join(directory_path, image_name))
+    return ImageWithFilename(image, image_name)
+
+
+def load_images(directory_path: str) -> list[ImageWithFilename]:
+    """
+    Returns a list of ImageWithFilename objects from the images in the given directory
+    """
+    file_names = get_file_names(directory_path)
+    image_names = filter(lambda x: get_file_extension(x) in supported_types, file_names)
+    return [load_image(directory_path, image_name) for image_name in image_names]
+
+
+def get_file_names(directory_path: str) -> list[str]:
+    """
+    Returns the names of the files in the given directory
+    """
+    if not os.path.exists(directory_path):
+        return []
+    return [
+        file_name
+        for file_name in os.listdir(directory_path)
+        if os.path.isfile(os.path.join(directory_path, file_name))
+    ]

myutils/respath.py

@@ -0,0 +1,16 @@
+import os
+import sys
+
+build_paths = dict([(os.path.normpath(x[0]), os.path.normpath(x[1])) for x in [
+    ("icon.ico", "icon.ico"),
+    ("ai-models/2024-11-00/best.pt", "models/best.pt"),
+]])
+
+# Function to get the correct path to bundled resources
+def resource_path(relative_path: str) -> str:
+    relative_path = os.path.normpath(relative_path)
+    if hasattr(sys, '_MEIPASS'):
+        # Running in a PyInstaller bundle
+        return build_paths[relative_path]
+    else:
+        return relative_path

requirements.txt

@@ -0,0 +1,8 @@
+--extra-index-url https://download.pytorch.org/whl/cu126
+
+gradio
+numpy
+opencv-contrib-python
+tqdm
+torch
+yolov5

webui.bat

@@ -0,0 +1,162 @@
+@echo off
+
+:: The original source of the webui.bat file is stable-diffusion-webui
+:: Modified and enhanced by Gemini with features for venv management and requirements handling.
+
+:: --------- Configuration ---------
+set COMMANDLINE_ARGS=
+:: Define the name of the Launch application
+set APPLICATION_NAME=app.py
+:: Define the name of the virtual environment directory
+set VENV_NAME=venv
+:: Set to 1 to always attempt to update packages from requirements.txt on every launch
+set ALWAYS_UPDATE_REQS=0
+:: ---------------------------------
+
+
+:: Set PYTHON executable if not already defined
+if not defined PYTHON (set PYTHON=python)
+:: Set VENV_DIR using VENV_NAME if not already defined
+if not defined VENV_DIR (set "VENV_DIR=%~dp0%VENV_NAME%")
+
+mkdir tmp 2>NUL
+
+:: Check if Python is callable
+%PYTHON% -c "" >tmp/stdout.txt 2>tmp/stderr.txt
+if %ERRORLEVEL% == 0 goto :check_pip
+echo Couldn't launch python
+goto :show_stdout_stderr
+
+:check_pip
+:: Check if pip is available
+%PYTHON% -mpip --help >tmp/stdout.txt 2>tmp/stderr.txt
+if %ERRORLEVEL% == 0 goto :start_venv
+:: If pip is not available and PIP_INSTALLER_LOCATION is set, try to install pip
+if "%PIP_INSTALLER_LOCATION%" == "" goto :show_stdout_stderr
+%PYTHON% "%PIP_INSTALLER_LOCATION%" >tmp/stdout.txt 2>tmp/stderr.txt
+if %ERRORLEVEL% == 0 goto :start_venv
+echo Couldn't install pip
+goto :show_stdout_stderr
+
+:start_venv
+:: Skip venv creation/activation if VENV_DIR is explicitly set to "-"
+if ["%VENV_DIR%"] == ["-"] goto :skip_venv_entirely
+:: Skip venv creation/activation if SKIP_VENV is set to "1"
+if ["%SKIP_VENV%"] == ["1"] goto :skip_venv_entirely
+
+:: Check if the venv already exists by looking for Python.exe in its Scripts directory
+dir "%VENV_DIR%\Scripts\Python.exe" >tmp/stdout.txt 2>tmp/stderr.txt
+if %ERRORLEVEL% == 0 goto :activate_venv_and_maybe_update
+
+:: Venv does not exist, create it
+echo Virtual environment not found in "%VENV_DIR%". Creating a new one.
+for /f "delims=" %%i in ('CALL %PYTHON% -c "import sys; print(sys.executable)"') do set PYTHON_FULLNAME="%%i"
+echo Creating venv in directory %VENV_DIR% using python %PYTHON_FULLNAME%
+%PYTHON_FULLNAME% -m venv "%VENV_DIR%" >tmp/stdout.txt 2>tmp/stderr.txt
+if %ERRORLEVEL% NEQ 0 (
+    echo Unable to create venv in directory "%VENV_DIR%"
+    goto :show_stdout_stderr
+)
+echo Venv created.
+
+:: Install requirements for the first time if venv was just created
+:: This section handles the initial installation of packages from requirements.txt
+:: immediately after a new virtual environment is created.
+echo Checking for requirements.txt for initial setup in %~dp0
+if exist "%~dp0requirements.txt" (
+    echo Found requirements.txt, attempting to install for initial setup...
+    call "%VENV_DIR%\Scripts\activate.bat"
+    echo Installing packages from requirements.txt ^(initial setup^)...
+    "%VENV_DIR%\Scripts\python.exe" -m pip install -r "%~dp0requirements.txt"
+    if %ERRORLEVEL% NEQ 0 (
+        echo Failed to install requirements during initial setup. Please check the output above.
+        pause
+        goto :show_stdout_stderr_custom_pip_initial 
+    )
+    echo Initial requirements installed successfully.
+    call "%VENV_DIR%\Scripts\deactivate.bat"
+) else (
+    echo No requirements.txt found for initial setup, skipping package installation.
+)
+goto :activate_venv_and_maybe_update
+
+
+:activate_venv_and_maybe_update
+:: This label is reached if the venv exists or was just created.
+:: Set PYTHON to point to the venv's Python interpreter.
+set PYTHON="%VENV_DIR%\Scripts\Python.exe"
+echo Activating venv: %PYTHON%
+
+:: Always update requirements if ALWAYS_UPDATE_REQS is 1
+:: This section allows for updating packages from requirements.txt on every launch
+:: if the ALWAYS_UPDATE_REQS variable is set to 1.
+if defined ALWAYS_UPDATE_REQS (
+    if "%ALWAYS_UPDATE_REQS%"=="1" (
+        echo ALWAYS_UPDATE_REQS is enabled.
+        if exist "%~dp0requirements.txt" (
+            echo Attempting to update packages from requirements.txt...
+            REM No need to call activate.bat here again, PYTHON is already set to the venv's python
+            %PYTHON% -m pip install -r "%~dp0requirements.txt"
+            if %ERRORLEVEL% NEQ 0 (
+                echo Failed to update requirements. Please check the output above.
+                pause
+                goto :endofscript 
+            )
+            echo Requirements updated successfully.
+        ) else (
+            echo ALWAYS_UPDATE_REQS is enabled, but no requirements.txt found. Skipping update.
+        )
+    ) else (
+        echo ALWAYS_UPDATE_REQS is not enabled or not set to 1. Skipping routine update.
+    )
+)
+
+goto :launch
+
+:skip_venv_entirely
+:: This label is reached if venv usage is explicitly skipped.
+echo Skipping venv.
+goto :launch
+
+:launch
+:: Launch the main application
+echo Launching Web UI with arguments: %COMMANDLINE_ARGS% %*
+%PYTHON% %APPLICATION_NAME% %COMMANDLINE_ARGS% %*
+echo Launch finished.
+pause
+exit /b
+
+:show_stdout_stderr_custom_pip_initial
+:: Custom error handler for failures during the initial pip install process.
+echo.
+echo exit code ^(pip initial install^): %errorlevel%
+echo Errors during initial pip install. See output above.
+echo.
+echo Launch unsuccessful. Exiting.
+pause
+exit /b
+
+
+:show_stdout_stderr
+:: General error handler: displays stdout and stderr from the tmp directory.
+echo.
+echo exit code: %errorlevel%
+
+for /f %%i in ("tmp\stdout.txt") do set size=%%~zi
+if %size% equ 0 goto :show_stderr
+echo.
+echo stdout:
+type tmp\stdout.txt
+
+:show_stderr
+for /f %%i in ("tmp\stderr.txt") do set size=%%~zi
+if %size% equ 0 goto :endofscript
+echo.
+echo stderr:
+type tmp\stderr.txt
+
+:endofscript
+echo.
+echo Launch unsuccessful. Exiting.
+pause
+exit /b