v1

.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
+*.png filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,593 @@
+import gradio as gr
+
+import cv2
+import json
+import os
+import numpy as np
+from pathlib import Path
+from pylena.scribo import line_detector
+from pylena.scribo import VSegment, LSuperposition
+from pylena.scribo import e_segdet_preprocess, e_segdet_process_extraction, e_segdet_process_tracking, e_segdet_process_traversal_mode
+import time
+
+from typing import List, Tuple, Dict
+
+
+# Define all the default values
+default_min_len = 10
+default_preprocess = "NONE"
+default_tracker = "KALMAN"
+default_traversal_mode = "HORIZONTAL_VERTICAL"
+default_extraction_type = "BINARY"
+default_negate_image = False
+default_dyn = 0.6
+default_size_mask = 11
+default_double_exponential_alpha = 0.6
+default_simple_moving_average_memory = 30.0
+default_exponential_moving_average_memory = 16.0
+default_one_euro_beta = 0.007
+default_one_euro_mincutoff = 1.0
+default_one_euro_dcutoff = 1.0
+default_bucket_size = 32
+default_nb_values_to_keep = 30
+default_discontinuity_relative = 0
+default_discontinuity_absolute = 0
+default_minimum_for_fusion = 15
+default_default_sigma_position = 2
+default_default_sigma_thickness = 2
+default_default_sigma_luminosity = 57
+default_min_nb_values_sigma = 10
+default_sigma_pos_min = 1.0
+default_sigma_thickness_min = 0.64
+default_sigma_luminosity_min = 13.0
+default_gradient_threshold = 30
+default_llumi = 225
+default_blumi = 225
+default_ratio_lum = 1.0
+default_max_thickness = 100
+default_threshold_intersection = 0.8
+default_remove_duplicates = True
+
+
+def get_json_extract(full_json: dict) -> dict:
+    """Extract 5 samples from a json dictionnary
+
+    Args:
+        full_json (dict): The full json dictionnary
+
+    Returns:
+        dict: A sub sample of the full json dictionnary containing the first 5 samples.
+    """
+    extract_json = {}
+
+    count = 5
+    for key, value in full_json.items():
+        extract_json[key] = value
+
+        count -= 1
+        if count == 0:
+            break
+
+    return extract_json
+
+
+def save_json(data: dict, path: Path) -> None:
+    """Save a json dictionnary to a file
+
+    Args:
+        data (dict): The json dictionnary to save
+        path (Path): The path to the file
+    """
+    with open(path, "w") as f:
+        json.dump(data, f)
+
+
+def get_new_white(height: int, width: int) -> np.ndarray:
+    """Create a new white image
+
+    Args:
+        height (int): The height of the image
+        width (int): The width of the image
+
+    Returns:
+        np.ndarray: The new white image
+    """
+    img = np.ones((height, width, 3), dtype=np.uint8) * 255
+    return img
+
+# fmt: off
+
+def generate_vector_output(img_rgb_input: np.ndarray, lines: List[VSegment], lines_colors: Dict[int, np.ndarray]):
+    """Generate the vector output using the VSegment list
+
+    Args:
+        img_rgb_input (np.ndarray): Input image with 3 channels
+        lines (List[VSegment]): The identified lines in the image
+        lines_colors (Dict[int, np.ndarray]): Dictionary containing the color for each line according to their label
+
+    Returns:
+        Tuple[np.ndarray, np.ndarray, Path, dict]: The vector output
+    """
+
+    def draw_lines(img: np.ndarray, lines: List[VSegment]) -> np.ndarray:
+        """Draw the lines as vector on the image 
+
+        Args:
+            img (np.ndarray): The image to draw on
+            lines (List[VSegment]): The lines to draw
+
+        Returns:
+            np.ndarray: The image with the lines drawn on it
+        """
+        for line in lines:
+            cv2.line(img, (line.x0, line.y0), (line.x1, line.y1), lines_colors[line.label].tolist(), 2)
+        return img
+
+    def get_vector_json(lines: List[VSegment]) -> dict:
+        """Generate the json dictionnary containing the vector output
+
+        Args:
+            lines (List[VSegment]): The lines to draw
+
+        Returns:
+            dict: The json dictionnary containing the vector output
+        """
+        ret = {}
+        for line in lines:
+            ret[str(line.label)] = {"x0": line.x0, "y0": line.y0, "x1": line.x1, "y1": line.y1}
+        return ret
+
+    img_empty = get_new_white(img_rgb_input.shape[0], img_rgb_input.shape[1])
+
+    out_vector_over_img = draw_lines(img_rgb_input.copy(), lines)
+    out_vector_label_img = draw_lines(img_empty, lines)
+
+    out_vector_file = Path("vector_output_full.json")
+    out_vector_file_full = get_vector_json(lines)
+    save_json(out_vector_file_full, out_vector_file)
+
+    out_vector_file_extract = get_json_extract(out_vector_file_full)
+
+    return out_vector_over_img, out_vector_label_img, out_vector_file, out_vector_file_extract,
+
+def generate_pixel_output(img_rgb_input: np.ndarray, img_label: np.ndarray, superpositions: List[LSuperposition], lines_colors: Dict[int, np.ndarray]):
+    """Generate the pixel output using the LSuperposition list and the img_label
+
+    Args:
+        img_rgb_input (np.ndarray): Input image with 3 channels
+        img_label (np.ndarray): The labelized image
+        superpositions (List[LSuperposition]): The identified superpositions in the image
+        lines_colors (Dict[int, np.ndarray]): Dictionary containing the color for each line according to their label
+
+    Returns:
+        Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, Path, Path, dict]: The pixel output
+    """
+
+    def draw_pixels(img: np.ndarray, img_label: np.ndarray, lines_colors: Dict[int, np.ndarray]) -> np.ndarray:
+        """Draw the pixels as vector on the image
+
+        Args:
+            img (np.ndarray): The image to draw on
+            img_label (np.ndarray): The labelized image
+            lines_colors (Dict[int, np.ndarray]): Dictionary containing the color for each line according to their label
+
+        Returns:
+            np.ndarray: The image with the pixels drawn on it
+        """
+        for x in range(img.shape[0]):
+            for y in range(img.shape[1]):
+                if img_label[x, y] != 0 and img_label[x, y] != 1:
+                    img[x, y, :] = lines_colors[img_label[x, y]]
+        return img
+
+    def draw_superposition(img: np.ndarray, superpositions: List[LSuperposition], lines_colors: Dict[int, np.ndarray]) -> np.ndarray:
+        """Draw the superpositions as vector on the image
+
+        Args:
+            img (np.ndarray): The image to draw on
+            superpositions (List[LSuperposition]): The superpositions to draw
+            lines_colors (Dict[int, np.ndarray]): Dictionary containing the color for each line according to their label
+
+        Returns:
+            np.ndarray: The image with the superpositions drawn on it
+        """
+        for superposition in superpositions:
+            img[superposition.y, superposition.x, :] = lines_colors[1]
+        return img
+
+    def get_superposition_json(superpositions: List[LSuperposition]) -> dict:
+        """Generate the json dictionnary containing the superposition output
+
+        Args:
+            superpositions (List[LSuperposition]): The superpositions
+
+        Returns:
+            dict: The json dictionnary containing the superposition output
+        """
+        ret = {}
+        for superposition in superpositions:
+            key = f"{superposition.x}_{superposition.y}"
+            if not key in ret:
+                ret[key] = []
+
+            ret[key].append(superposition.label) 
+        return ret
+
+    def draw_full(img: np.ndarray, img_label: np.ndarray, superpositions: List[LSuperposition], lines_colors: Dict[int, np.ndarray]):
+        """Draw the full output (pixels and superpositions) on the image
+
+        Args:
+            img (np.ndarray): The image to draw on
+            img_label (np.ndarray): The labelized image
+            superpositions (List[LSuperposition]): The superpositions
+            lines_colors (Dict[int, np.ndarray]): Dictionary containing the color for each line according to their label
+
+        Returns:
+            np.ndarray: The image with the full output drawn on it
+        """
+        img = draw_pixels(img, img_label, lines_colors)
+        img = draw_superposition(img, superpositions, lines_colors)
+        return img
+
+    out_pixel_full_over_img = draw_full(img_rgb_input.copy(), img_label, superpositions, lines_colors)
+    out_pixel_line_over_img = draw_pixels(img_rgb_input.copy(), img_label, lines_colors)
+    out_pixel_superposition_over_img = draw_superposition(img_rgb_input.copy(), superpositions, lines_colors)
+
+    img_empty = get_new_white(img_rgb_input.shape[0], img_rgb_input.shape[1])
+    out_pixel_full_img = draw_full(img_empty.copy(), img_label, superpositions, lines_colors)
+    out_pixel_line_img = draw_pixels(img_empty.copy(), img_label, lines_colors)
+    out_pixel_superposition_img = draw_superposition(img_empty.copy(), superpositions, lines_colors)
+
+    out_pixel_file_label = Path("pixel_output_label.npy")
+    img_label.dump(out_pixel_file_label)
+    out_pixel_file_superposition = Path("pixel_output_superposition.json")
+    out_pixel_file_superposition_full = get_superposition_json(superpositions)
+    save_json(out_pixel_file_superposition_full, out_pixel_file_superposition)
+    out_pixel_file_superposition_extract = get_json_extract(out_pixel_file_superposition_full)
+
+    return out_pixel_full_over_img, out_pixel_line_over_img, out_pixel_superposition_over_img, out_pixel_full_img, out_pixel_line_img, out_pixel_superposition_img, out_pixel_file_label, out_pixel_file_superposition, out_pixel_file_superposition_extract
+
+def generate_output(img_input: np.ndarray, img_label: np.ndarray, superpositions: List[LSuperposition], lines: List[VSegment]):
+    """Generate the output using the LSuperposition list and the img_label
+
+    Args:
+        img_input (np.ndarray): Input image with 1 channel
+        img_label (np.ndarray): The labelized image
+        superpositions (List[LSuperposition]): The identified superpositions in the image
+        lines (List[VSegment]): The identified lines in the image
+
+    Returns:
+        Tuple[np.ndarray, np.ndarray, Path, dict, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, Path, Path, dict]: The complete output for gradio application
+    """
+    def get_rgb_input_img(greyscale_input_img: np.ndarray) -> np.ndarray:
+        """Convert a greyscale image to a rgb image
+
+        Args:
+            greyscale_input_img (np.ndarray): The greyscale / 1 channel image
+
+        Returns:
+            np.ndarray: The 3 channels version of the input image
+        """
+        rgb_input_img: np.ndarray = np.zeros((greyscale_input_img.shape[0], greyscale_input_img.shape[1], 3), dtype=np.uint8)
+        rgb_input_img[:, :, 0] = greyscale_input_img
+        rgb_input_img[:, :, 1] = greyscale_input_img
+        rgb_input_img[:, :, 2] = greyscale_input_img
+
+        return rgb_input_img
+
+    def generate_line_colors(lines: List[VSegment]) -> Dict[int, np.ndarray]:
+        """Generate a color for each line
+
+        Args:
+            lines (List[VSegment]): The lines
+
+        Returns:
+            Dict[int, np.ndarray]: A dictionary containing the color for each line according to their label
+        """
+        np.random.seed(0)
+        color = np.random.randint(low=0, high=255, size=(len(lines), 3))
+
+        ret = {}
+        ret[0] = np.array([0, 0, 0])
+        ret[1] = np.array([255, 0, 0])
+        for i, line in enumerate(lines):
+            ret[line.label] = color[i, :].astype(np.uint8)
+        return ret
+
+    rgb_input_img: np.ndarray = get_rgb_input_img(img_input)
+    lines_colors: Dict[int, np.ndarray] = generate_line_colors(lines)
+
+    out_vector: Tuple[np.ndarray, np.ndarray, Path, dict]
+    out_vector = generate_vector_output(rgb_input_img, lines, lines_colors)
+
+    out_pixel: Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, Path, Path, dict]
+    out_pixel = generate_pixel_output(rgb_input_img, img_label, superpositions, lines_colors)
+
+    return *out_vector, *out_pixel
+
+def app_function(
+    greyscale_input_img,
+    min_len,
+    preprocess,
+    tracker,
+    traversal_mode,
+    extraction_type,
+    negate_image,
+    dyn,
+    size_mask,
+    double_exponential_alpha,
+    simple_moving_average_memory,
+    exponential_moving_average_memory,
+    one_euro_beta,
+    one_euro_mincutoff,
+    one_euro_dcutoff,
+    bucket_size,
+    nb_values_to_keep,
+    discontinuity_relative,
+    discontinuity_absolute,
+    minimum_for_fusion,
+    default_sigma_position,
+    default_sigma_thickness,
+    default_sigma_luminosity,
+    min_nb_values_sigma,
+    sigma_pos_min,
+    sigma_thickness_min,
+    sigma_luminosity_min,
+    gradient_threshold,
+    llumi,
+    blumi,
+    ratio_lum,
+    max_thickness,
+    threshold_intersection,
+    remove_duplicates):
+
+    img_label: np.ndarray
+    superpositions: List[LSuperposition]
+    lines: List[VSegment]
+
+    def get_enum_value(enum, value):
+        return enum.__members__[value]
+
+    t0 = time.time()
+    img_label, superpositions, lines = line_detector(
+        greyscale_input_img, "full",
+        min_len=int(min_len),
+        preprocess=get_enum_value(e_segdet_preprocess, preprocess),
+        tracker=get_enum_value(e_segdet_process_tracking, tracker),
+        traversal_mode=get_enum_value(e_segdet_process_traversal_mode, traversal_mode),
+        extraction_type=get_enum_value(e_segdet_process_extraction, extraction_type),
+        negate_image=bool(negate_image),
+        dyn=float(dyn),
+        size_mask=int(size_mask),
+        double_exponential_alpha=float(double_exponential_alpha),
+        simple_moving_average_memory=int(simple_moving_average_memory),
+        exponential_moving_average_memory=int(exponential_moving_average_memory),
+        one_euro_beta=float(one_euro_beta),
+        one_euro_mincutoff=float(one_euro_mincutoff),
+        one_euro_dcutoff=float(one_euro_dcutoff),
+        bucket_size=int(bucket_size),
+        nb_values_to_keep=int(nb_values_to_keep),
+        discontinuity_relative=int(discontinuity_relative),
+        discontinuity_absolute=int(discontinuity_absolute),
+        minimum_for_fusion=int(minimum_for_fusion),
+        default_sigma_position=int(default_sigma_position),
+        default_sigma_thickness=int(default_sigma_thickness),
+        default_sigma_luminosity=int(default_sigma_luminosity),
+        min_nb_values_sigma=int(min_nb_values_sigma),
+        sigma_pos_min=float(sigma_pos_min),
+        sigma_thickness_min=float(sigma_thickness_min),
+        sigma_luminosity_min=float(sigma_luminosity_min),
+        gradient_threshold=int(gradient_threshold),
+        llumi=int(llumi),
+        blumi=int(blumi),
+        ratio_lum=float(ratio_lum),
+        max_thickness=int(max_thickness),
+        threshold_intersection=float(threshold_intersection),
+        remove_duplicates=bool(remove_duplicates)
+    )
+    t1 = time.time()
+
+    duration = t1 - t0
+
+    outputs = generate_output(greyscale_input_img, img_label, superpositions, lines)
+
+    return duration, *outputs
+
+
+
+with gr.Blocks() as app:
+    gr.Markdown("""
+        # Pylena line detection demonstration
+                
+        This is a demonstration of the line detector described in the article *Linear Object Detection in Document Images using Multiple Object Tracking*
+        accepted at ICDAR 2023. The article is available at: https://arxiv.org/abs/2305.16968.
+
+        ## How to use this demonstration ?
+                
+        You can either upload your own (greyscale/8bit image) image or use one of the examples, then change the parameters and click on the run button.              
+
+        The complete documentation is available at: http://olena.pages.lre.epita.fr/pylena/
+    """)
+
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("## Input")
+
+            img_input = gr.Image(type="numpy", image_mode="L", label="Greyscale input image")
+
+            with gr.Tab("Parameters"):
+                with gr.Tab("Tracking"):
+                    min_len = gr.Number(label="min_len", value=default_min_len)
+                    tracker = gr.Radio(label="tracker", choices=["KALMAN", "ONE_EURO", "DOUBLE_EXPONENTIAL", "LAST_INTEGRATION", "SIMPLE_MOVING_AVERAGE", "EXPONENTIAL_MOVING_AVERAGE"], value=default_tracker)
+                    traversal_mode = gr.Radio(label="traversal_mode", choices=["HORIZONTAL_VERTICAL", "HORIZONTAL", "VERTICAL"], value=default_traversal_mode)
+
+                with gr.Tab("Observation extraction"):
+                    blumi = gr.Number(label="blumi", value=default_blumi)
+                    llumi = gr.Number(label="llumi", value=default_llumi)
+                    max_thickness = gr.Number(label="max_thickness", value=default_max_thickness)
+
+                with gr.Tab("Discontinuity"):
+                    discontinuity_relative = gr.Number(label="discontinuity_relative", value=default_discontinuity_relative)
+                    discontinuity_absolute = gr.Number(label="discontinuity_absolute", value=default_discontinuity_absolute)
+
+            with gr.Tab("Advanced parameters"):
+                with gr.Tab("Preprocessing"):
+                    preprocess = gr.Radio(label="preprocess", choices=["NONE", "Black top hat"], value=default_preprocess)
+                    negate_image = gr.Checkbox(label="negate_image", value=default_negate_image)
+                    dyn = gr.Number(label="dyn", value=default_dyn)
+                    size_mask = gr.Number(label="size_mask", value=default_size_mask)
+
+                with gr.Tab("Tracker specific parameters"):
+                    double_exponential_alpha = gr.Number(label="double_exponential_alpha", value=default_double_exponential_alpha)
+                    simple_moving_average_memory = gr.Number(label="simple_moving_average_memory", value=default_simple_moving_average_memory)
+                    exponential_moving_average_memory = gr.Number(label="exponential_moving_average_memory", value=default_exponential_moving_average_memory)
+                    one_euro_beta = gr.Number(label="one_euro_beta", value=default_one_euro_beta)
+                    one_euro_mincutoff = gr.Number(label="one_euro_mincutoff", value=default_one_euro_mincutoff)
+                    one_euro_dcutoff = gr.Number(label="one_euro_dcutoff", value=default_one_euro_dcutoff)
+
+                with gr.Tab("Tracker parameters"):
+                    nb_values_to_keep = gr.Number(label="nb_values_to_keep", value=default_nb_values_to_keep)
+                    minimum_for_fusion = gr.Number(label="minimum_for_fusion", value=default_minimum_for_fusion)
+
+                with gr.Tab("Observation extraction"):
+                    extraction_type = gr.Radio(label="extraction_type", choices=["BINARY", "GRADIENT"], value="BINARY")
+                    gradient_threshold = gr.Number(label="gradient_threshold", value=default_gradient_threshold)
+
+                with gr.Tab("Observation matching"):
+                    default_sigma_position = gr.Number(label="default_sigma_position", value=default_default_sigma_position)
+                    default_sigma_thickness = gr.Number(label="default_sigma_thickness", value=default_default_sigma_thickness)
+                    default_sigma_luminosity = gr.Number(label="default_sigma_luminosity", value=default_default_sigma_luminosity)
+                    min_nb_values_sigma = gr.Number(label="min_nb_values_sigma", value=default_min_nb_values_sigma)
+                    sigma_pos_min = gr.Number(label="sigma_pos_min", value=default_sigma_pos_min)
+                    sigma_thickness_min = gr.Number(label="sigma_thickness_min", value=default_sigma_thickness_min)
+                    sigma_luminosity_min = gr.Number(label="sigma_luminosity_min", value=default_sigma_luminosity_min)
+
+                with gr.Tab("Extraction"):
+                    ratio_lum = gr.Number(label="ratio_lum", value=default_ratio_lum)
+
+                with gr.Tab("Post Processing"):
+                    threshold_intersection = gr.Number(label="threshold_intersection", value=default_threshold_intersection)
+                    remove_duplicates = gr.Checkbox(label="remove_duplicates", value=default_remove_duplicates)
+
+                with gr.Tab("Optimisation"):
+                    bucket_size = gr.Number(label="bucket_size", value=default_bucket_size)
+
+        with gr.Column():
+            gr.Markdown("## Output")
+
+            out_duration = gr.Number(label="Line detection duration (in seconds)", value=-1, interactive=False)
+
+            with gr.Tab("Output Vector"):
+                with gr.Tab("Over input"):
+                    out_vector_over_img = gr.Image(type="numpy", image_mode="RGB", interactive=False)
+                with gr.Tab("Line only"):
+                    out_vector_label_img = gr.Image(type="numpy", image_mode="RGB", interactive=False)
+                with gr.Tab("File"):
+                    out_vector_file = gr.File(label="Vector output full", interactive=False)
+                    out_vector_file_extract = gr.Json(label="Vector sample")
+
+            with gr.Tab("Output Pixel"):
+                with gr.Tab("Line and Superposition over input"):
+                    out_pixel_full_over_img = gr.Image(type="numpy", image_mode="RGB", interactive=False)
+                with gr.Tab("Line over input"):
+                    out_pixel_line_over_img = gr.Image(type="numpy", image_mode="RGB", interactive=False)
+                with gr.Tab("Superposition over input"):
+                    out_pixel_superposition_over_img = gr.Image(type="numpy", image_mode="RGB", interactive=False)
+                with gr.Tab("Line and Superposition"):
+                    out_pixel_full_img = gr.Image(type="numpy", image_mode="RGB", interactive=False)
+                with gr.Tab("Line only"):
+                    out_pixel_line_img = gr.Image(type="numpy", image_mode="RGB", interactive=False)
+                with gr.Tab("Superposition only"):
+                    out_pixel_superposition_img = gr.Image(type="numpy", image_mode="RGB", label="Labelized image")
+                with gr.Tab("File"):
+                    out_pixel_file_label = gr.File(label="Pixel output full", interactive=False)
+                    out_pixel_file_superposition = gr.File(label="Pixel output full", interactive=False)
+                    out_pixel_file_superposition_extract = gr.Json(label="Superposition sample")
+
+
+    run_button = gr.Button("Run")
+    run_button.click(
+        app_function,
+        inputs=[
+            img_input,
+            min_len,
+            preprocess,
+            tracker,
+            traversal_mode,
+            extraction_type,
+            negate_image,
+            dyn,
+            size_mask,
+            double_exponential_alpha,
+            simple_moving_average_memory,
+            exponential_moving_average_memory,
+            one_euro_beta,
+            one_euro_mincutoff,
+            one_euro_dcutoff,
+            bucket_size,
+            nb_values_to_keep,
+            discontinuity_relative,
+            discontinuity_absolute,
+            minimum_for_fusion,
+            default_sigma_position,
+            default_sigma_thickness,
+            default_sigma_luminosity,
+            min_nb_values_sigma,
+            sigma_pos_min,
+            sigma_thickness_min,
+            sigma_luminosity_min,
+            gradient_threshold,
+            llumi,
+            blumi,
+            ratio_lum,
+            max_thickness,
+            threshold_intersection,
+            remove_duplicates
+        ],
+        outputs=[
+            out_duration,
+
+            out_vector_over_img, out_vector_label_img,
+            out_vector_file, out_vector_file_extract,
+
+            out_pixel_full_over_img, out_pixel_line_over_img, out_pixel_superposition_over_img,
+            out_pixel_full_img, out_pixel_line_img, out_pixel_superposition_img,
+            out_pixel_file_label,
+            out_pixel_file_superposition, out_pixel_file_superposition_extract
+        ])
+
+
+    gr.Markdown("""
+        ## Examples
+                     
+        Be aware that parameters are not reset when you change example.
+    """)
+
+    current_dir = os.path.dirname(__file__)
+    with gr.Tab("trade_directory"):
+        gr.Examples(
+            examples=[[os.path.join(current_dir, "image", "trade_directories.png"), 200, 200, 200]],
+            inputs=[img_input, blumi, llumi, min_len]
+        )
+    with gr.Tab("music_sheet"):
+        gr.Examples(
+
+            examples=[[os.path.join(current_dir, "image", "music_sheet.png"), 30, 5, 20, "HORIZONTAL"]],
+            inputs=[img_input, discontinuity_relative, max_thickness, min_len, traversal_mode]
+        )
+    with gr.Tab("map"):
+        gr.Examples(
+            examples=[[os.path.join(current_dir, "image", "map.png"), 4, 180, 180, 20, 6]],
+            inputs=[img_input, discontinuity_relative, blumi, llumi, min_len, max_thickness]
+        )
+
+    gr.Markdown("""
+        ## A question ?
+
+        If you have any question, please contact us at: <philippe.bernet@epita.fr>             
+    """)
+
+# fmt: on
+
+app.launch()

requirements.txt

@@ -0,0 +1,3 @@
+numpy
+opencv-python
+pylena