added files

Corriger.py

@@ -0,0 +1,152 @@
+import streamlit as st
+from code.functions import pipeline_svg
+from PIL import Image
+import cv2
+import numpy as np
+from io import BytesIO
+import copy
+
+inch_value = 2.54
+
+logo = Image.open("seguinmoreau.png")
+st.set_page_config(
+    page_title="Moulinette Logos",
+    page_icon=logo,
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+st.markdown(
+    """
+    # Boîte à Outils de correction de logos :wrench:
+    
+    Bienvenue dans la boîte à outils de correction de logos de Seguin Moreau.
+    
+    ### :hammer: Les outils
+    Dans cette boîte à outils, vous trouverez:
+    * Un outil de Correction automatique de logo (enlever les petits défauts, lissage, vectorisation, grossissement des traits trop fins.
+    * Un outil de Vectorisation (image en pixels => image vectorisée => image en pixels).
+    
+    ### :bulb: Mode d'emploi
+    * Cliquer sur 'Browse files'
+    * Sélectionner un logo
+    * La correction est automatique. Si la correction ne vous convient pas, il est possible de régler les paramètres en cliquant sur 'Paramétrage' à droite de l'image.
+        * Les deux paramètres permettent de corriger les défauts liés à la présence de gris sur le logo ou la 'pixélisation' du logo trop importante.
+    
+    """
+)
+
+logo = Image.open('seguinmoreau.png')
+st.image(logo, width=100)
+
+uploaded_files = st.file_uploader("Choisir un logo", accept_multiple_files=True)
+
+image_width = 500
+size_value = st.slider("Largeur de trait minimum", min_value=1, max_value=21, value=7, step=2)
+
+size_value = (size_value - 1) // 2
+
+#kernel_type_str = st.selectbox("Kernel type", ["Ellipse", "Rectangle", "Cross"])
+kernel_type_str = "Ellipse"
+dict_kernel_type = {"Ellipse": cv2.MORPH_ELLIPSE, "Rectangle": cv2.MORPH_RECT, "Cross": cv2.MORPH_CROSS}
+kernel_type = dict_kernel_type[kernel_type_str]
+
+for uploaded_file in uploaded_files:
+    col1, col2, col3 = st.columns([1, 1, 1])
+    col3.markdown("---")
+
+    image = Image.open(uploaded_file).convert('L')
+    image_input = np.array(image)
+    image = copy.deepcopy(image_input)
+    col1.image(image_input/255.0, caption="Image d'entrée", use_column_width='auto')
+
+    with col3:
+        with st.expander(":gear: Paramétrage"):
+            st.write("Si l'image contient du gris, faire varier le seuil ci-dessous:")
+            threshold = st.slider("Seuil pour convertir l'image en noir&blanc.", min_value=0, max_value=255, value=0,
+                                    step=1, key=f"{uploaded_file}_slider_threshold")
+            st.write("Si l'image est pixelisée, ou contient trop de détails, "
+                     "augmenter la valeur ci-dessous:")
+            blur_value = st.slider("Seuil pour lisser l'image", min_value=1, max_value=11, value=1, step=2,
+                                   key=f"{uploaded_file}_slider_gaussian_sigma")
+            st.write("Si l'image contient des traits très fin (de l'odre du pixel),"
+                     " augmenter le seuil ci-dessous, de 1 par 1:")
+            dilate_lines_value = st.slider("Dilatation de l'image d'origine: (en pixels)", min_value=0, max_value=5, value=0, step=1,key=f"{uploaded_file}_slider_dilation_image")
+
+            st.write("Taille d'exportation d'image:")
+
+            dpi_value = st.number_input("Valeur dpi:", key=f"{uploaded_file}_number_dpi_value", value=200)
+            side_width_value = st.number_input("Taille max de côté cible (cm):", key=f"{uploaded_file}_number_target_value", value=20)
+            new_largest_side_value = int(side_width_value / inch_value * dpi_value)
+
+            h, w, *_ = image.shape
+
+            # Resize image
+            ratio = w / h
+            if ratio > 1:
+                width = new_largest_side_value
+                height = int(new_largest_side_value / ratio)
+            else:
+                height = new_largest_side_value
+                width = int(ratio * new_largest_side_value)
+
+            target_width_value = st.number_input("Largeur cible (cm):", key=f"{uploaded_file}_number_width_value", value=0)
+            target_height_value = st.number_input("Hauteur cible (cm):", key=f"{uploaded_file}_number_height_value", value=0)
+
+            if target_width_value > 0 and target_height_value == 0:
+                width = int(target_width_value / inch_value * dpi_value)
+                height = int(width / ratio)
+            elif target_height_value > 0 and target_width_value == 0:
+                height = int(target_height_value / inch_value * dpi_value)
+                width = int(height * ratio)
+            elif target_height_value > 0 and target_width_value > 0:
+                st.warning("Vous ne pouvez pas modifier la largeur et la hauteur simultanément.")
+
+    if threshold > 0:
+        image = (image > threshold)*255
+        image = image.astype('uint8')
+
+    if blur_value > 0:
+        image = cv2.GaussianBlur(image, (blur_value, blur_value), blur_value - 1)
+
+    # Process image cv32f ==> cv32f
+    img_final = pipeline_svg(image, size_value=size_value, level=1, threshold=threshold, kernel_type=kernel_type, dilate_lines_value=dilate_lines_value)
+
+    col2.image(img_final, caption="Image corrigée", use_column_width='auto')
+
+    # Check for grayscale
+    tolerance = 10
+    ratio_of_gray_pixels = int(np.sum((tolerance < image)* (image < 255 - tolerance))/np.size(image)*100)
+    if ratio_of_gray_pixels > 1:
+        col3.warning(f":warning: Le nombre de pixels gris est élevé: {ratio_of_gray_pixels} % > 1%")
+
+    # Check reconstruction fidelity
+    distance = np.mean((np.array(image) - img_final)**2)
+    if distance > 10:
+        col3.warning(f":warning: Le logo est peut-être trop dégradé (MSE={distance:.2f} > 10).\nVérifier visuellement.")
+
+
+
+    dim = (width, height)
+    # resize image
+    resized_img_final = cv2.resize(img_final, dim, interpolation=cv2.INTER_AREA)
+    resized_image_input = cv2.resize(image_input, dim, interpolation=cv2.INTER_AREA)
+
+    buf = BytesIO()
+    img_stacked = np.hstack((resized_image_input, resized_img_final))
+    img_final = Image.fromarray(img_stacked).convert("L")
+    img_final.save(buf, format="PNG")
+    byte_im= buf.getvalue()
+
+    btn = col3.download_button(
+        label=":inbox_tray: Télécharger l'image",
+        data=byte_im,
+        file_name=f"corrected_{uploaded_file.name}",
+        mime="image/png"
+    )
+
+
+
+
+
+

Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.9-slim
+
+EXPOSE 7860
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /moulinette
+COPY . .
+RUN echo $(ls -1 .. )
+
+RUN pip3 install -r requirements.txt
+
+ENTRYPOINT ["streamlit", "run", "Corriger.py", "--server.port=7860"]

README.md

@@ -1,10 +1,27 @@
----
-title: Moulinette
-emoji: 🔥
-colorFrom: indigo
-colorTo: red
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# moulinette
+moulinette
+
+
+#Command line svg to png
+inkscape -h 1468 -w 1576 imagea10.svg -o output.png --export-background-opacity=255
+
+# command line png to svg
+pip install potrace-cli
+potracer ../SMoreau/images/flower.png -b svg -o image.png
+
+# Or image j
+convert image10.svg -colorspace Gray output.png
+
+# Put to aws
+
+Follow
+https://itnext.io/run-your-containers-on-aws-fargate-c2d4f6a47fda
+Permission denied ==> use sudo.
+
+1/ build docker
+2/ push docker image on aws ECR (elastic container registery)
+
+Error in building the docker use
+https://stackoverflow.com/questions/72564830/python3-minimal-error-during-pip-installation-in-docker-build-permissionerro
+
+Il faut absolument ne pas être sudo pour docker !

code/functions.py

@@ -0,0 +1,145 @@
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+import os
+import cairosvg
+from potrace import POTRACE_CORNER, Path, Bitmap
+import io
+from PIL import Image, ImageStat
+
+import streamlit
+from PIL import Image
+
+@streamlit.cache_data
+def pipeline_svg(image_input, size_value, level=3, streamlit=False, threshold=0, kernel_type=cv2.MORPH_ELLIPSE, dilate_lines_value=0):
+    """
+    uint8 ==> uint8
+
+    Args:
+        streamlit:
+        size_value:
+        image_input:
+
+    Returns:
+
+    """
+
+    # Process image
+    image_processed = process_svg(image_input, size_value=size_value, streamlit=streamlit, kernel_type=kernel_type, dilate_lines_value=dilate_lines_value)
+
+    return image_processed
+
+def process_svg(img, size_value=12, level=1, streamlit=False, kernel_type=cv2.MORPH_ELLIPSE, dilate_lines_value=0):
+
+    image_path = "input_image.png"
+    img = img.astype('uint8')
+
+    # Lines very small
+    if dilate_lines_value > 0:
+        size = dilate_lines_value + 1 # No sens to dilate by one pixel (doesn't do anything).
+        kernel = get_kernel_ellipse(size, kernel_type=kernel_type)
+        img = cv2.erode(img, kernel, iterations=1)
+
+    cv2.imwrite(image_path, img)
+    img_array = convert_to_svg_and_back(img)
+
+    img_array = binarise(img_array)
+    img_bin = (255 - img_array)
+    img_bin = img_bin.astype('uint8')
+    image_already_added = np.zeros_like(img_bin)
+
+    target_min_size = max(1, size_value)
+
+    image_final = img_bin
+    for i in range(target_min_size+1):
+        size = 2 * i + 1
+        kernel = get_kernel_ellipse(size, kernel_type=kernel_type)
+
+        erosion = cv2.erode((img_bin - image_already_added), kernel, iterations=1)
+        dilation = cv2.dilate(erosion, kernel, iterations=1)
+
+        image_petits_objets = (img_bin - dilation)
+        image_petits_objets = remove_solo_pixels(image_petits_objets, kernel_size=3)
+
+        size = 2 * (target_min_size - i) + 1
+        kernel = get_kernel_ellipse(size, kernel_type=kernel_type)
+        dilate_image_petits_objets = cv2.dilate(image_petits_objets, kernel, iterations=1)
+
+        image_already_added = (image_already_added + image_petits_objets)
+
+        if i > level:
+            image_final = (image_final + dilate_image_petits_objets)
+
+    cv2.imwrite("image_finale.png", (255 - image_final))
+    image = convert_to_svg_and_back((255 - image_final))
+    return image
+def get_kernel_ellipse(size, kernel_type=cv2.MORPH_ELLIPSE):
+    list_coords = [size, size]
+    return cv2.getStructuringElement(kernel_type, (list_coords[0], list_coords[1]),
+                                     (int((list_coords[0] - 1) / 2), int((list_coords[1] - 1) / 2)))
+
+
+def binarise(img):
+    img = img > 200
+    img = img * 255
+    img = img.astype('uint8')
+    return img
+
+
+def imshow(title, image, vmin=0, vmax=1):
+    plt.figure()
+    plt.title(title)
+    plt.imshow(image * 255, vmin=vmin * 255, vmax=vmax * 255, cmap='gray')
+
+
+def remove_solo_pixels(image, kernel_size=3):
+    kernel = get_kernel_ellipse(kernel_size)
+
+    erosion = cv2.erode(image, kernel, iterations=1)
+    dilation = cv2.dilate(erosion, kernel, iterations=1)
+
+    dilation = dilation.astype('uint8')
+    return dilation
+
+def convert_to_svg_and_back(image_array) -> np.array:
+    image_pil = Image.fromarray(image_array)
+
+    bm = Bitmap(image_pil, blacklevel=0.5)
+
+    plist = bm.trace(
+        turdsize=2,
+        turnpolicy=4,
+        alphamax=1,
+        opticurve= False,
+        opttolerance=0.2)
+
+    image = backend_svg_no_file(image_pil, plist)
+
+    return np.array(image)
+
+def backend_svg_no_file(image, path: Path):
+    output = f'<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="{image.width}" height="{image.height}" viewBox="0 0 {image.width} {image.height}">'
+
+    parts = []
+    for curve in path:
+        fs = curve.start_point
+        parts.append("M%f,%f" % (fs.x, fs.y))
+        for segment in curve.segments:
+            if segment.is_corner:
+                a = segment.c
+                parts.append("L%f,%f" % (a.x, a.y))
+                b = segment.end_point
+                parts.append("L%f,%f" % (b.x, b.y))
+            else:
+                a = segment.c1
+                b = segment.c2
+                c = segment.end_point
+                parts.append("C%f,%f %f,%f %f,%f" % (a.x, a.y, b.x, b.y, c.x, c.y))
+        parts.append("z")
+    output += f'<path stroke="none" fill="#000000" fill-rule="evenodd" d="{"".join(parts)}"/>'
+
+    output += "</svg>"
+    # From svg to png (bytes)
+    image_data = cairosvg.surface.PNGSurface.convert(output)
+    image = Image.open(io.BytesIO(image_data)).split()[-1]
+    return image

requirements.txt

@@ -0,0 +1,8 @@
+matplotlib==3.4.1
+numpy==1.20.2
+opencv_python_headless==4.5.5.64
+Pillow==9.4.0
+scipy==1.6.2
+streamlit==1.20.0
+potracer==0.0.4
+cairosvg==2.7.0