Upload 3 files

app.py

@@ -0,0 +1,880 @@
+import streamlit as st
+import cv2
+import imutils
+from paddleocr import PaddleOCR, draw_ocr
+from PIL import Image
+import io
+import os
+import numpy as np
+import ast
+import operator
+import matplotlib.pyplot as plt
+
+st.set_page_config(
+    page_title='OpenCV Image processing', layout ="wide",
+    initial_sidebar_state="expanded",
+)
+os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
+
+st.markdown("""
+        <style>
+               .block-container {
+                    padding-top: 1rem;
+                    padding-bottom: 1rem;
+                    padding-left: 1rem;
+                    padding-right: 2rem;
+                }
+        </style>
+        """, unsafe_allow_html=True)
+
+###################################################################################################
+##   INITIALISATIONS
+###################################################################################################
+###
+@st.cache_data(show_spinner=True)
+def initializations():
+    print("Initializations ...")
+    out_dict_lang_ppocr = {'Abaza': 'abq', 'Adyghe': 'ady', 'Afrikaans': 'af', 'Albanian': 'sq', \
+    'Angika': 'ang', 'Arabic': 'ar', 'Avar': 'ava', 'Azerbaijani': 'az', 'Belarusian': 'be', \
+    'Bhojpuri': 'bho','Bihari': 'bh','Bosnian': 'bs','Bulgarian': 'bg','Chinese & English': 'ch', \
+    'Chinese Traditional': 'chinese_cht', 'Croatian': 'hr', 'Czech': 'cs', 'Danish': 'da', \
+    'Dargwa': 'dar', 'Dutch': 'nl', 'English': 'en', 'Estonian': 'et', 'French': 'fr', \
+    'German': 'german','Goan Konkani': 'gom','Hindi': 'hi','Hungarian': 'hu','Icelandic': 'is', \
+    'Indonesian': 'id', 'Ingush': 'inh', 'Irish': 'ga', 'Italian': 'it', 'Japan': 'japan', \
+    'Kabardian': 'kbd', 'Korean': 'korean', 'Kurdish': 'ku', 'Lak': 'lbe', 'Latvian': 'lv', \
+    'Lezghian': 'lez', 'Lithuanian': 'lt', 'Magahi': 'mah', 'Maithili': 'mai', 'Malay': 'ms', \
+    'Maltese': 'mt', 'Maori': 'mi', 'Marathi': 'mr', 'Mongolian': 'mn', 'Nagpur': 'sck', \
+    'Nepali': 'ne', 'Newari': 'new', 'Norwegian': 'no', 'Occitan': 'oc', 'Persian': 'fa', \
+    'Polish': 'pl', 'Portuguese': 'pt', 'Romanian': 'ro', 'Russia': 'ru', 'Saudi Arabia': 'sa', \
+    'Serbian(cyrillic)': 'rs_cyrillic', 'Serbian(latin)': 'rs_latin', 'Slovak': 'sk', \
+    'Slovenian': 'sl', 'Spanish': 'es', 'Swahili': 'sw', 'Swedish': 'sv', 'Tabassaran': 'tab', \
+    'Tagalog': 'tl', 'Tamil': 'ta', 'Telugu': 'te', 'Turkish': 'tr', 'Ukranian': 'uk', \
+    'Urdu': 'ur', 'Uyghur': 'ug', 'Uzbek': 'uz', 'Vietnamese': 'vi', 'Welsh': 'cy'}
+
+    out_dict_interpolation = {"INTER_LINEAR": cv2.INTER_LINEAR,
+                              "INTER_NEAREST": cv2.INTER_NEAREST,
+#                              "INTER_LINEAR_EXACT": cv2.INTER_LINEAR_EXACT,
+                              "INTER_AREA": cv2.INTER_AREA,
+                              "INTER_CUBIC": cv2.INTER_CUBIC,
+                              "INTER_LANCZOS4": cv2.INTER_LANCZOS4,
+#                              "INTER_NEAREST_EXACT": cv2.INTER_NEAREST_EXACT,
+#                              "INTER_MAX": cv2.INTER_MAX,
+#                              "WARP_FILL_OUTLIERS": cv2.WARP_FILL_OUTLIERS,
+#                              "WARP_INVERSE_MAP": cv2.WARP_INVERSE_MAP,
+                             }
+
+    out_dict_thresholding_type = {"THRESH_BINARY": cv2.THRESH_BINARY,
+                                  "THRESH_BINARY_INV": cv2.THRESH_BINARY_INV,
+                                  "THRESH_TRUNC": cv2.THRESH_TRUNC,
+                                  "THRESH_TOZERO": cv2.THRESH_TOZERO,
+                                 }
+
+    out_dict_adaptative_method = {"ADAPTIVE_THRESH_MEAN_C": cv2.ADAPTIVE_THRESH_MEAN_C,
+                                  "ADAPTIVE_THRESH_GAUSSIAN_C": cv2.ADAPTIVE_THRESH_GAUSSIAN_C}
+
+    return out_dict_lang_ppocr, out_dict_interpolation, out_dict_thresholding_type, out_dict_adaptative_method
+
+###################################################################################################
+##   FONTIONS
+###################################################################################################
+###
+@st.cache_data(show_spinner=False)
+def load_image(in_image_file):
+    """Load input file and open it
+    Args:
+        in_image_file (string or Streamlit UploadedFile): image to consider
+    Returns:
+        matrix      : input file opened with Opencv
+    """
+    #if isinstance(in_image_file, str):
+    #    out_image_path = "img."+in_image_file.split('.')[-1]
+    #else:
+    #    out_image_path = "img."+in_image_file.name.split('.')[-1]
+    if isinstance(in_image_file, str):
+        out_image_path = "tmp_"+in_image_file
+    else:
+        out_image_path = "tmp_"+in_image_file.name
+    img = Image.open(in_image_file)
+    img_saved = img.save(out_image_path)
+    # Read image
+#    out_image_orig = Image.open(out_image_path)
+    out_image_cv2 = cv2.cvtColor(cv2.imread(out_image_path), cv2.COLOR_BGR2RGB)
+
+    st.session_state.resize = False
+    st.session_state.scaling_factor = None
+    st.session_state.interpolation = None
+    st.session_state.rotate = None
+    st.session_state.angle = None
+    st.session_state.convolution = None
+    st.session_state.text_convol = None
+    st.session_state.convol_kernel = None
+    st.session_state.averaging = None
+    st.session_state.averaging_kernel_size = None
+    st.session_state.gaussian_bluring = None
+    st.session_state.gb_kernel_size = None
+    st.session_state.sigmaX = None
+    st.session_state.sigmaY = None
+    st.session_state.median_bluring = None
+    st.session_state.mb_kernel_size = None
+    st.session_state.bilateral_filtering = None
+    st.session_state.d = None
+    st.session_state.sigma_color = None
+    st.session_state.sigma_space = None
+    st.session_state.erosion = None
+    st.session_state.erosion_kernel_size = None
+    st.session_state.nb_iter_erosion = None
+    st.session_state.dilation = None
+    st.session_state.dilation_kernel_size = None
+    st.session_state.nb_iter_dilation = None
+    st.session_state.binarization = None
+    st.session_state.bin_thresh = None
+    st.session_state.bin_thresh = None
+    st.session_state.bin_thresholding_type = None
+    st.session_state.bin_otsu = None
+    st.session_state.thresh_typ = None
+    st.session_state.adaptative_thresh = None
+    st.session_state.at_thresholding_type = None
+    st.session_state.at_max_value = None
+    st.session_state.at_adaptative_method = None
+    st.session_state.at_block_size = None
+    st.session_state.at_const = None
+    st.session_state.processed_image = None
+
+    return out_image_cv2, out_image_path
+###
+def eval_expr(expr):
+    """Eval numeric expression
+    Args:
+        expr (string): numeric expression
+    Returns:
+       float: eval result
+    """
+    result = 1.
+    # Dictionnary of authorized operators
+    operators = {
+        ast.Add: operator.add,
+        ast.Sub: operator.sub,
+        ast.Mult: operator.mul,
+        ast.Div: operator.truediv,
+        ast.Pow: operator.pow,
+        ast.USub: operator.neg,
+    }
+    def _eval(node):
+        if isinstance(node, ast.Expression):
+            return _eval(node.body)
+        elif isinstance(node, ast.Constant):  # nombre
+            return node.value
+        elif isinstance(node, ast.BinOp):  # opérations binaires
+            return operators[type(node.op)](_eval(node.left), _eval(node.right))
+        elif isinstance(node, ast.UnaryOp):  # opérations unaires (-n)
+            return operators[type(node.op)](_eval(node.operand))
+        else:
+            raise TypeError(node)
+    try:
+        parsed = ast.parse(expr, mode='eval')
+        result = _eval(parsed.body)
+    except:
+        pass
+    return result
+###
+def text_kernel_to_latex(text_eval):
+    """Try to parse a kernel text description like: 1/6 * [[1,1],[1,1]]
+    Args:
+        text_eval (string): the string with the kernel expression
+    Returns:
+       string: left part of input string before *
+       list: right part of input string after *
+       string: latex expression corresponding to the text kernel input
+    """
+    list_eval = text_eval.split('*')
+    text_kernel = list_eval[-1].strip()
+    list_kernel = ast.literal_eval(text_kernel)
+    latex = "\\begin{bmatrix}\n"
+    for row in list_kernel:
+        latex += " & ".join(map(str, row)) + " \\\\\n"
+    latex += "\\end{bmatrix}"
+    text_coeff = 1.
+    latex_text = latex
+    if len(list_eval) > 1:
+        text_coeff = list_eval[0].strip()
+        latex_text = text_coeff + ' ' + latex
+    return text_coeff, list_kernel, latex_text
+###
+def get_img_fig(img):
+    """Plot image with matplotlib, in order to have image size
+    Args:
+        img (Image): Image to show
+    Returns:
+        Matplotlib figure
+    """
+    fig = plt.figure()
+    if len(img.shape) == 3:
+        plt.imshow(img, cmap=None)
+    else:
+        plt.imshow(img, cmap='gray')
+    return fig
+
+@st.fragment
+def show_latex(latex_code):
+    st.latex(latex_code)
+###################################################################################################
+##   STREAMLIT APP
+###################################################################################################
+st.title(''':orange[Image processing with OpenCV]''')
+st.write("")
+st.write("")
+st.write("")
+st.set_option("client.showErrorDetails", False)
+
+dict_lang_ppocr, dict_interpolation, dict_thresholding_type, dict_adaptative_method = initializations()
+
+cols = st.columns([0.25, 0.25, 0.5])
+cols[0].markdown("#### :orange[Choose picture:]")
+img_typ = cols[0].radio("#### :orange[Choose picture type:]", ['Upload file', 'Take a picture', 'Use a demo file'], \
+                            index=0)
+if img_typ == 'Upload file':
+    image_file = cols[1].file_uploader("Upload a file:", type=["png","jpg","jpeg"])
+
+if img_typ == 'Take a picture':
+    image_file = cols[1].camera_input("Take a picture:")
+if img_typ == 'Use a demo file':
+    image_file = 'img_demo_enhance.png'
+
+##----------- Process input image -----------------------------------------------------------------
+if image_file is not None:
+    img_cv2, image_path = load_image(image_file)
+
+    cols[2].markdown('#### :orange[Original image]')
+    cnt_img_ori = cols[2].container(height=300, border=False)
+    #cnt_img_ori.image(img_cv2) #, use_container_width=True)
+    cnt_img_ori.pyplot(get_img_fig(img_cv2))
+    col1, col2 = st.columns([0.5, 0.5]) #gap="medium")
+
+    col1.markdown('#### :orange[Processed image]')
+    list_op = []
+
+    if col1.checkbox("GrayScale"):
+        try:
+            img_first = cv2.cvtColor(img_cv2.copy(), cv2.COLOR_BGR2GRAY)
+            list_op.append("Grayscale")
+        except Exception as e:
+            st.exception(e)
+    else:
+        img_first = img_cv2.copy()
+
+    if col1.checkbox("Bit-wise inversion"):
+        try:
+            img_first = cv2.bitwise_not(img_first)
+            list_op.append("Bit-wise inversion")
+        except Exception as e:
+            st.exception(e)
+
+    # Processed image construction
+    cnt_img_wrk = col1.container(height=500, border=False)
+    img_processed = cnt_img_wrk.empty()
+    img_wrk = img_first.copy()
+
+    if st.session_state.resize:
+        try:
+            img_wrk = cv2.resize(img_wrk, None, fx=st.session_state.scaling_factor,
+                                 fy=st.session_state.scaling_factor,
+                                 interpolation=dict_interpolation[st.session_state.interpolation])
+            list_op.append("Resize - fx="+str(st.session_state.scaling_factor)+", fy="+
+                           str(st.session_state.scaling_factor)+", interpolation="+
+                           st.session_state.interpolation)
+        except Exception as e:
+            st.exception(e)
+
+    if st.session_state.rotate:
+        try:
+            img_wrk = imutils.rotate(img_wrk, angle=st.session_state.angle)
+            list_op.append("Rotate - angle="+str(st.session_state.angle))
+        except Exception as e:
+            st.exception(e)
+
+    if st.session_state.convolution:
+        try:
+            img_wrk = cv2.filter2D(src=img_wrk, ddepth=-1, kernel=st.session_state.convol_kernel)
+            list_op.append("Filtering - Custom 2D Convolution - kernel="+ st.session_state.text_convol)
+        except Exception as e:
+            st.exception(e)
+
+    if st.session_state.averaging:
+        try:
+            img_wrk = cv2.blur(src=img_wrk, ksize=st.session_state.averaging_kernel_size)
+            list_op.append("Filtering - Averaging - kernel_size="+
+                           str(st.session_state.averaging_kernel_size))
+        except Exception as e:
+            st.exception(e)
+
+    if  st.session_state.gaussian_bluring:
+        try:
+            img_wrk = cv2.GaussianBlur(src=img_wrk, ksize=st.session_state.gb_kernel_size, \
+                                    sigmaX=st.session_state.sigmaX, sigmaY=st.session_state.sigmaY)
+            list_op.append("Filtering - Gaussian Blurring - ksize="+ \
+                        str(st.session_state.gb_kernel_size)+", sigmaX="+
+                        str(st.session_state.sigmaX)+", sigmaY="+str(st.session_state.sigmaY))
+        except Exception as e:
+            st.exception(e)
+
+    if st.session_state.median_bluring:
+        try:
+            img_wrk = cv2.medianBlur(img_wrk, st.session_state.mb_kernel_size)
+            list_op.append("Filtering - Median Blurring - kernel_size="+ \
+                           str(st.session_state.mb_kernel_size))
+        except Exception as e:
+            st.exception(e)
+
+    if st.session_state.bilateral_filtering:
+        try:
+            img_wrk = cv2.bilateralFilter(img_wrk, st.session_state.d, st.session_state.sigma_color,
+                                         st.session_state.sigma_space)
+            list_op.append("Filtering - Bilateral Filtering - d="+ str(st.session_state.d)+
+                           ", sigma_color="+str(st.session_state.sigma_color)+ \
+                           ", sigma_space="+str(st.session_state.sigma_space))
+        except Exception as e:
+            st.exception(e)
+
+    if st.session_state.erosion:
+        try:
+            kernel = np.ones((st.session_state.erosion_kernel_size,
+                              st.session_state.erosion_kernel_size),
+                             np.uint8)
+            img_wrk = cv2.erode(img_wrk, kernel, iterations=st.session_state.nb_iter_erosion)
+            list_op.append("Erosion - kernel_size="+str(st.session_state.erosion_kernel_size)+ \
+                           ", iterations="+str(st.session_state.nb_iter_erosion))
+        except Exception as e:
+            st.exception(e)
+
+    if st.session_state.dilation:
+        try:
+            kernel = np.ones((st.session_state.dilation_kernel_size,
+                              st.session_state.dilation_kernel_size),
+                             np.uint8)
+            img_wrk = cv2.dilate(img_wrk, kernel, iterations=st.session_state.nb_iter_dilation)
+            list_op.append("Dilation - kernel_size="+str(st.session_state.dilation_kernel_size )+ \
+                           ", iterations="+str(st.session_state.nb_iter_dilation))
+        except Exception as e:
+            st.exception(e)
+
+    if st.session_state.binarization:
+        try:
+            ret, img_wrk = cv2.threshold(img_wrk, st.session_state.bin_thresh,
+                                         st.session_state.bin_value,
+                                         st.session_state.thresh_typ)
+            list_op.append("Thresholding - thresh="+str(st.session_state.bin_thresh)+ \
+                           ", maxval="+str(st.session_state.bin_value)+", type="+ \
+                           st.session_state.bin_thresholding_type+", otsu="+ \
+                           str(st.session_state.bin_otsu))
+        except Exception as e:
+            st.exception(e)
+
+    if st.session_state.adaptative_thresh:
+        try:
+            img_wrk = cv2.adaptiveThreshold(img_wrk, st.session_state.at_max_value,
+                                dict_adaptative_method[st.session_state.at_adaptative_method],
+                                dict_thresholding_type[st.session_state.at_thresholding_type],
+                                st.session_state.at_block_size, st.session_state.at_const)
+            list_op.append("Adaptative thresholding - maxValue="+
+                           str(st.session_state.at_max_value)+", adaptiveMethod="+
+                           st.session_state.at_adaptative_method+", thresholdType"+
+                           ", thresholding_type="+st.session_state.at_thresholding_type+
+                           ", blockSize="+str(st.session_state.at_block_size)+", C="+
+                           str(st.session_state.at_const))
+        except Exception as e:
+            st.exception(e)
+
+    # Show image
+    img_processed.pyplot(get_img_fig(img_wrk))
+    st.session_state.processed_image = img_wrk
+
+    # Process
+    col2.markdown('#### :orange[Check & enhance]')
+
+    with col2.expander(":blue[Image processing]", expanded=False):
+        tab1, tab2, tab3, tab4, tab5 = \
+                st.tabs(["Resize", "Rotate", "Filtering",
+                          "Morphologie", "Thresholding"])
+        with tab1: # Resize
+            with tab1.form("Resize parameters"):
+                st.session_state.scaling_factor = st.slider("Scaling factor :", 0.1, 20., 1., 0.1)
+                cols_tab1 = st.columns([0.1, 0.9], gap="medium", vertical_alignment="center")
+                cols_tab1[0].markdown("💬", help="""An interpolation function’s goal is
+        to examine neighborhoods of pixels and use these neighborhoods to optically increase or decrease
+        the size of the image without introducing distortions (or at least as few distortions
+        as possible).\n
+        ```cv2.INTER_LINEAR``` This option uses the bilinear interpolation algorithm. Unlike INTER_NEAREST,
+        this does the interpolation in two dimensions and predicts the function used to calculate the color
+        of a pixel. This algorithm is effective in handling visual distortions while zooming or
+        enlarging an image.\n
+        ```cv2.INTER_NEAREST``` This option uses the nearest neighbor interpolation algorithm. It retains
+        the sharpness of the edges though the overall image may be blurred.\n
+        ```cv2.INTER_LINEAR_EXACT```is a modification of ```INTER_LINEAR``` and both uses bilinear
+        interpolation algorithm. The only difference is that the calculations in ```INTER_LINEAR_EXACT```
+        are accurate to a bit.\n
+        ```cv2.INTER_AREA``` option uses resampling using pixel area relation technique. While enlarging
+        images, INTER_AREA work same as INTER_NEAREST. In other cases, ```INTER_AREA works``` better in
+        image decimation and avoiding false inference patterns in images (moire pattern).\n
+        ```cv2.INTER_CUBIC``` option uses bicubic interpolation technique. This is an extension of cubic
+        interpolation technique and is used for 2 dimension regular grid patterns.\n
+        ```cv2.INTER_LANCZOS4``` option uses Lanczos interpolation over 8 x 8 pixel neighborhood technique.
+        It uses Fourier series and Chebyshev polynomials and is suited for images with large number of
+        small size details.\n
+        ```cv2.INTER_NEAREST_EXACT ``` is a modification of INTER_NEAREST with bit level accuracy.\n
+        ```cv2.INTER_MAX ``` option uses mask for interpolation codes.\n
+        ```cv2.WARP_FILL_OUTLIERS ``` interpolation technique skips the outliers during interpolation calculations.\n
+        ```cv2.WARP_INVERSE_MAP ``` option uses inverse transformation technique for interpolation.\n""")
+                cols_tab1[0].link_button("📚", "https://opencv.org/blog/resizing-and-rescaling-images-with-opencv/#h-resizing-with-different-interpolation-methods")
+                st.session_state.interpolation = cols_tab1[1].selectbox("Interpolation method:",
+                                                            list(dict_interpolation.keys()))
+                c1, c2 = st.columns(2)
+                apply_tab1 = c1.toggle("Apply", help="Click here to indicate whether the operation should be carried out or not, then validate with Confirm.", key=1)
+                with c2:
+                    submit_tab1 = st.form_submit_button(":green[Confirm]")
+
+            if submit_tab1:
+                st.session_state.resize = apply_tab1
+                st.rerun()
+
+        with tab2: # Rotate
+            with tab2.form("Rotate parameters"):
+                st.session_state.angle = st.slider("Angle :", 0, 360, 0, step=10)
+                c1, c2 = st.columns(2)
+                apply_tab2 = c1.toggle("Apply", help="Click here to indicate whether the operation should be carried out or not, then validate with Confirm.", key=2)
+                with c2:
+                    submit_tab2 = st.form_submit_button(":green[Confirm]")
+
+            if submit_tab2:
+                st.session_state.rotate = apply_tab2
+                st.rerun()
+
+        with tab3: # Filtering
+            st.write("📚 :blue[*More about image filtering*]  👉  \
+                        [here](https://learnopencv.com/image-filtering-using-convolution-in-opencv/)")
+            selection = st.segmented_control("Filtering type",
+                                            ["Custom 2D Convolution", "Blurring"],
+                                            selection_mode="single")
+            match selection:
+                case "Custom 2D Convolution":
+                    with st.form("tab3_1"):
+                        st.write("📚 :blue[*More about convolution matrix*]  👉  \
+                                    [here](https://en.wikipedia.org/wiki/Kernel_(image_processing))")
+                        text_convol = st.text_input("Write your custom kernel here (example : 1/9 * [[1,1,1], [1,1,1], [1,1,1]]):",
+                                                    value=None)
+                        kernel = None
+                        if text_convol is not None:
+                            try:
+                                text_coeff, list_kernel, latex_code = text_kernel_to_latex(text_convol)
+                                coeff = eval_expr(text_coeff)
+                                kernel = coeff * np.array(list_kernel)
+                                show_latex(latex_code)
+                            except Exception as e:
+                                st.exception(e)
+                                text_convol = None
+                        else:
+                            text_coeff, list_kernel, latex_code = \
+                                        text_kernel_to_latex("1/9 * [[1,1,1], [1,1,1], [1,1,1]]")
+                            show_latex(latex_code)
+
+                        c1, c2 = st.columns(2)
+                        apply_tab31 = c1.toggle("Apply", help="Click here to indicate whether the operation should be carried out or not, then validate with Confirm.", key=3)
+                        with c2:
+                            submit_tab31 = st.form_submit_button(":green[Confirm]")
+
+                    if submit_tab31:
+                        st.session_state.convolution = apply_tab31
+                        st.session_state.text_convol = text_convol
+                        st.session_state.convol_kernel = kernel
+                        st.rerun()
+
+                case "Blurring":
+                    st.write("📚 :blue[*More about blurring techniques*]  👉  \
+                                [here](https://docs.opencv.org/4.x/d4/d13/tutorial_py_filtering.html)")
+                    b1, b2, b3, b4 = st.tabs(["Averaging", "Gaussian Blurring", "Median Blurring",
+                                        "Bilateral Filtering"])
+#                    typ_blurring = st.segmented_control("Bluring type",
+#                                        ["Averaging", "Gaussian Blurring", "Median Blurring",
+#                                        "Bilateral Filtering"],
+#                                        selection_mode="multi")
+
+                    with b1:
+                        with st.form("tab_32a"):
+                            st.markdown("💬 :green[Averaging?]",
+                                            help="This is done by convolving an image with a normalized box filter.\
+                                        It simply takes the average of all the pixels under the kernel \
+                                        area and replaces the central element."
+                                           )
+                            kernel_width = st.slider("Kernel size width:", 2, 20, None, 1)
+                            kernel_height = st.slider("Kernel size height:", 2, 20, None, 1)
+
+                            c1, c2 = st.columns(2)
+                            apply_tab32a = c1.toggle("Apply", help="Click here to indicate whether the operation should be carried out or not, then validate with Confirm.", key=4)
+                            with c2:
+                                submit_tab32a = st.form_submit_button(":green[Confirm]")
+
+                        if submit_tab32a:
+                            st.session_state.averaging = apply_tab32a
+                            st.session_state.averaging_kernel_size = (kernel_width, kernel_height)
+                            st.rerun()
+
+                    with b2:
+                        with st.form("tab_32b"):
+                            st.markdown("💬 :green[Gaussian Blurringing?]",
+                                                help="In this method, instead of a box filter, a Gaussian kernel is used. \
+    We should specify the width and height of the kernel which should be positive and odd. \
+    We also should specify the standard deviation in the X and Y directions, `sigmaX` and `sigmaY` respectively. \
+    If only `sigmaX` is specified, `sigmaY` is taken as the same as sigmaX. If both are given as zeros, they are \
+    calculated from the kernel size.\n \
+    Gaussian blurring is highly effective in removing Gaussian noise from an image.")
+                            kernel_width = st.slider("Kernel size width:", 2, 20, None, 1,)
+                            kernel_height = st.slider("Kernel size height:", 2, 20, None, 1)
+                            st.markdown("Standard deviations of the Gaussian kernel:",
+                                        help="""The parameters `sigmaX` and `sigmaY` represent the standard deviations
+                                                    of the Gaussian kernel in the horizontal (X) and vertical (Y) directions,
+                                                    respectively. These values control the extent of blurring applied to the image.​\n
+    **Typical Values for sigmaX and sigmaY:**
+    - Low values (e.g., 1–3): Apply a mild blur, useful for slight noise reduction while preserving image details.​
+    - Moderate values (e.g., 5–10): Produce a more noticeable blur, helpful for reducing more significant noise or smoothing out textures.
+    - High values (e.g., >10): Result in a strong blur, which can be used for artistic effects or to obscure details.​
+    It's common practice to set sigmaX and sigmaY to 0. In this case, OpenCV calculates the standard deviations based on the kernel size (ksize).
+    If only sigmaX is specified and sigmaY is set to 0, OpenCV uses the same value for both directions. ​\n
+    **Recommendations:**
+    - Specify sigmaX and sigmaY explicitly: For precise control over the blurring effect, define both parameters based on the desired outcome.​
+    - Use sigmaX = 0 and sigmaY = 0: To allow OpenCV to compute the standard deviations automatically from the kernel size.​
+    - Choose an appropriate kernel size: The ksize parameter should be a tuple of positive odd integers (e.g., (3, 3), (5, 5)).
+                        """)
+                            sigmaX = st.slider("sigmaX:", 0, 20, 0, 1)
+                            sigmaY = st.slider("sigmaY:", 0, 20, 0, 1)
+
+                            c1, c2 = st.columns(2)
+                            apply_tab32b = c1.toggle("Apply", help="Click here to indicate whether the operation should be carried out or not, then validate with Confirm.", key=5)
+                            with c2:
+                                submit_tab32b = st.form_submit_button(":green[Confirm]")
+
+                        if submit_tab32b:
+                            st.session_state.gaussian_bluring = apply_tab32b
+                            st.session_state.gb_kernel_size = (kernel_width, kernel_height)
+                            st.session_state.sigmaX = sigmaX
+                            st.session_state.sigmaY = sigmaY
+                            st.rerun()
+
+                    with b3:
+                        with st.form("tab_32c"):
+                            st.markdown("💬 :green[Median Blurring?]",
+                                            help="It takes the median of all the pixels under the \
+    kernel area and the central element is replaced with this median value.  Interestingly, in the above \
+    filters, the central element is a newly calculated value which may be a pixel value in the image or a new value. \
+    But in median blurring, the central element is always replaced by some pixel value in the image. \
+    It reduces the noise effectively. Its kernel size should be a positive odd integer.\n \
+    Median blurring is highly effective against salt-and-pepper noise in an image.")
+                            kernel_size = st.slider("Kernel size:", 3, 15, None, 2, key=101)
+
+                            c1, c2 = st.columns(2)
+                            apply_tab32c = c1.toggle("Apply", help="Click here to indicate whether the operation should be carried out or not, then validate with Confirm.", key=6)
+                            with c2:
+                                submit_tab32c = st.form_submit_button(":green[Confirm]")
+
+                        if submit_tab32c:
+                            st.session_state.median_bluring = apply_tab32c
+                            st.session_state.mb_kernel_size = kernel_size
+                            st.rerun()
+
+                    with b4:
+                        with st.form("tab_32d"):
+                            st.markdown("💬 :green[Bilateral Filtering?]",
+                                        help="It is highly effective in noise removal while \
+    keeping edges sharp. But the operation is slower compared to other filters. We already saw that a \
+    Gaussian filter takes the neighbourhood around the pixel and finds its Gaussian weighted average. \
+    This Gaussian filter is a function of space alone, that is, nearby pixels are considered while \
+    filtering. It doesn't consider whether pixels have almost the same intensity. It doesn't consider \
+    whether a pixel is an edge pixel or not. So it blurs the edges also, which we don't want to do.\n \
+    Bilateral filtering also takes a Gaussian filter in space, but one more Gaussian filter which is \
+    a function of pixel difference. \
+    The Gaussian function of space makes sure that only nearby pixels are considered for blurring, \
+    while the Gaussian function of intensity difference makes sure that only those pixels with similar \
+    intensities to the central pixel are considered for blurring. \
+    So it preserves the edges since pixels at edges will have large intensity variation.")
+                            st.markdown("Diameter of each pixel neighborhood that is used during filtering:",
+                                        help=""" **Effect:**\n
+    A larger `d` value means that more neighboring pixels are considered in the filtering process, leading to a more pronounced
+    blurring effect. Conversely, a smaller `d` focuses the filter on a tighter area, preserving more details.​
+    **Automatic Calculation:**\n
+    If `d` is set to a non-positive value (e.g., 0 or negative), OpenCV automatically calculates it based on the sigmaSpace parameter.
+    Specifically, the radius is computed as `radius = cvRound(sigmaSpace * 1.5)`, and then `d = radius * 2 + 1` to ensure it's an odd
+    number. This ensures that the kernel has a central pixel. ​
+    **Typical Values for `d`:**\n
+    The choice of d depends on the desired balance between noise reduction and edge preservation:​
+    - Small d (e.g., 5 to 9): Suitable for subtle smoothing while maintaining edge sharpness.​
+    - Medium d (e.g., 9 to 15): Offers a balance between noise reduction and detail preservation.​
+    - Large d (e.g., 15 and above): Provides stronger blurring, which may be useful for artistic effects but can lead to loss of
+    fine details.​
+    **Recommendations:**\n
+    - Large filters (d > 5) are very slow, so it is recommended to use `d=5` for real-time applications, and perhaps
+    `d=9` for offline applications that need heavy noise filtering.
+    - Start with Moderate Values: Begin with `d=9`, `sigmaColor=75`, and `sigmaSpace=75` as a baseline. Adjust these values based on
+    the specific requirements of your application.​
+    - Consider Image Size: For larger images, you might need to increase `d` to achieve a noticeable effect. Conversely,
+    for smaller images, a smaller `d` might suffice.​
+    - Balance with `sigmaColor` and `sigmaSpace`: Ensure that `d` is appropriately balanced with `sigmaColor` and
+    `sigmaSpace`. An excessively large `sigmaSpace` with a small `d` might not utilize the full potential of the spatial filtering.
+                                                """)
+                            d_value = st.slider("d:", 3, 15, None, 2)
+                            st.markdown("`sigmaColor` and `sigmaSpace`:", help="""
+    `sigmaColor`: This parameter defines the filter sigma in the color space. A larger value means that pixels with more significant
+    color differences will be mixed together, resulting in areas of semi-equal color.​
+    `sigmaSpace`: This parameter defines the filter sigma in the coordinate space. A larger value means that pixels farther apart
+    will influence each other as long as their colors are close enough.​\n
+    These parameters work together to ensure that the filter smooths the image while preserving edges.​
+    **Typical Values for `sigmaColor` and `sigmaSpace`:**\n
+    The choice of `sigmaColor` and `sigmaSpace` depends on the specific application and the desired effect.
+    However, some commonly used values are:​
+    - `sigmaColor`: Values around 75 are often used for general smoothing while preserving edges.​
+    - `sigmaSpace`: Similarly, values around 75 are typical for maintaining edge sharpness while reducing noise.​
+    For example, applying the bilateral filter with `d=9`, `sigmaColor=75`, and `sigmaSpace=75` is a common practice.
+    **Recommendations:**`\n
+    - Start with Equal Values: Setting `sigmaColor` and `sigmaSpace` to the same value (e.g., 75) is a good starting point.​
+    - Adjust Based on Results: If the image appears too blurred, reduce the values. If noise is still present, increase them.​
+    - Consider Image Characteristics: For images with high noise, higher values may be necessary. For images where edge preservation
+    is critical, lower values are preferable.""")
+                            sigma_color = st.slider("sigmaColor", 1, 255, None, 1)
+                            sigma_space = st.slider("sigmaSpace", 1, 255, None, 1)
+
+                            c1, c2 = st.columns(2)
+                            apply_tab32d = c1.toggle("Apply", help="Click here to indicate whether the operation should be carried out or not, then validate with Confirm.", key=7)
+                            with c2:
+                                submit_tab32d = st.form_submit_button(":green[Confirm]")
+
+                        if submit_tab32d:
+                            st.session_state.bilateral_filtering = apply_tab32d
+                            st.session_state.d = d_value
+                            st.session_state.sigma_color = sigma_color
+                            st.session_state.sigma_space = sigma_space
+                            st.rerun()
+
+        with tab4: # Morphologie
+            list_select = st.segmented_control("Morphological operation:",
+                                              ["Erosion", 'Dilation'],
+                                              selection_mode="multi")
+            if "Erosion" in list_select:
+                with st.form("tab_4a"):
+                    st.markdown("💬 :green[Erosion?]",
+                                    help="The basic idea of erosion is just like soil erosion only, it erodes \
+    away the boundaries of foreground object (Always try to keep foreground in white). \
+    So what it does? The kernel slides through the image (as in 2D convolution). A pixel in the \
+    original image (either 1 or 0) will be considered 1 only if all the pixels under the kernel is 1, \
+    otherwise it is eroded (made to zero). \n \
+    So what happends is that, all the pixels near boundary will be discarded depending upon the \
+    size of kernel. So the thickness or size of the foreground object decreases or simply white region \
+    decreases in the image. \n\
+    It is useful for removing small white noises, detach two connected objects etc. \n \
+    :orange[**Best practice :** convert to grayscale before apply erosion.]​")
+                    kernel_size_ero = st.slider("Kernel size:", 3, 21, 3, 2, key=102)
+                    nb_iter = st.slider('Iterations number:', 1, 7, 1, 1, key=201)
+
+                    c1, c2 = st.columns(2)
+                    apply_tab4a = c1.toggle("Apply", help="Click here to indicate whether the operation should be carried out or not, then validate with Confirm.", key=8)
+                    with c2:
+                        submit_tab4a = st.form_submit_button(":green[Confirm]")
+
+                if submit_tab4a:
+                    st.session_state.erosion = apply_tab4a
+                    st.session_state.erosion_kernel_size = kernel_size_ero
+                    st.session_state.nb_iter_erosion = nb_iter
+                    st.rerun()
+
+            if "Dilation" in list_select:
+                with st.form("tab_4b"):
+                    st.markdown("💬 :green[Dilation?]",
+                                    help="The opposite of an erosion is a dilation. Just like an \
+    erosion will eat away at the foreground pixels, a dilation will grow the foreground pixels. \
+    Dilations increase the size of foreground objects and are especially useful for joining broken \
+    parts of an image together. Dilations, just as an erosion, also utilize structuring elements \
+    — a center pixel p of the structuring element is set to white if ANY pixel in the structuring \
+    element is > 0. \n \
+    :orange[**Best practice :** convert to grayscale before apply dilation.]​")
+                    kernel_size_dil = st.slider("Kernel size:", 3, 21, 3, 2, key=103)
+                    nb_iter = st.slider('Iterations number:', 1, 7, 1, 1, key=202)
+                    kernel = np.ones((kernel_size_dil,kernel_size_dil),np.uint8)
+
+                    c1, c2 = st.columns(2)
+                    apply_tab4b = c1.toggle("Apply", help="Click here to indicate whether the operation should be carried out or not, then validate with Confirm.", key=9)
+                    with c2:
+                        submit_tab4b = st.form_submit_button(":green[Confirm]")
+
+                if submit_tab4b:
+                    st.session_state.dilation = apply_tab4b
+                    st.session_state.dilation_kernel_size = kernel_size_dil
+                    st.session_state.nb_iter_dilation = nb_iter
+                    st.rerun()
+
+        with tab5: # Thresholding
+            selection = st.segmented_control("Type:", ["Binarization", "Adaptative thresholding"])
+            match selection:
+                case "Binarization":
+                    with st.form("tab5_a"):
+                        st.markdown("💬 :green[What is thresholding?]",
+                                    help='''Thresholding is the binarization of an image. In general, we seek to
+                                            convert a grayscale image to a binary image, where the pixels are either
+                                            0 or 255.
+                                            A simple thresholding example would be selecting a threshold value T,
+                                            and then setting all pixel intensities less than T to 0, and all pixel
+                                            values greater than T to 255. In this way, we are able to create a binary
+                                            representation of the image.''')
+                        st.markdown("*:orange[⚠ Image must be in gray scale]*")
+                        cols_tab1 = st.columns([0.1, 0.9], gap="medium", vertical_alignment="center")
+                        with cols_tab1[1]:
+                            thresholding_type = cols_tab1[1].selectbox("Thresholding type:",
+                                                                    list(dict_thresholding_type.keys()))
+                            with cols_tab1[0].popover(":material/info:", help="Help on thresholding type",
+                                                    use_container_width=False):
+                                st.link_button("📚:blue[cf. OpenCV documentation :]",
+                                            "https://docs.opencv.org/3.0-beta/modules/imgproc/doc/miscellaneous_transformations.html#threshold")
+
+                        thresh = st.slider("Thresh :", 0, 255, 255, 1)
+                        if thresholding_type in ["cv.THRESH_BINARY", "cv.THRESH_BINARY_INV"]:
+                            value = st.slider("Value :", 0, 255, 255, 1)
+                        else:
+                            value = 255
+
+                        cols_tab3 = st.columns(2, gap="medium", vertical_alignment="center")
+                        otsu = cols_tab3[0].checkbox("Optimum Global Thresholding using Otsu’s Method?",
+                                                    help='''Otsu’s method tries to find a threshold value
+                                                        which minimizes the weighted within-class variance.
+                                                        Since Variance is the spread of the distribution
+                                                            about the mean. Thus, minimizing the within-class
+                                                            variance will tend to make the classes compact.''')
+                        cols_tab3[1].link_button("📚:blue[Documentation]",
+                                                "https://theailearner.com/2019/07/19/optimum-global-thresholding-using-otsus-method/")
+
+                        thresh_typ = dict_thresholding_type[thresholding_type]
+
+                        c1, c2 = st.columns(2)
+                        apply_tab5a = c1.toggle("Apply", help="Click here to indicate whether the operation should be carried out or not, then validate with Confirm.", key=10)
+                        with c2:
+                            submit_tab5a = st.form_submit_button(":green[Confirm]")
+
+                    if submit_tab5a:
+                        if otsu:
+                            thresh_typ = thresh_typ+cv2.THRESH_OTSU
+                        st.session_state.binarization = apply_tab5a
+                        st.session_state.bin_thresh = thresh
+                        st.session_state.bin_value = value
+                        st.session_state.bin_thresholding_type = thresholding_type
+                        st.session_state.bin_otsu = otsu
+                        st.session_state.thresh_typ = thresh_typ
+                        st.rerun()
+
+                case "Adaptative thresholding":
+                    with st.form("tab5_b"):
+                        st.markdown("💬 :green[What is adaptative thresholding?]",
+                                            help='''This is a usefull technique when dealing with images having non-uniform illumination.
+                                            In this, the threshold value is calculated separately for each pixel using
+                                            some statistics obtained from its neighborhood. This way we will get different thresholds
+                                            for different image regions and thus tackles the problem of varying illumination.''')
+                        st.markdown("*:orange[⚠ Image must be in gray scale]*")
+                        thresholding_type = st.selectbox("Thresholding type:",
+                                                        list(dict_thresholding_type.keys())[:2])
+                        max_value = st.slider("Max value :", 0, 255, 255, 1,
+                                              help="""This is the value assigned to the pixels after thresholding.
+                                                This depends on the thresholding type. If the type is cv2.THRESH_BINARY,
+                                                all the pixels greater than the threshold are assigned this maxValue.""")
+                        adaptative_method = st.selectbox("Adaptative method:",
+                                                         list(dict_adaptative_method.keys()),
+                                                         help="""This tells us how the threshold is calculated from the pixel neighborhood.
+                This currently supports two methods:
+                - cv2.ADAPTIVE_THRESH_MEAN_C: In this, the threshold value is the mean of the neighborhood area.\n
+                - cv2.ADAPTIVE_THRESH_GAUSSIAN_C: In this, the threshold value is the weighted sum of the
+                neighborhood area. This uses Gaussian weights computed using getGaussiankernel() method.""")
+                        block_size = st.slider("Block size:", 3, 21, 3, 2,
+                                               help='''**🔍 What is blockSize?**\n
+                In adaptive thresholding, the threshold for each pixel is determined based on a local neighborhood around it.
+                The blockSize parameter specifies the size of this neighborhood.
+                Specifically, it defines the dimensions of the square region (of size blockSize × blockSize) centered on the pixel being processed.
+                The threshold is then calculated based on the pixel values within this region.​\n
+                **✅ Acceptable Values for blockSize**\n
+                Must be an odd integer greater than 1: This ensures that the neighborhood has a central pixel.​
+                Common choices: 3, 5, 7, 9, 11, 13, 15, etc.​
+                Even numbers are invalid: Using an even blockSize (e.g., 2, 4, 6) would result in an error because
+                there would be no central pixel in the neighborhood.​\n
+                **🎯 Impact of blockSize on Thresholding**\n
+                Smaller blockSize (e.g., 3 or 5):​\n
+                - Captures fine details and small variations in illumination.​
+                - May be more sensitive to noise.​\n
+                Larger blockSize (e.g., 15 or 21):​\n
+                - Provides smoother thresholding, reducing the effect of noise.​
+                - Might overlook small features or details.
+
+                Choosing the appropriate blockSize depends on the specific characteristics of your image and the details you wish to preserve or suppress.''')
+                        const = st.slider("C:", -10, 20, 0, 1,
+                                          help='''The parameter C serves as a constant subtracted from the computed mean or weighted mean of the
+                                                    neighborhood pixels. This subtraction fine-tunes the thresholding process, allowing for better control
+                                                    over the binarization outcome.
+                **🎯 Typical Values for C**
+                The optimal value for C varies depending on the image's characteristics, such as lighting conditions and noise levels. Commonly used values include:​
+                - 2 to 10: These values are often effective for standard images with moderate lighting variations.​
+                - Higher values (e.g., 15 or 20): Useful for images with significant noise or when a more aggressive thresholding is needed.​
+                - Negative values: Occasionally used to make the thresholding more lenient, capturing lighter details that might otherwise be missed.​
+
+                It's advisable to experiment with different C values to determine the most suitable one for your specific application. ''')
+
+                        c1, c2 = st.columns(2)
+                        apply_tab5b = c1.toggle("Apply", help="Click here to indicate whether the operation should be carried out or not, then validate with Confirm.", key=11)
+                        with c2:
+                            submit_tab5b = st.form_submit_button(":green[Confirm]")
+
+                    if submit_tab5b:
+                        st.session_state.adaptative_thresh = apply_tab5b
+                        st.session_state.at_max_value = max_value
+                        st.session_state.at_adaptative_method = adaptative_method
+                        st.session_state.at_thresholding_type = thresholding_type
+                        st.session_state.at_block_size = block_size
+                        st.session_state.at_const = const
+                        st.rerun()
+
+    col1_a, col1_b = col1.columns(2)
+    if col1_a.button("📃 :blue[List of operations]"):
+        col1_a.write(list_op)
+
+    if col1_b.button("Prepare download"):
+        if len(img_wrk.shape) == 2:
+            pil_img = Image.fromarray(img_wrk).convert("L")
+        else:
+            img_rgb = cv2.cvtColor(img_wrk, cv2.COLOR_BGR2RGB)
+            pil_img = Image.fromarray(img_rgb)
+        img_bytes = io.BytesIO()
+        pil_img.save(img_bytes, format='PNG')
+        img_bytes.seek(0)
+        col1_b.download_button(
+            label="Download processed image",
+            data=img_bytes,
+            file_name="processed_image.png",
+            on_click="ignore",
+            icon=":material/download:",
+            mime="image/png"
+        )
+
+    with col2.expander(":blue[Quick overview of OCR recognition (with PPOCR)]", expanded=True):
+        with st.form("form1"):
+            key_ppocr_lang = st.selectbox("Choose language: :", dict_lang_ppocr.keys(), 20)
+            res_cnt = st.empty()
+            submit_detect = st.form_submit_button("Launch overview")
+
+        ##----------- Process OCR --------------------------------------------------------------
+        if submit_detect:
+            with res_cnt, st.spinner("PPOCR initialization ..."):
+                ocr = PaddleOCR(lang=dict_lang_ppocr[key_ppocr_lang]) #, show_log=False)
+            with res_cnt, st.spinner("OCR process ..."):
+                result = ocr.ocr(img_wrk)
+            # draw result
+            result = result[0]
+            if len(img_wrk.shape) == 3:
+                image = img_wrk.copy()
+            else:
+                image = cv2.cvtColor(img_wrk, cv2.COLOR_GRAY2RGB)
+            boxes = [line[0] for line in result]
+
+            txts = [line[1][0] for line in result]
+            scores = [line[1][1] for line in result]
+            im_show = draw_ocr(image, boxes, txts, scores, font_path='./fonts/french.ttf')
+            im_show = Image.fromarray(im_show)
+            res_cnt.image(im_show, use_container_width=True)

requirements.txt

@@ -0,0 +1,7 @@
+streamlit==1.43.0
+opencv-python-headless==4.9.0.80
+Pillow
+paddleocr==2.8.0
+paddlepaddle==2.6.0
+numpy #==1.23.4
+imutils