initial commit

app.py

@@ -0,0 +1,125 @@
+import gradio as gr
+import improcess
+import numpy as np
+
+
+# Fonction pour choisir un filtre et l'appliquer
+def choose_filter(input_img, filter):
+    if input_img is None:
+        return None
+    match filter:
+        case "Gray Scale":
+            return improcess.gray_scale(input_img)
+        case "Gaussian Blur":
+            return improcess.gaussian_blur(input_img)
+        case "Binarize":
+            return improcess.binarize(input_img)
+        case "Negative":
+            return improcess.negative(input_img)
+
+
+# Fonction pour manipuler le contraste
+def handle_contrast(output_image, contrast: list):
+    if output_image is None:
+        return None
+    for trans in contrast:
+        if trans == "Dark Contrast":
+            output_image = improcess.log_trans(output_image)
+        elif trans == "White Contrast":
+            output_image = improcess.exp_trans(output_image)
+    return output_image
+
+
+# Fonction pour egaliser l'histogramme
+def equalize_hist(image, equalize):
+    if equalize == True:
+        return improcess.equalize(image)
+    return image
+
+
+def detect_feat(input_img, feature):
+    if input_img is None:
+        return None
+    match feature:
+        case "Edges":
+            input_img = improcess.find_edges(input_img)
+            return input_img
+        case "Contours":
+            input_img = improcess.find_contours(input_img)
+            return input_img
+
+
+# Fonction pour réinitialiser l'image
+def reset_img(input_img):
+    return input_img
+
+
+# Interface Gradio
+with gr.Blocks(theme="Zarkel/IBM_Carbon_Theme") as demo:
+    gr.Markdown(
+        """
+        # <p align="center">Image processing lab</p> 
+        """
+    )
+    with gr.Row():
+        input_img = gr.Image(
+            "profile.jpeg", label="Original image", scale=1, interactive=True
+        )
+        with gr.Group():
+            output_img = gr.Image(
+                "profile.jpeg", label="Transformed image", scale=2, interactive=False
+            )
+            btn = gr.Button(value="Reset")  # Bouton de réinitialisation
+    with gr.Row(variant="panel"):
+        with gr.Group():
+            equalize_img = gr.Checkbox(label="Equalize image")
+            gamma = gr.Slider(
+                minimum=0, maximum=1, label="Luminosity", interactive=True, value=0
+            )
+
+            contrast = gr.CheckboxGroup(
+                choices=["Dark Contrast", "White Contrast"], label="Contrast"
+            )
+            angle = gr.Slider(label="Rotation (deg)", minimum=0, maximum=360)
+        with gr.Group():
+            scale = gr.Slider(
+                minimum=0.1, maximum=1.5, value=1, label="Resize", info="Choose a scale"
+            )
+            filter = gr.Dropdown(
+                interactive=True,
+                label="Apply filter",
+                choices=["Gray Scale", "Binarize", "Negative", "Gaussian Blur"],
+            )
+            features = gr.Dropdown(
+                choices=["Contours", "Edges"],
+                interactive=True,
+                label="Extract feature",
+            )
+
+    # Mise à jour de l'image lorsqu'un filtre est appliqué
+    filter.change(fn=choose_filter, inputs=[input_img, filter], outputs=output_img)
+
+    # Mise à jour de l'image avec redimensionnement
+    scale.change(fn=improcess.resize, inputs=[input_img, scale], outputs=output_img)
+
+    # Bouton de réinitialisation de l'image
+    btn.click(fn=reset_img, inputs=[input_img], outputs=[output_img])
+
+    # Mise à jour de l'image avec correction de gamma
+    gamma.change(
+        fn=improcess.gamma_trans, inputs=[input_img, gamma], outputs=[output_img]
+    )
+
+    # Mise à jour de l'image avec contraste
+    contrast.change(
+        fn=handle_contrast, inputs=[output_img, contrast], outputs=output_img
+    )
+    # Egaliser l'histogramme de l'image
+    equalize_img.change(fn=equalize_hist, inputs=[input_img], outputs=[output_img])
+    # Effectuer une rotation de l'image
+    angle.change(fn=improcess.rotate, inputs=[input_img, angle], outputs=[output_img])
+
+    features.select(fn=detect_feat, inputs=[input_img, features], outputs=[output_img])
+# Lancer l'application
+if __name__ == "__main__":
+    demo.launch()

improcess.py

@@ -0,0 +1,112 @@
+import cv2 as cv
+import numpy as np
+from skimage import exposure
+from scipy import signal
+
+
+def resize(image: np.ndarray, scale: float = 1.0) -> np.ndarray:
+    """Fonction effectuant le changement d'échelle de l'image `image` selon le facteur `scale`
+        en utilisant l'interpolation linéaire.
+
+    Paramètre(s) d'entrée
+
+    image : ndarray
+        Image (niveaux de gris) d'un type reconnu par Python.
+    scale : float
+        Paramètre de changement d'échelle. Un nombre réel strictement positif
+
+    Paramètre(s) de sortie
+    ----------------------
+    im_resized : ndarray
+        Image interpolé àa la nouvelle échelle, de même type que `image`
+    """
+
+    new_height = int(image.shape[1] * scale)
+    new_width = int(image.shape[0] * scale)
+    new_shape = (new_height, new_width)
+
+    inter = cv.INTER_AREA if scale <= 1 else cv.INTER_LANCZOS4
+    im_resized = cv.resize(image, new_shape, interpolation=inter)
+
+    return im_resized.astype("uint8")
+
+
+def negative(image) -> np.ndarray:
+    neg_image = 255 - image
+    return neg_image.astype("uint8")
+
+
+def gray_scale(image):
+    return cv.cvtColor(image, cv.COLOR_RGB2GRAY).astype("uint8")
+
+
+def binarize(image) -> np.ndarray:
+    gray_img = gray_scale(image)
+    bin_image = np.where(gray_img > 128, 255, 0)
+    return bin_image.astype("uint8")
+
+
+def log_trans(image) -> np.ndarray:
+    c = 255 / np.log(1 + np.max(image))
+
+    log_img = c * np.log(image + 1)
+    return log_img.astype("uint8")
+
+
+def exp_trans(image) -> np.ndarray:
+    image = image.astype(np.float32)
+
+    normalized_img = image / 255.0
+
+    exp_img = np.exp(normalized_img) - 1
+
+    exp_img = 255 * exp_img / np.max(exp_img)
+
+    return exp_img.astype("uint8")
+
+
+def gamma_trans(image, gamma):
+    gamma *= 5
+    gamma = 5 - gamma
+    gamma_img = image / 255
+    gamma_img = np.power(gamma_img, gamma) * 225
+    return gamma_img.astype("uint8")
+
+
+def equalize(image):
+    return exposure.equalize_hist(image).astype("uint8")
+
+
+def gaussian_blur(image):
+    return cv.GaussianBlur(image, ksize=(5, 5), sigmaX=1.0).astype("uint8")
+
+
+def rotate(img, angle):
+    (height, width) = img.shape[:2]
+
+    rotPoint = (width // 2, height // 2)
+    rotMat = cv.getRotationMatrix2D(rotPoint, angle, 1.0)
+    dimensions = (width, height)
+    return cv.warpAffine(img, rotMat, dimensions)
+
+
+def find_contours(image):
+    gray_image = gray_scale(image)
+    _, thresh = cv.threshold(gray_image, 125, 255, cv.THRESH_BINARY)
+    contours, _ = cv.findContours(thresh, cv.RETR_LIST, cv.CHAIN_APPROX_NONE)
+    blank = np.zeros(image.shape, dtype="uint8")
+    contour_img = cv.drawContours(blank, contours, -1, (255, 255, 255), 2)
+    return contour_img
+
+
+def find_edges(image):
+    gray_image = gray_scale(image)
+    return cv.Canny(gray_image, 125, 175).astype("uint8")
+
+
+if __name__ == "__main__":
+    image = cv.imread("profile.jpeg")
+
+    cv.imshow("normal", image)
+    cv.imshow("Gamma", find_contours(image))
+    cv.waitKey(0)

requirements.txt

@@ -0,0 +1,4 @@
+gradio
+opencv-python-headless
+scikit-image
+numpy