Upload 26 files

.gitattributes

@@ -32,3 +32,16 @@ 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
+fonts/arabic.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/chinese_cht.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/french.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/german.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/hindi.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/japan.ttc filter=lfs diff=lfs merge=lfs -text
+fonts/kannada.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/korean.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/nepali.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/simfang.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/spanish.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/tamil.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/telugu.ttf filter=lfs diff=lfs merge=lfs -text

Home.py

@@ -1,17 +1,33 @@
-import streamlit as st
-from multipage import MultiPage
-from app_pages import home, about, ocr_comparator
-
-app = MultiPage()
-st.set_page_config(
-    page_title='OCR Comparator', layout ="wide",
-    initial_sidebar_state="expanded",
-)
-
-# Add all your application here
-app.add_page("Home", "house", home.app)
-app.add_page("About", "info-circle", about.app)
-app.add_page("App", "cast", ocr_comparator.app)
-
-# The main app
-app.run()
+import streamlit as st
+#from multipage import MultiPage
+#from app_pages import home, about, ocr_comparator, enhance
+#from mmocr.utils.ocr import MMOCR
+import os
+os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
+
+st.set_page_config(
+    page_title='OCR Comparator', layout ="wide",
+    initial_sidebar_state="expanded",
+)
+
+# https://fonts.google.com/icons?icon.set=Material+Symbols&icon.style=Rounded&selected=Material+Symbols+Rounded:info:FILL@0;wght@400;GRAD@0;opsz@24&icon.query=info&icon.size=24&icon.color=%235f6368
+
+st.markdown("""
+        <style>
+               .block-container {
+                    padding-top: 1rem;
+                    padding-bottom: 1rem;
+                    padding-left: 1rem;
+                    padding-right: 2rem;
+                }
+        </style>
+        """, unsafe_allow_html=True)
+
+page1 = st.Page("home_page.py", title="Home", icon=":material/home:")
+page2 = st.Page("about.py", title="About", icon=":material/info:")
+page3 = st.Page("enhance.py", title="Image processing", icon=":material/edit_square:")
+page4 = st.Page("ocr_comparator.py", title="OCR Comparator", icon=":material/smart_display:")
+
+pg = st.navigation([page1, page2, page3, page4])
+
+pg.run()

about.py

@@ -0,0 +1,66 @@
+import streamlit as st
+import os
+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)
+
+st.markdown('''#### :orange[OCR solutions comparator]''')
+st.write("")
+lib = "This application's tab allows you to compare, from a given image, the results of different solutions:  \n*EasyOcr, PaddleOCR, MMOCR, Tesseract*"
+st.markdown(lib)
+
+with st.expander("See details:"):
+    st.markdown(''' The 1st step is to choose the language for the text recognition (not all solutions \
+    support the same languages), and then choose the picture to consider. It is possible to upload a file, \
+    to take a picture, or to use a demo file. \
+    It is then possible to change the default values for the text area detection process, \
+    before launching the detection task for each solution.\n
+    The different results are then presented.
+
+    The 2nd step is to choose one of these \
+    detection results, in order to carry out the text recognition process there. It is also possible to change \
+    the default settings for each solution.''')
+    st.write("")
+    st.markdown("###### The recognition results appear in 2 formats:")
+    st.markdown(''' - a visual format resumes the initial image, replacing the detected areas with \
+    the recognized text. The background is + or - strongly colored in green according to the \
+    confidence level of the recognition.
+        A slider allows you to change the font size, another \
+    allows you to modify the confidence threshold above which the text color changes: if it is at \
+    70% for example, then all the texts with a confidence threshold higher or equal to 70 will appear \
+    in white, in black otherwise.''')
+    st.markdown(" - a detailed format presents the results in a table, for each text box detected. \
+    It is possible to download this results in a local csv file.")
+
+
+st.markdown('-----')
+
+
+lib = "But, :orange[before evaluating OCR solutions], you may want to verify that the image is \
+       of sufficient quality for an OCR task. And if it isn't, you might want to be able to \
+       improve its quality.\n This is what the application's tab 'Image processing' allows you to do."
+st.markdown(lib)
+
+st.markdown('''#### :orange[Image quality verification and improvement]''')
+with st.expander("See details:", expanded=True):
+    st.write('''Here, you can run a recognition test with basic PPOCR. This displays the text areas \
+             detected in the image, along with their values and probabilities.''')
+    st.markdown('The **Image Processing** tab offers several operations: resize, rotate, filtering, \
+             morphological transformations, and thresholding.')
+    st.write('Special care has been taken to document the various operations, including links to \
+             documentation and explanatory pop-ups for the various parameters:')
+    st.image("doc.png", width=500)
+    st.markdown('For each operation, you can choose whether or not to apply the transformation \
+                to the image being processed using the **"Apply"** toggle.')
+    st.markdown('When the result is satisfactory, you can view a detailed list of the various \
+                operations performed on the original image using the **"List of operations"** button.')
+    st.markdown('Finally, you can download the resulting image.')

enhance.py

@@ -0,0 +1,874 @@
+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
+
+
+os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
+
+st.markdown("""
+    <style>
+        .main > div:first-of-type {
+            padding: 1em 2em 2em 2em;
+        }
+    </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 check and enhance for OCR task]''')
+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)

fonts/arabic.ttf

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

fonts/chinese_cht.ttf

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

fonts/french.ttf

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

fonts/german.ttf

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

fonts/hindi.ttf

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

fonts/japan.ttc

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

fonts/kannada.ttf

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

fonts/korean.ttf

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

fonts/nepali.ttf

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

fonts/simfang.ttf

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

fonts/spanish.ttf

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

fonts/tamil.ttf

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

fonts/telugu.ttf

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

ocr_comparator.py

@@ -0,0 +1,1301 @@
+"""This Streamlit app allows you to compare, from a given image, the results of different solutions:
+   EasyOcr, PaddleOCR, MMOCR, Tesseract
+"""
+
+#import mim
+#
+#mim.install(['mmengine>=0.7.1,<1.1.0'])
+#mim.install(['mmcv>=2.0.0rc4,<2.1.0'])
+#mim.install(['mmdet>=3.0.rc5,<3.2.0'])
+#mim.install(['mmocr'])
+
+import streamlit as st
+import plotly.express as px
+import numpy as np
+import math
+import pandas as pd
+from time import sleep
+
+import cv2
+from PIL import Image, ImageColor
+import PIL
+import easyocr
+from paddleocr import PaddleOCR
+#from mmocr.utils.ocr import MMOCR
+import pytesseract
+from pytesseract import Output
+import os
+from mycolorpy import colorlist as mcp
+
+import os
+os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
+###################################################################################################
+##   MAIN
+###################################################################################################
+#def app():
+
+###################################################################################################
+##   FUNCTIONS
+###################################################################################################
+@st.cache_data
+def convert_df(in_df):
+    """Convert data frame function, used by download button
+    Args:
+        in_df (data frame): data frame to convert
+    Returns:
+        data frame: converted data frame
+    """
+    # IMPORTANT: Cache the conversion to prevent computation on every rerun
+    return in_df.to_csv().encode('utf-8')
+###
+def easyocr_coord_convert(in_list_coord):
+    """Convert easyocr coordinates to standard format used by others functions
+    Args:
+        in_list_coord (list of numbers): format [x_min, x_max, y_min, y_max]
+    Returns:
+        list of lists: format [ [x_min, y_min], [x_max, y_min], [x_max, y_max], [x_min, y_max] ]
+    """
+    coord = in_list_coord
+    return [[coord[0], coord[2]], [coord[1], coord[2]], [coord[1], coord[3]], [coord[0], coord[3]]]
+###
+@st.cache_data
+def initializations():
+    """Initializations for the app
+    Returns:
+        list of strings : list of OCR solutions names
+                        (['EasyOCR', 'PPOCR', 'MMOCR', 'Tesseract'])
+        dict            : names and indices of the OCR solutions
+                        ({'EasyOCR': 0, 'PPOCR': 1, 'MMOCR': 2, 'Tesseract': 3})
+        list of dicts   : list of languages supported by each OCR solution
+        list of int     : columns for recognition details results
+        dict            : confidence color scale
+        plotly figure   : confidence color scale figure
+    """
+    # the readers considered
+    #out_reader_type_list = ['EasyOCR', 'PPOCR', 'MMOCR', 'Tesseract']
+    #out_reader_type_dict = {'EasyOCR': 0, 'PPOCR': 1, 'MMOCR': 2, 'Tesseract': 3}
+    out_reader_type_list = ['EasyOCR', 'PPOCR', 'Tesseract']
+    out_reader_type_dict = {'EasyOCR': 0, 'PPOCR': 1, 'Tesseract': 2}
+    # Columns for recognition details results
+    out_cols_size = [2] + [2,1]*(len(out_reader_type_list)-1) # Except Tesseract
+    # Dicts of laguages supported by each reader
+    out_dict_lang_easyocr = {'Abaza': 'abq', 'Adyghe': 'ady', 'Afrikaans': 'af', 'Angika': 'ang', \
+    'Arabic': 'ar', 'Assamese': 'as', 'Avar': 'ava', 'Azerbaijani': 'az', 'Belarusian': 'be', \
+    'Bulgarian': 'bg', 'Bihari': 'bh', 'Bhojpuri': 'bho', 'Bengali': 'bn', 'Bosnian': 'bs', \
+    'Simplified Chinese': 'ch_sim', 'Traditional Chinese': 'ch_tra', 'Chechen': 'che', \
+    'Czech': 'cs', 'Welsh': 'cy', 'Danish': 'da', 'Dargwa': 'dar', 'German': 'de', \
+    'English': 'en', 'Spanish': 'es', 'Estonian': 'et', 'Persian (Farsi)': 'fa', 'French': 'fr', \
+    'Irish': 'ga', 'Goan Konkani': 'gom', 'Hindi': 'hi', 'Croatian': 'hr', 'Hungarian': 'hu', \
+    'Indonesian': 'id', 'Ingush': 'inh', 'Icelandic': 'is', 'Italian': 'it', 'Japanese': 'ja', \
+    'Kabardian': 'kbd', 'Kannada': 'kn', 'Korean': 'ko', 'Kurdish': 'ku', 'Latin': 'la', \
+    'Lak': 'lbe', 'Lezghian': 'lez', 'Lithuanian': 'lt', 'Latvian': 'lv', 'Magahi': 'mah', \
+    'Maithili': 'mai', 'Maori': 'mi', 'Mongolian': 'mn', 'Marathi': 'mr', 'Malay': 'ms', \
+    'Maltese': 'mt', 'Nepali': 'ne', 'Newari': 'new', 'Dutch': 'nl', 'Norwegian': 'no', \
+    'Occitan': 'oc', 'Pali': 'pi', 'Polish': 'pl', 'Portuguese': 'pt', 'Romanian': 'ro', \
+    'Russian': 'ru', 'Serbian (cyrillic)': 'rs_cyrillic', 'Serbian (latin)': 'rs_latin', \
+    'Nagpuri': 'sck', 'Slovak': 'sk', 'Slovenian': 'sl', 'Albanian': 'sq', 'Swedish': 'sv', \
+    'Swahili': 'sw', 'Tamil': 'ta', 'Tabassaran': 'tab', 'Telugu': 'te', 'Thai': 'th', \
+    'Tajik': 'tjk', 'Tagalog': 'tl', 'Turkish': 'tr', 'Uyghur': 'ug', 'Ukranian': 'uk', \
+    'Urdu': 'ur', 'Uzbek': 'uz', 'Vietnamese': 'vi'}
+    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_lang_mmocr = {'English & Chinese': 'en'}
+    out_dict_lang_tesseract = {'Afrikaans': 'afr','Albanian': 'sqi','Amharic': 'amh', \
+    'Arabic': 'ara', 'Armenian': 'hye','Assamese': 'asm','Azerbaijani - Cyrilic': 'aze_cyrl', \
+    'Azerbaijani': 'aze', 'Basque': 'eus','Belarusian': 'bel','Bengali': 'ben','Bosnian': 'bos', \
+    'Breton': 'bre', 'Bulgarian': 'bul','Burmese': 'mya','Catalan; Valencian': 'cat', \
+    'Cebuano': 'ceb', 'Central Khmer': 'khm','Cherokee': 'chr','Chinese - Simplified': 'chi_sim', \
+    'Chinese - Traditional': 'chi_tra','Corsican': 'cos','Croatian': 'hrv','Czech': 'ces', \
+    'Danish':'dan','Dutch; Flemish':'nld','Dzongkha':'dzo','English, Middle (1100-1500)':'enm', \
+    'English': 'eng','Esperanto': 'epo','Estonian': 'est','Faroese': 'fao', \
+    'Filipino (old - Tagalog)': 'fil','Finnish': 'fin','French, Middle (ca.1400-1600)': 'frm', \
+    'French': 'fra','Galician': 'glg','Georgian - Old': 'kat_old','Georgian': 'kat', \
+    'German - Fraktur': 'frk','German': 'deu','Greek, Modern (1453-)': 'ell','Gujarati': 'guj', \
+    'Haitian; Haitian Creole': 'hat','Hebrew': 'heb','Hindi': 'hin','Hungarian': 'hun', \
+    'Icelandic': 'isl','Indonesian': 'ind','Inuktitut': 'iku','Irish': 'gle', \
+    'Italian - Old': 'ita_old','Italian': 'ita','Japanese': 'jpn','Javanese': 'jav', \
+    'Kannada': 'kan','Kazakh': 'kaz','Kirghiz; Kyrgyz': 'kir','Korean (vertical)': 'kor_vert', \
+    'Korean': 'kor','Kurdish (Arabic Script)': 'kur_ara','Lao': 'lao','Latin': 'lat', \
+    'Latvian':'lav','Lithuanian':'lit','Luxembourgish':'ltz','Macedonian':'mkd','Malay':'msa', \
+    'Malayalam': 'mal','Maltese': 'mlt','Maori': 'mri','Marathi': 'mar','Mongolian': 'mon', \
+    'Nepali': 'nep','Norwegian': 'nor','Occitan (post 1500)': 'oci', \
+    'Orientation and script detection module':'osd','Oriya':'ori','Panjabi; Punjabi':'pan', \
+    'Persian':'fas','Polish':'pol','Portuguese':'por','Pushto; Pashto':'pus','Quechua':'que', \
+    'Romanian; Moldavian; Moldovan': 'ron','Russian': 'rus','Sanskrit': 'san', \
+    'Scottish Gaelic': 'gla','Serbian - Latin': 'srp_latn','Serbian': 'srp','Sindhi': 'snd', \
+    'Sinhala; Sinhalese': 'sin','Slovak': 'slk','Slovenian': 'slv', \
+    'Spanish; Castilian - Old': 'spa_old','Spanish; Castilian': 'spa','Sundanese': 'sun', \
+    'Swahili': 'swa','Swedish': 'swe','Syriac': 'syr','Tajik': 'tgk','Tamil': 'tam', \
+    'Tatar':'tat','Telugu':'tel','Thai':'tha','Tibetan':'bod','Tigrinya':'tir','Tonga':'ton', \
+    'Turkish': 'tur','Uighur; Uyghur': 'uig','Ukrainian': 'ukr','Urdu': 'urd', \
+    'Uzbek - Cyrilic': 'uzb_cyrl','Uzbek': 'uzb','Vietnamese': 'vie','Welsh': 'cym', \
+    'Western Frisian': 'fry','Yiddish': 'yid','Yoruba': 'yor'}
+    out_list_dict_lang = [out_dict_lang_easyocr, out_dict_lang_ppocr, \
+                          #out_dict_lang_mmocr, \
+                        out_dict_lang_tesseract]
+    # Initialization of detection form
+    if 'columns_size' not in st.session_state:
+        st.session_state.columns_size = [2] + [1 for x in out_reader_type_list[1:]]
+    if 'column_width' not in st.session_state:
+        st.session_state.column_width = [400] + [300 for x in out_reader_type_list[1:]]
+    if 'columns_color' not in st.session_state:
+        st.session_state.columns_color = ["rgb(228,26,28)"] + \
+                                        ["rgb(79, 43, 255)" for x in out_reader_type_list[1:]]
+    if 'list_coordinates' not in st.session_state:
+        st.session_state.list_coordinates = []
+    # Confidence color scale
+    out_list_confid = list(np.arange(0,101,1))
+    out_list_grad = mcp.gen_color_normalized(cmap="Greens",data_arr=np.array(out_list_confid))
+    out_dict_back_colors = {out_list_confid[i]: out_list_grad[i] \
+                                                for i in range(len(out_list_confid))}
+    list_y = [1 for i in out_list_confid]
+    df_confid = pd.DataFrame({'% confidence scale': out_list_confid, 'y': list_y})
+    out_fig = px.scatter(df_confid, x='% confidence scale', y='y', \
+                hover_data={'% confidence scale': True, 'y': False},
+                color=out_dict_back_colors.values(), range_y=[0.9,1.1], range_x=[0,100],
+                color_discrete_map="identity",height=50,symbol='y',symbol_sequence=['square'])
+    out_fig.update_xaxes(showticklabels=False)
+    out_fig.update_yaxes(showticklabels=False, range=[0.1, 1.1], visible=False)
+    out_fig.update_traces(marker_size=50)
+    out_fig.update_layout(paper_bgcolor="white", margin=dict(b=0,r=0,t=0,l=0), xaxis_side="top", \
+                        showlegend=False)
+    return out_reader_type_list, out_reader_type_dict, out_list_dict_lang, \
+        out_cols_size, out_dict_back_colors, out_fig
+###
+@st.cache_data
+def init_easyocr(in_params):
+    """Initialization of easyOCR reader
+    Args:
+        in_params (list): list with the language
+    Returns:
+        easyocr reader: the easyocr reader instance
+    """
+    out_ocr = easyocr.Reader(in_params)
+    return out_ocr
+###
+
+def init_ppocr(in_params):
+    """Initialization of PPOCR reader
+    Args:
+        in_params (dict): dict with parameters
+    Returns:
+        ppocr reader: the ppocr reader instance
+    """
+    out_ocr = PaddleOCR(lang=in_params[0], **in_params[1])
+    return out_ocr
+###
+#@st.cache_data(show_spinner=False)
+#def init_mmocr(in_params):
+#    """Initialization of MMOCR reader
+
+#    Args:
+#        in_params (dict): dict with parameters
+
+#    Returns:
+#        mmocr reader: the ppocr reader instance
+#    """
+#    out_ocr = MMOCR(recog=None, **in_params[1])
+#    return out_ocr
+###
+def init_readers(in_list_params):
+    """Initialization of the readers, and return them as list
+    Args:
+        in_list_params (list): list of dicts of parameters for each reader
+    Returns:
+        list: list of the reader's instances
+    """
+    # Instantiations of the readers :
+    # - EasyOCR
+    with st.spinner("EasyOCR reader initialization in progress ..."):
+        reader_easyocr = init_easyocr([in_list_params[0][0]])
+    # - PPOCR
+    # Paddleocr
+    with st.spinner("PPOCR reader initialization in progress ..."):
+        reader_ppocr = init_ppocr(in_list_params[1])
+    # - MMOCR
+    #with st.spinner("MMOCR reader initialization in progress ..."):
+    #    reader_mmocr = init_mmocr(in_list_params[2])
+    out_list_readers = [reader_easyocr, reader_ppocr] #, reader_mmocr]
+    return out_list_readers
+###
+def load_image(in_image_file):
+    """Load input file and open it
+    Args:
+        in_image_file (string or Streamlit UploadedFile): image to consider
+    Returns:
+        string      : locally saved image path (img.)
+        PIL.Image   : input file opened with Pillow
+        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)
+    return out_image_path, out_image_orig, out_image_cv2
+###
+@st.cache_data(show_spinner=False)
+def easyocr_detect(_in_reader, in_image_path, in_params):
+    """Detection with EasyOCR
+    Args:
+        _in_reader (EasyOCR reader) : the previously initialized instance
+        in_image_path (string  )    : locally saved image path
+        in_params (list)            : list with the parameters for detection
+    Returns:
+        list        : list of the boxes coordinates
+        exception on error, string 'OK' otherwise
+    """
+    try:
+        dict_param = in_params[1]
+        detection_result = _in_reader.detect(in_image_path,
+                                            #width_ths=0.7,
+                                            #mag_ratio=1.5
+                                            **dict_param
+                                            )
+        easyocr_coordinates = detection_result[0][0]
+        # The format of the coordinate is as follows: [x_min, x_max, y_min, y_max]
+        # Format boxes coordinates for draw
+        out_easyocr_boxes_coordinates = list(map(easyocr_coord_convert, easyocr_coordinates))
+        out_status = 'OK'
+    except Exception as e:
+        out_easyocr_boxes_coordinates = []
+        out_status = e
+    return out_easyocr_boxes_coordinates, out_status
+###
+@st.cache_data(show_spinner=False)
+def ppocr_detect(_in_reader, in_image_path):
+    """Detection with PPOCR
+    Args:
+        _in_reader (PPOCR reader) : the previously initialized instance
+        in_image_path (string  )  : locally saved image path
+    Returns:
+        list        : list of the boxes coordinates
+        exception on error, string 'OK' otherwise
+    """
+    # PPOCR detection method
+    try:
+        out_ppocr_boxes_coordinates = _in_reader.ocr(in_image_path, rec=False)
+        out_status = 'OK'
+    except Exception as e:
+        out_ppocr_boxes_coordinates = []
+        out_status = e
+    return out_ppocr_boxes_coordinates, out_status
+###
+#@st.cache_data(show_spinner=False)
+#def mmocr_detect(_in_reader, in_image_path):
+#    """Detection with MMOCR
+
+#    Args:
+#        _in_reader (MMOCR reader) : the previously initialized instance
+#        in_image_path (string)      : locally saved image path
+#        in_params (list)            : list with the parameters
+
+#    Returns:
+#        list        : list of the boxes coordinates
+#        exception on error, string 'OK' otherwise
+#    """
+#    # MMOCR detection method
+#    out_mmocr_boxes_coordinates = []
+#    try:
+#        det_result = _in_reader.readtext(in_image_path, details=True)
+#        bboxes_list = [res['boundary_result'] for res in det_result]
+#        for bboxes in bboxes_list:
+#            for bbox in bboxes:
+#                if len(bbox) > 9:
+#                    min_x = min(bbox[0:-1:2])
+#                    min_y = min(bbox[1:-1:2])
+#                    max_x = max(bbox[0:-1:2])
+#                    max_y = max(bbox[1:-1:2])
+#                    #box = [min_x, min_y, max_x, min_y, max_x, max_y, min_x, max_y]
+#                else:
+#                    min_x = min(bbox[0:-1:2])
+#                    min_y = min(bbox[1::2])
+#                    max_x = max(bbox[0:-1:2])
+#                    max_y = max(bbox[1::2])
+#                box4 = [ [min_x, min_y], [max_x, min_y], [max_x, max_y], [min_x, max_y] ]
+#                out_mmocr_boxes_coordinates.append(box4)
+#        out_status = 'OK'
+#    except Exception as e:
+#        out_status = e
+
+#    return out_mmocr_boxes_coordinates, out_status
+###
+def cropped_1box(in_box, in_img):
+    """Construction of an cropped image corresponding to an area of the initial image
+    Args:
+        in_box (list)   : box with coordinates
+        in_img (matrix) : image
+    Returns:
+        matrix : cropped image
+    """
+    box_ar = np.array(in_box).astype(np.int64)
+    x_min = box_ar[:, 0].min()
+    x_max = box_ar[:, 0].max()
+    y_min = box_ar[:, 1].min()
+    y_max = box_ar[:, 1].max()
+    out_cropped = in_img[y_min:y_max, x_min:x_max]
+    return out_cropped
+###
+@st.cache_data(show_spinner=False)
+def tesserocr_detect(in_image_path, _in_img, in_params):
+    """Detection with Tesseract
+    Args:
+        in_image_path (string) : locally saved image path
+        _in_img (PIL.Image)    : image to consider
+        in_params (list)       : list with the parameters for detection
+    Returns:
+        list        : list of the boxes coordinates
+        exception on error, string 'OK' otherwise
+    """
+    try:
+        dict_param = in_params[1]
+        df_res = pytesseract.image_to_data(_in_img, **dict_param, output_type=Output.DATAFRAME)
+        df_res['box'] = df_res.apply(lambda d: [[d['left'], d['top']], \
+                                                [d['left'] + d['width'], d['top']], \
+                                                [d['left'] + d['width'], d['top'] + d['height']], \
+                                                [d['left'], d['top'] + d['height']], \
+                                            ], axis=1)
+        out_tesserocr_boxes_coordinates = df_res[df_res.word_num > 0]['box'].to_list()
+        out_status = 'OK'
+    except Exception as e:
+        out_tesserocr_boxes_coordinates = []
+        out_status = e
+    return out_tesserocr_boxes_coordinates, out_status
+###
+@st.cache_data(show_spinner=False)
+def process_detect(in_image_path, _in_list_images, _in_list_readers, in_list_params, in_color):
+    """Detection process for each OCR solution
+    Args:
+        in_image_path (string)  : locally saved image path
+        _in_list_images (list)  : list of original image
+        _in_list_readers (list) : list with previously initialized reader's instances
+        in_list_params (list)   : list with dict parameters for each OCR solution
+        in_color (tuple)        : color for boxes around text
+    Returns:
+        list: list of detection results images
+        list: list of boxes coordinates
+    """
+    ## ------- EasyOCR Text detection
+    with st.spinner('EasyOCR Text detection in progress ...'):
+        easyocr_boxes_coordinates,easyocr_status = easyocr_detect(_in_list_readers[0], \
+                                                                in_image_path, in_list_params[0])
+        # Visualization
+        if easyocr_boxes_coordinates:
+            easyocr_image_detect = draw_detected(_in_list_images[0], easyocr_boxes_coordinates, \
+                                                in_color, 'None', 3)
+        else:
+            easyocr_boxes_coordinates = easyocr_status
+    ##
+    ## ------- PPOCR Text detection
+    with st.spinner('PPOCR Text detection in progress ...'):
+        list_ppocr_boxes_coordinates, ppocr_status = ppocr_detect(_in_list_readers[1], in_image_path)
+
+
+        # Visualization
+        try:
+            ppocr_boxes_coordinates = list_ppocr_boxes_coordinates[0]
+            ppocr_image_detect = draw_detected(_in_list_images[0], ppocr_boxes_coordinates, \
+                                            in_color, 'None', 3)
+        except:
+            ppocr_boxes_coordinates = []
+            ppocr_image_detect = ppocr_status
+    ##
+    ## ------- MMOCR Text detection
+    #with st.spinner('MMOCR Text detection in progress ...'):
+    #    mmocr_boxes_coordinates, mmocr_status = mmocr_detect(_in_list_readers[2], in_image_path)
+    #    # Visualization
+    #    if mmocr_boxes_coordinates:
+    #        mmocr_image_detect = draw_detected(_in_list_images[0], mmocr_boxes_coordinates, \
+    #                                        in_color, 'None', 3)
+    #    else:
+    #        mmocr_image_detect = mmocr_status
+    ##
+    ## ------- Tesseract Text detection
+    with st.spinner('Tesseract Text detection in progress ...'):
+        tesserocr_boxes_coordinates, tesserocr_status = tesserocr_detect(in_image_path, \
+                                                                        _in_list_images[0], \
+                                                                        in_list_params[2]) #in_list_params[3]
+        # Visualization
+        if tesserocr_status == 'OK':
+            tesserocr_image_detect = draw_detected(_in_list_images[0],tesserocr_boxes_coordinates,\
+                                                in_color, 'None', 3)
+        else:
+            tesserocr_image_detect = tesserocr_status
+    ##
+    #
+    out_list_images = _in_list_images + [easyocr_image_detect, ppocr_image_detect, \
+                                       # mmocr_image_detect, \
+                                            tesserocr_image_detect]
+    out_list_coordinates = [easyocr_boxes_coordinates, ppocr_boxes_coordinates, \
+                          #  mmocr_boxes_coordinates, \
+                                tesserocr_boxes_coordinates]
+    #
+    return out_list_images, out_list_coordinates
+###
+def draw_detected(in_image, in_boxes_coordinates, in_color, posit='None', in_thickness=4):
+    """Draw boxes around detected text
+    Args:
+        in_image (PIL.Image)        : original image
+        in_boxes_coordinates (list) : boxes coordinates, from top to bottom and from left to right
+                                    [ [ [x_min, y_min], [x_max, y_min], [x_max, y_max], [x_min, y_max] ],
+                                        [ ...                                                            ]
+                                    ]
+        in_color (tuple)            : color for boxes around text
+        posit (str, optional)       : position for text. Defaults to 'None'.
+        in_thickness (int, optional): thickness of the box. Defaults to 4.
+    Returns:
+        PIL.Image : original image with detected areas
+    """
+    work_img = in_image.copy()
+    if in_boxes_coordinates:
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        for ind_box, box in enumerate(in_boxes_coordinates):
+            box = np.reshape(np.array(box), [-1, 1, 2]).astype(np.int64)
+            work_img = cv2.polylines(np.array(work_img), [box], True, in_color, in_thickness)
+            if posit != 'None':
+                if posit == 'top_left':
+                    pos = tuple(box[0][0])
+                elif posit == 'top_right':
+                    pos = tuple(box[1][0])
+                work_img = cv2.putText(work_img, str(ind_box+1), pos, font, 5.5, color, \
+                                    in_thickness,cv2.LINE_AA)
+        out_image_drawn = Image.fromarray(work_img)
+    else:
+        out_image_drawn = work_img
+    return out_image_drawn
+###
+@st.cache_data(show_spinner=False)
+def get_cropped(in_boxes_coordinates, in_image_cv):
+    """Construct list of cropped images corresponding of the input boxes coordinates list
+    Args:
+        in_boxes_coordinates (list) : list of boxes coordinates
+        in_image_cv (matrix)        : original image
+    Returns:
+        list : list with cropped images
+    """
+    out_list_images = []
+    for box in in_boxes_coordinates:
+        cropped = cropped_1box(box, in_image_cv)
+        out_list_images.append(cropped)
+    return out_list_images
+###
+def process_recog(in_list_readers, in_image_cv, in_boxes_coordinates, in_list_dict_params):
+    """Recognition process for each OCR solution
+    Args:
+        in_list_readers (list)      : list with previously initialized reader's instances
+        in_image_cv (matrix)        : original image
+        in_boxes_coordinates (list) : list of boxes coordinates
+        in_list_dict_params (list)  : list with dict parameters for each OCR solution
+    Returns:
+        data frame  : results for each OCR solution, except Tesseract
+        data frame  : results for Tesseract
+        list        : status for each recognition (exception or 'OK')
+    """
+    out_df_results = pd.DataFrame([])
+    list_text_easyocr = []
+    list_confidence_easyocr = []
+    list_text_ppocr = []
+    list_confidence_ppocr = []
+    #list_text_mmocr = []
+    #list_confidence_mmocr = []
+    # Create cropped images from detection
+    list_cropped_images = get_cropped(in_boxes_coordinates, in_image_cv)
+    # Recognize with EasyOCR
+    with st.spinner('EasyOCR Text recognition in progress ...'):
+        list_text_easyocr, list_confidence_easyocr, status_easyocr = \
+            easyocr_recog(list_cropped_images, in_list_readers[0], in_list_dict_params[0])
+    ##
+    # Recognize with PPOCR
+    with st.spinner('PPOCR Text recognition in progress ...'):
+        list_text_ppocr, list_confidence_ppocr, status_ppocr = \
+            ppocr_recog(list_cropped_images, in_list_dict_params[1])
+    ##
+    # Recognize with MMOCR
+    #with st.spinner('MMOCR Text recognition in progress ...'):
+    #    list_text_mmocr, list_confidence_mmocr, status_mmocr = \
+    #        mmocr_recog(list_cropped_images, in_list_dict_params[2])
+    ##
+    # Recognize with Tesseract
+    with st.spinner('Tesseract Text recognition in progress ...'):
+        out_df_results_tesseract, status_tesseract = \
+        tesserocr_recog(in_image_cv, in_list_dict_params[2], len(list_cropped_images))
+        #tesserocr_recog(in_image_cv, in_list_dict_params[3], len(list_cropped_images))
+    ##
+    # Create results data frame
+    out_df_results = pd.DataFrame({'cropped_image': list_cropped_images,
+                                'text_easyocr': list_text_easyocr,
+                                'confidence_easyocr': list_confidence_easyocr,
+                                'text_ppocr': list_text_ppocr,
+                                'confidence_ppocr': list_confidence_ppocr,
+                                #'text_mmocr': list_text_mmocr,
+                                #'confidence_mmocr': list_confidence_mmocr
+                                }
+                                )
+    #out_list_reco_status = [status_easyocr, status_ppocr, status_mmocr, status_tesseract]
+    out_list_reco_status = [status_easyocr, status_ppocr, status_tesseract]
+    return out_df_results, out_df_results_tesseract, out_list_reco_status
+###
+@st.cache_data
+def easyocr_recog(in_list_images, _in_reader_easyocr, in_params):
+    """Recognition with EasyOCR
+    Args:
+        in_list_images (list)               : list of cropped images
+        _in_reader_easyocr (EasyOCR reader) : the previously initialized instance
+        in_params (dict)                    : parameters for recognition
+    Returns:
+        list : list of recognized text
+        list : list of recognition confidence
+        string/Exception : recognition status
+    """
+    progress_bar = st.progress(0)
+    out_list_text_easyocr = []
+    out_list_confidence_easyocr = []
+    ## ------- EasyOCR Text recognition
+    try:
+        step = 0*len(in_list_images) # first recognition process
+        #nb_steps = 4 * len(in_list_images)
+        nb_steps = 3 * len(in_list_images)
+        for ind_img, cropped in enumerate(in_list_images):
+            result = _in_reader_easyocr.recognize(cropped, **in_params)
+            try:
+                out_list_text_easyocr.append(result[0][1])
+                out_list_confidence_easyocr.append(np.round(100*result[0][2], 1))
+            except:
+                out_list_text_easyocr.append('Not recognize')
+                out_list_confidence_easyocr.append(100.)
+            progress_bar.progress((step+ind_img+1)/nb_steps)
+        out_status = 'OK'
+    except Exception as e:
+        out_status = e
+    progress_bar.empty()
+    return out_list_text_easyocr, out_list_confidence_easyocr, out_status
+###
+@st.cache_data
+def ppocr_recog(in_list_images, in_params):
+    """Recognition with PPOCR
+    Args:
+        in_list_images (list) : list of cropped images
+        in_params (dict)      : parameters for recognition
+    Returns:
+        list : list of recognized text
+        list : list of recognition confidence
+        string/Exception : recognition status
+    """
+    ## ------- PPOCR Text recognition
+    out_list_text_ppocr = []
+    out_list_confidence_ppocr = []
+    try:
+        reader_ppocr = PaddleOCR(**in_params)
+        step = 1*len(in_list_images) # second recognition process
+        #nb_steps = 4 * len(in_list_images)
+        nb_steps = 3 * len(in_list_images)
+        progress_bar = st.progress(step/nb_steps)
+        for ind_img, cropped in enumerate(in_list_images):
+            list_result = reader_ppocr.ocr(cropped, det=False, cls=False)
+            result = list_result[0]
+            try:
+                out_list_text_ppocr.append(result[0][0])
+                out_list_confidence_ppocr.append(np.round(100*result[0][1], 1))
+            except:
+                out_list_text_ppocr.append('Not recognize')
+                out_list_confidence_ppocr.append(100.)
+            progress_bar.progress((step+ind_img+1)/nb_steps)
+        out_status = 'OK'
+    except Exception as e:
+        out_status = e
+    progress_bar.empty()
+    return out_list_text_ppocr, out_list_confidence_ppocr, out_status
+###
+#@st.cache_data(suppress_st_warning=True, show_spinner=False)
+#def mmocr_recog(in_list_images, in_params):
+#    """Recognition with MMOCR
+
+#    Args:
+#        in_list_images (list) : list of cropped images
+#        in_params (dict)      : parameters for recognition
+
+#    Returns:
+#        list : list of recognized text
+#        list : list of recognition confidence
+#        string/Exception : recognition status
+#    """
+#    ## ------- MMOCR Text recognition
+#    out_list_text_mmocr = []
+#    out_list_confidence_mmocr = []
+#    try:
+#        reader_mmocr = MMOCR(det=None, **in_params)
+#        step = 2*len(in_list_images) # third recognition process
+#        nb_steps = 4 * len(in_list_images)
+#        progress_bar = st.progress(step/nb_steps)
+
+#        for ind_img, cropped in enumerate(in_list_images):
+#            result = reader_mmocr.readtext(cropped, details=True)
+#            try:
+#                out_list_text_mmocr.append(result[0]['text'])
+#                out_list_confidence_mmocr.append(np.round(100* \
+#                                                        (np.array(result[0]['score']).mean()), 1))
+#            except:
+#                out_list_text_mmocr.append('Not recognize')
+#                out_list_confidence_mmocr.append(100.)
+#            progress_bar.progress((step+ind_img+1)/nb_steps)
+#        out_status = 'OK'
+#    except Exception as e:
+#        out_status = e
+#    progress_bar.empty()
+
+#    return out_list_text_mmocr, out_list_confidence_mmocr, out_status
+
+###
+@st.cache_data
+def tesserocr_recog(in_img, in_params, in_nb_images):
+    """Recognition with Tesseract
+    Args:
+        in_image_cv (matrix) : original image
+        in_params (dict)     : parameters for recognition
+        in_nb_images         : nb cropped images (used for progress bar)
+    Returns:
+        Pandas data frame : recognition results
+        string/Exception  : recognition status
+    """
+    ## ------- Tesseract Text recognition
+    step = 3*in_nb_images # fourth recognition process
+    #nb_steps = 4 * in_nb_images
+    nb_steps = 3 * in_nb_images
+    progress_bar = st.progress(step/nb_steps)
+    try:
+        out_df_result = pytesseract.image_to_data(in_img, **in_params,output_type=Output.DATAFRAME)
+        out_df_result['box'] = out_df_result.apply(lambda d: [[d['left'], d['top']], \
+                                                    [d['left'] + d['width'], d['top']], \
+                                                    [d['left']+d['width'], d['top']+d['height']], \
+                                                    [d['left'], d['top'] + d['height']], \
+                                                    ], axis=1)
+        out_df_result['cropped'] = out_df_result['box'].apply(lambda b: cropped_1box(b, in_img))
+        out_df_result = out_df_result[(out_df_result.word_num > 0) & (out_df_result.text != ' ')] \
+                            .reset_index(drop=True)
+        out_status = 'OK'
+    except Exception as e:
+        out_df_result = pd.DataFrame([])
+        out_status = e
+    progress_bar.progress(1.)
+    return out_df_result, out_status
+###
+def draw_reco_images(in_image, in_boxes_coordinates, in_list_texts, in_list_confid, \
+                    in_dict_back_colors, in_df_results_tesseract, in_reader_type_list, \
+                    in_font_scale=1, in_conf_threshold=65):
+    """Draw recognized text on original image, for each OCR solution used
+    Args:
+        in_image (matrix)        : original image
+        in_boxes_coordinates (list) : list of boxes coordinates
+        in_list_texts (list): list of recognized text for each recognizer (except Tesseract)
+        in_list_confid (list): list of recognition confidence for each recognizer (except Tesseract)
+        in_df_results_tesseract (Pandas data frame): Tesseract recognition results
+        in_font_scale (int, optional): text font scale. Defaults to 3.
+    Returns:
+        shows the results container
+    """
+    img = in_image.copy()
+    nb_readers = len(in_reader_type_list)
+    list_reco_images = [img.copy() for i in range(nb_readers)]
+    for num, box_ in enumerate(in_boxes_coordinates):
+        box = np.array(box_).astype(np.int64)
+        # For each box : draw the results of each recognizer
+        for ind_r in range(nb_readers-1):
+            confid = np.round(in_list_confid[ind_r][num], 0)
+            rgb_color = ImageColor.getcolor(in_dict_back_colors[confid], "RGB")
+            if confid < in_conf_threshold:
+                text_color = (0, 0, 0)
+            else:
+                text_color = (255, 255, 255)
+            if in_font_scale < 1.:
+                thickness = 1
+            else:
+                thickness = 2
+            list_reco_images[ind_r] = cv2.rectangle(list_reco_images[ind_r], \
+                                                (box[0][0], box[0][1]), \
+                                                (box[2][0], box[2][1]), rgb_color, -1)
+            list_reco_images[ind_r] = cv2.putText(list_reco_images[ind_r], \
+                                                in_list_texts[ind_r][num], \
+                                        (box[0][0],int(np.round((box[0][1]+box[2][1])/2,0))), \
+                                        cv2.FONT_HERSHEY_DUPLEX, in_font_scale, text_color, thickness)
+    # Add Tesseract process
+    if not in_df_results_tesseract.empty:
+        ind_tessocr = nb_readers-1
+        for num, box_ in enumerate(in_df_results_tesseract['box'].to_list()):
+            box = np.array(box_).astype(np.int64)
+            confid = np.round(in_df_results_tesseract.iloc[num]['conf'], 0)
+            rgb_color = ImageColor.getcolor(in_dict_back_colors[confid], "RGB")
+            if confid < in_conf_threshold:
+                text_color = (0, 0, 0)
+            else:
+                text_color = (255, 255, 255)
+            list_reco_images[ind_tessocr] = \
+                cv2.rectangle(list_reco_images[ind_tessocr], (box[0][0], box[0][1]), \
+                            (box[2][0], box[2][1]), rgb_color, -1)
+            try:
+                list_reco_images[ind_tessocr] = \
+                    cv2.putText(list_reco_images[ind_tessocr], \
+                                in_df_results_tesseract.iloc[num]['text'], \
+                                (box[0][0],int(np.round((box[0][1]+box[2][1])/2,0))), \
+                                cv2.FONT_HERSHEY_DUPLEX, in_font_scale, text_color, 2)
+            except:
+                pass
+    with show_reco.container():
+        # Draw the results, 2 images per line
+        reco_lines = math.ceil(len(in_reader_type_list) / 2)
+        column_width = 400
+        for ind_lig in range(0, reco_lines+1, 2):
+            cols = st.columns(2)
+            for ind_col in range(2):
+                ind = ind_lig + ind_col
+                if ind < len(in_reader_type_list):
+                    if in_reader_type_list[ind] == 'Tesseract':
+                        column_title = '<p style="font-size: 20px;color:rgb(228,26,28); \
+                                        ">Recognition with ' + in_reader_type_list[ind] + \
+                                        '<sp style="font-size: 17px"> (with its own detector) \
+                                        </sp></p>'
+                    else:
+                        column_title = '<p style="font-size: 20px;color:rgb(228,26,28); \
+                                        ">Recognition with ' + \
+                                        in_reader_type_list[ind]+ '</p>'
+                    cols[ind_col].markdown(column_title, unsafe_allow_html=True)
+                    if st.session_state.list_reco_status[ind] == 'OK':
+                        cols[ind_col].image(list_reco_images[ind], \
+                                            width=column_width, use_container_width=True)
+                    else:
+                        cols[ind_col].write(list_reco_status[ind], \
+                                            use_container_width=True)
+        st.markdown(' 💡 Bad font size? you can adjust it below and refresh:')
+###
+def highlight():
+    """ Highlight choosen detector results
+    """
+    with show_detect.container():
+        columns_size = [1 for x in reader_type_list]
+        column_width  = [300 for x in reader_type_list]
+        columns_color = ["rgb(12, 5, 105)" for x in reader_type_list]
+        columns_size[reader_type_dict[st.session_state.detect_reader]] = 2
+        column_width[reader_type_dict[st.session_state.detect_reader]] = 400
+        columns_color[reader_type_dict[st.session_state.detect_reader]] = "rgb(228,26,28)"
+        columns = st.columns(columns_size, ) #gap='medium')
+        for ind_col, col in enumerate(columns):
+            column_title = '<p style="font-size: 20px;color:'+columns_color[ind_col] + \
+                            ';">Detection with ' + reader_type_list[ind_col]+ '</p>'
+            col.markdown(column_title, unsafe_allow_html=True)
+            if isinstance(list_images[ind_col+2], PIL.Image.Image):
+                col.image(list_images[ind_col+2], width=column_width[ind_col], \
+                          use_container_width=True)
+            else:
+                col.write(list_images[ind_col+2], use_container_width=True)
+        st.session_state.columns_size = columns_size
+        st.session_state.column_width = column_width
+        st.session_state.columns_color = columns_color
+###
+@st.cache(show_spinner=False)
+def get_demo():
+    """Get the demo files
+    Returns:
+        PIL.Image   : input file opened with Pillow
+        PIL.Image   : input file opened with Pillow
+    """
+    out_img_demo_1 = Image.open("img_demo_1.jpg")
+    out_img_demo_2 = Image.open("img_demo_2.jpg")
+    return out_img_demo_1, out_img_demo_2
+###
+def raz():
+    st.session_state.list_coordinates = []
+    st.session_state.list_images = []
+    st.session_state.detect_reader = reader_type_list[0]
+    st.session_state.columns_size = [2] + [1 for x in reader_type_list[1:]]
+    st.session_state.column_width = [400] + [300 for x in reader_type_list[1:]]
+    st.session_state.columns_color = ["rgb(228,26,28)"] + \
+                                     ["rgb(79, 43, 255)" for x in reader_type_list[1:]]
+    # Clear caches
+    easyocr_detect.clear()
+    ppocr_detect.clear()
+    #mmocr_detect.clear()
+    tesserocr_detect.clear()
+    process_detect.clear()
+    get_cropped.clear()
+    easyocr_recog.clear()
+    ppocr_recog.clear()
+    #mmocr_recog.clear()
+    tesserocr_recog.clear()
+###
+###################################################################################################
+##   STREAMLIT APP
+###################################################################################################
+#     ##----------- Initializations ---------------------------------------------------------------------
+#print("PID : ", os.getpid())
+print("ocr comparator")
+st.set_option("client.showErrorDetails", False)
+st.markdown("""
+        <style>
+               .block-container {
+                    padding-top: 1rem;
+                    padding-bottom: 1rem;
+                    padding-left: 1rem;
+                    padding-right: 2rem;
+                }
+        </style>
+        """, unsafe_allow_html=True)
+st.title("OCR solutions comparator")
+#st.markdown("##### *EasyOCR, PPOCR, Tesseract*")
+st.markdown("##### *EasyOCR, PPOCR, MMOCR, Tesseract*")
+#st.markdown("#### PID : " + str(os.getpid()))
+# Initializations
+with st.spinner("Initializations in progress ..."):
+    reader_type_list, reader_type_dict, list_dict_lang, \
+    cols_size, dict_back_colors, fig_colorscale = initializations()
+    img_demo_1, img_demo_2 = get_demo()
+##----------- Choose language & image -------------------------------------------------------------
+st.markdown("#### Choose languages for the text recognition:")
+lang_col = st.columns(4)
+easyocr_key_lang = lang_col[0].selectbox(reader_type_list[0]+" :", list_dict_lang[0].keys(), 26)
+easyocr_lang = list_dict_lang[0][easyocr_key_lang]
+ppocr_key_lang = lang_col[1].selectbox(reader_type_list[1]+" :", list_dict_lang[1].keys(), 22)
+ppocr_lang = list_dict_lang[1][ppocr_key_lang]
+#mmocr_key_lang = lang_col[2].selectbox(reader_type_list[2]+" :", list_dict_lang[2].keys(), 0)
+#mmocr_lang = list_dict_lang[2][mmocr_key_lang]
+#tesserocr_key_lang = lang_col[3].selectbox(reader_type_list[3]+" :", list_dict_lang[3].keys(), 35)
+#tesserocr_lang = list_dict_lang[3][tesserocr_key_lang]
+tesserocr_key_lang = lang_col[2].selectbox(reader_type_list[2]+" :", list_dict_lang[2].keys(), 35)
+tesserocr_lang = list_dict_lang[2][tesserocr_key_lang]
+st.markdown("#### Choose picture:")
+cols_pict = st.columns([1, 2])
+img_typ = cols_pict[0].radio("", ['Upload file', 'Take a picture', 'Use a demo file'], \
+                            index=0, on_change=raz)
+if img_typ == 'Upload file':
+    image_file = cols_pict[1].file_uploader("Upload a file:", type=["jpg","jpeg","png"], on_change=raz)
+if img_typ == 'Take a picture':
+    image_file = cols_pict[1].camera_input("Take a picture:", on_change=raz)
+if img_typ == 'Use a demo file':
+    with st.expander('Choose a demo file:', expanded=True):
+        demo_used = st.radio('', ['File 1', 'File 2'], index=0, \
+                            horizontal=True, on_change=raz)
+        cols_demo = st.columns([1, 2])
+        cols_demo[0].markdown('###### File 1')
+        cols_demo[0].image(img_demo_1, width=150)
+        cols_demo[1].markdown('###### File 2')
+        cols_demo[1].image(img_demo_2, width=300)
+        if demo_used == 'File 1':
+            image_file = 'img_demo_1.jpg'
+        else:
+            image_file = 'img_demo_2.jpg'
+##----------- Process input image -----------------------------------------------------------------
+if image_file is not None:
+    try:
+        image_path, image_orig, image_cv2 = load_image(image_file)
+        list_images = [image_orig, image_cv2]
+    except Exception as e:
+        image_file = None
+        st.exception(e)
+##----------- Form with original image & hyperparameters for detectors ----------------------------
+    with st.form("form1"):
+        col1, col2 = st.columns(2, ) #gap="medium")
+        col1.markdown("##### Original image")
+        col1.image(list_images[0], width=400)
+        col2.markdown("##### Hyperparameters values for detection")
+        with col2.expander("Choose detection hyperparameters for " + reader_type_list[0], \
+                        expanded=False):
+            t0_min_size = st.slider("min_size", 1, 20, 10, step=1, \
+                    help="min_size (int, default = 10) - Filter text box smaller than \
+                        minimum value in pixel")
+            t0_text_threshold = st.slider("text_threshold", 0.1, 1., 0.7, step=0.1, \
+                    help="text_threshold (float, default = 0.7) - Text confidence threshold")
+            t0_low_text = st.slider("low_text", 0.1, 1., 0.4, step=0.1, \
+                    help="low_text (float, default = 0.4) - Text low-bound score")
+            t0_link_threshold = st.slider("link_threshold", 0.1, 1., 0.4, step=0.1, \
+                    help="link_threshold (float, default = 0.4) - Link confidence threshold")
+            t0_canvas_size = st.slider("canvas_size", 2000, 5000, 2560, step=10, \
+                    help='''canvas_size (int, default = 2560) \n
+Maximum e size. Image bigger than this value will be resized down''')
+            t0_mag_ratio = st.slider("mag_ratio", 0.1, 5., 1., step=0.1, \
+                    help="mag_ratio (float, default = 1) - Image magnification ratio")
+            t0_slope_ths = st.slider("slope_ths", 0.01, 1., 0.1, step=0.01, \
+                    help='''slope_ths (float, default = 0.1) - Maximum slope \
+                            (delta y/delta x) to considered merging. \n
+Low valuans tiled boxes will not be merged.''')
+            t0_ycenter_ths = st.slider("ycenter_ths", 0.1, 1., 0.5, step=0.1, \
+                    help='''ycenter_ths (float, default = 0.5) - Maximum shift in y direction. \n
+Boxes wiifferent level should not be merged.''')
+            t0_height_ths = st.slider("height_ths", 0.1, 1., 0.5, step=0.1, \
+                    help='''height_ths (float, default = 0.5) - Maximum different in box height. \n
+Boxes wiery different text size should not be merged.''')
+            t0_width_ths = st.slider("width_ths", 0.1, 1., 0.5, step=0.1, \
+                    help="width_ths (float, default = 0.5) - Maximum horizontal \
+                        distance to merge boxes.")
+            t0_add_margin = st.slider("add_margin", 0.1, 1., 0.1, step=0.1, \
+                    help='''add_margin (float, default = 0.1) - \
+                            Extend bounding boxes in all direction by certain value. \n
+This is rtant for language with complex script (E.g. Thai).''')
+            t0_optimal_num_chars = st.slider("optimal_num_chars", None, 100, None, step=10, \
+                    help="optimal_num_chars (int, default = None) - If specified, bounding boxes \
+                        with estimated number of characters near this value are returned first.")
+        with col2.expander("Choose detection hyperparameters for " + reader_type_list[1], \
+                        expanded=False):
+            t1_det_algorithm = st.selectbox('det_algorithm', ['DB'], \
+                    help='Type of detection algorithm selected. (default = DB)')
+            t1_det_max_side_len = st.slider('det_max_side_len', 500, 2000, 960, step=10, \
+                    help='''The maximum size of the long side of the image. (default = 960)\n
+Limit thximum image height and width.\n
+When theg side exceeds this value, the long side will be resized to this size, and the short side \
+will be ed proportionally.''')
+            t1_det_db_thresh =  st.slider('det_db_thresh', 0.1, 1., 0.3, step=0.1, \
+                    help='''Binarization threshold value of DB output map. (default = 0.3) \n
+Used to er the binarized image of DB prediction, setting 0.-0.3 has no obvious effect on the result.''')
+            t1_det_db_box_thresh = st.slider('det_db_box_thresh', 0.1, 1., 0.6, step=0.1, \
+                    help='''The threshold value of the DB output box. (default = 0.6) \n
+DB post-essing filter box threshold, if there is a missing box detected, it can be reduced as appropriate. \n
+Boxes sclower than this value will be discard.''')
+            t1_det_db_unclip_ratio = st.slider('det_db_unclip_ratio', 1., 3.0, 1.6, step=0.1, \
+                    help='''The expanded ratio of DB output box. (default = 1.6) \n
+Indicatee compactness of the text box, the smaller the value, the closer the text box to the text.''')
+            t1_det_east_score_thresh = st.slider('det_east_cover_thresh', 0.1, 1., 0.8, step=0.1, \
+                    help="Binarization threshold value of EAST output map. (default = 0.8)")
+            t1_det_east_cover_thresh = st.slider('det_east_cover_thresh', 0.1, 1., 0.1, step=0.1, \
+                    help='''The threshold value of the EAST output box. (default = 0.1) \n
+Boxes sclower than this value will be discarded.''')
+            t1_det_east_nms_thresh = st.slider('det_east_nms_thresh', 0.1, 1., 0.2, step=0.1, \
+                    help="The NMS threshold value of EAST model output box. (default = 0.2)")
+            t1_det_db_score_mode = st.selectbox('det_db_score_mode', ['fast', 'slow'], \
+                    help='''slow: use polygon box to calculate bbox score, fast: use rectangle box \
+                    to calculate. (default = fast) \n
+Use rectlar box to calculate faster, and polygonal box more accurate for curved text area.''')
+
+        #with col2.expander("Choose detection hyperparameters for " + reader_type_list[2], \
+        #                expanded=False):
+        #    t2_det = st.selectbox('det', ['DB_r18','DB_r50','DBPP_r50','DRRG','FCE_IC15', \
+        #                                'FCE_CTW_DCNv2','MaskRCNN_CTW','MaskRCNN_IC15', \
+        #                                'MaskRCNN_IC17', 'PANet_CTW','PANet_IC15','PS_CTW',\
+        #                                'PS_IC15','Tesseract','TextSnake'], 10, \
+        #            help='Text detection algorithm. (default = PANet_IC15)')
+        #    st.write("###### *More about text detection models*  👉  \
+        #            [here](https://mmocr.readthedocs.io/en/latest/textdet_models.html)")
+        #    t2_merge_xdist = st.slider('merge_xdist', 1, 50, 20, step=1, \
+        #            help='The maximum x-axis distance to merge boxes. (defaut=20)')
+
+        #with col2.expander("Choose detection hyperparameters for " + reader_type_list[3], \
+        with col2.expander("Choose detection hyperparameters for " + reader_type_list[2], \
+                        expanded=False):
+            t3_psm = st.selectbox('Page segmentation mode (psm)', \
+                                [' -  Default', \
+                                ' 4  Assume a single column of text of variable sizes', \
+                                ' 5  Assume a single uniform block of vertically aligned text', \
+                                ' 6  Assume a single uniform block of text', \
+                                ' 7  Treat the image as a single text line', \
+                                ' 8  Treat the image as a single word', \
+                                ' 9  Treat the image as a single word in a circle', \
+                                '10  Treat the image as a single character', \
+                                '11  Sparse text. Find as much text as possible in no \
+                                        particular order', \
+                                '13  Raw line. Treat the image as a single text line, \
+                                        bypassing hacks that are Tesseract-specific'])
+            t3_oem = st.selectbox('OCR engine mode', ['0  Legacy engine only', \
+                                '1  Neural nets LSTM engine only', \
+                                '2  Legacy + LSTM engines', \
+                                '3  Default, based on what is available'], 3)
+            t3_whitelist = st.text_input('Limit tesseract to recognize only this characters :', \
+                    placeholder='Limit tesseract to recognize only this characters', \
+                    help='Example for numbers only : 0123456789')
+        color_hex = col2.color_picker('Set a color for box outlines:', '#004C99')
+        color_part = color_hex.lstrip('#')
+        color = tuple(int(color_part[i:i+2], 16) for i in (0, 2, 4))
+        submit_detect = st.form_submit_button("Launch detection")
+##----------- Process text detection --------------------------------------------------------------
+    if submit_detect:
+        # Process text detection
+        if t0_optimal_num_chars == 0:
+            t0_optimal_num_chars = None
+        # Construct the config Tesseract parameter
+        t3_config = ''
+        psm = t3_psm[:2]
+        if psm != ' -':
+            t3_config += '--psm ' + psm.strip()
+        oem = t3_oem[:1]
+        if oem != '3':
+            t3_config += ' --oem ' + oem
+        if t3_whitelist != '':
+            t3_config += ' -c tessedit_char_whitelist=' + t3_whitelist
+        list_params_det = \
+            [[easyocr_lang, \
+            {'min_size': t0_min_size, 'text_threshold': t0_text_threshold, \
+            'low_text': t0_low_text, 'link_threshold': t0_link_threshold, \
+            'canvas_size': t0_canvas_size, 'mag_ratio': t0_mag_ratio, \
+            'slope_ths': t0_slope_ths, 'ycenter_ths': t0_ycenter_ths, \
+            'height_ths': t0_height_ths, 'width_ths': t0_width_ths, \
+            'add_margin': t0_add_margin, 'optimal_num_chars': t0_optimal_num_chars \
+            }], \
+            [ppocr_lang, \
+            {'det_algorithm': t1_det_algorithm, 'det_max_side_len': t1_det_max_side_len, \
+            'det_db_thresh': t1_det_db_thresh, 'det_db_box_thresh': t1_det_db_box_thresh, \
+            'det_db_unclip_ratio': t1_det_db_unclip_ratio, \
+            'det_east_score_thresh': t1_det_east_score_thresh, \
+            'det_east_cover_thresh': t1_det_east_cover_thresh, \
+            'det_east_nms_thresh': t1_det_east_nms_thresh, \
+            'det_db_score_mode': t1_det_db_score_mode}],
+            #[mmocr_lang, {'det': t2_det, 'merge_xdist': t2_merge_xdist}],
+            [tesserocr_lang, {'lang': tesserocr_lang, 'config': t3_config}]
+            ]
+        show_info1 = st.empty()
+        show_info1.info("Readers initializations in progress (it may take a while) ...")
+        list_readers = init_readers(list_params_det)
+        show_info1.info("Text detection in progress ...")
+        list_images, list_coordinates = process_detect(image_path, list_images, list_readers, \
+                                                    list_params_det, color)
+        show_info1.empty()
+        # Clear previous recognition results
+        st.session_state.df_results = pd.DataFrame([])
+        st.session_state.list_readers = list_readers
+        st.session_state.list_coordinates = list_coordinates
+        st.session_state.list_images = list_images
+        st.session_state.list_params_det = list_params_det
+        if 'columns_size' not in st.session_state:
+            st.session_state.columns_size = [2] + [1 for x in reader_type_list[1:]]
+        if 'column_width' not in st.session_state:
+            st.session_state.column_width = [400] + [300 for x in reader_type_list[1:]]
+        if 'columns_color' not in st.session_state:
+            st.session_state.columns_color = ["rgb(228,26,28)"] + \
+                                            ["rgb(79, 43, 255)" for x in reader_type_list[1:]]
+    if st.session_state.list_coordinates:
+        list_coordinates = st.session_state.list_coordinates
+        list_images = st.session_state.list_images
+        list_readers = st.session_state.list_readers
+        list_params_det = st.session_state.list_params_det
+##----------- Text detection results --------------------------------------------------------------
+        st.subheader("Text detection")
+        show_detect = st.empty()
+        list_ok_detect = []
+        with show_detect.container():
+            columns = st.columns(st.session_state.columns_size, ) #gap='medium')
+            for no_col, col in enumerate(columns):
+                column_title = '<p style="font-size: 20px;color:' + \
+                            st.session_state.columns_color[no_col] + \
+                            ';">Detection with ' + reader_type_list[no_col]+ '</p>'
+                col.markdown(column_title, unsafe_allow_html=True)
+                if isinstance(list_images[no_col+2], PIL.Image.Image):
+                    col.image(list_images[no_col+2], width=st.session_state.column_width[no_col], \
+                              use_container_width=True)
+                    list_ok_detect.append(reader_type_list[no_col])
+                else:
+                    col.write(list_images[no_col+2], use_container_width=True)
+        st.subheader("Text recognition")
+        st.markdown("##### Using detection performed above by:")
+        st.radio('Choose the detecter:', list_ok_detect, key='detect_reader', \
+                horizontal=True, on_change=highlight)
+##----------- Form with hyperparameters for recognition -----------------------
+        st.markdown("##### Hyperparameters values for recognition:")
+        with st.form("form2"):
+            with st.expander("Choose recognition hyperparameters for " + reader_type_list[0], \
+                            expanded=False):
+                t0_decoder = st.selectbox('decoder', ['greedy', 'beamsearch', 'wordbeamsearch'], \
+                    help="decoder (string, default = 'greedy') - options are 'greedy', \
+                        'beamsearch' and 'wordbeamsearch.")
+                t0_beamWidth = st.slider('beamWidth', 2, 20, 5, step=1, \
+                    help="beamWidth (int, default = 5) - How many beam to keep when decoder = \
+                        'beamsearch' or 'wordbeamsearch'.")
+                t0_batch_size = st.slider('batch_size', 1, 10, 1, step=1, \
+                    help="batch_size (int, default = 1) - batch_size>1 will make EasyOCR faster \
+                        but use more memory.")
+                t0_workers = st.slider('workers', 0, 10, 0, step=1, \
+                    help="workers (int, default = 0) - Number thread used in of dataloader.")
+                t0_allowlist = st.text_input('allowlist', value="", max_chars=None, \
+                    placeholder='Force EasyOCR to recognize only this subset of characters', \
+                    help='''allowlist (string) - Force EasyOCR to recognize only subset of characters.\n
+        Usefor specific problem (E.g. license plate, etc.)''')
+                t0_blocklist = st.text_input('blocklist', value="", max_chars=None, \
+                    placeholder='Block subset of character (will be ignored if allowlist is given)', \
+                    help='''blocklist (string) - Block subset of character. This argument will be \
+                        ignored if allowlist is given.''')
+                t0_detail = st.radio('detail', [0, 1], 1, horizontal=True, \
+                    help="detail (int, default = 1) - Set this to 0 for simple output")
+                t0_paragraph = st.radio('paragraph', [True, False], 1, horizontal=True, \
+                    help='paragraph (bool, default = False) - Combine result into paragraph')
+                t0_contrast_ths = st.slider('contrast_ths', 0.05, 1., 0.1, step=0.01, \
+                    help='''contrast_ths (float, default = 0.1) - Text box with contrast lower than \
+                        this value will be passed into model 2 times.\n
+        Firs with original image and second with contrast adjusted to 'adjust_contrast' value.\n
+        The with more confident level will be returned as a result.''')
+                t0_adjust_contrast = st.slider('adjust_contrast', 0.1, 1., 0.5, step=0.1, \
+                    help = 'adjust_contrast (float, default = 0.5) - target contrast level for low \
+                    contrast text box')
+            with st.expander("Choose recognition hyperparameters for " + reader_type_list[1], \
+                            expanded=False):
+                t1_rec_algorithm = st.selectbox('rec_algorithm', ['CRNN', 'SVTR_LCNet'], 0, \
+                    help="Type of recognition algorithm selected. (default=CRNN)")
+                t1_rec_batch_num = st.slider('rec_batch_num', 1, 50, step=1, \
+                    help="When performing recognition, the batchsize of forward images. \
+                        (default=30)")
+                t1_max_text_length = st.slider('max_text_length', 3, 250, 25, step=1, \
+                    help="The maximum text length that the recognition algorithm can recognize. \
+                        (default=25)")
+                t1_use_space_char = st.radio('use_space_char', [True, False], 0, horizontal=True, \
+                    help="Whether to recognize spaces. (default=TRUE)")
+                t1_drop_score = st.slider('drop_score', 0., 1., 0.25, step=.05, \
+                    help="Filter the output by score (from the recognition model), and those \
+                        below this score will not be returned. (default=0.5)")
+
+            #with st.expander("Choose recognition hyperparameters for " + reader_type_list[2], \
+            #                expanded=False):
+            #    t2_recog = st.selectbox('recog', ['ABINet','CRNN','CRNN_TPS','MASTER', \
+            #                'NRTR_1/16-1/8','NRTR_1/8-1/4','RobustScanner','SAR','SAR_CN', \
+            #                'SATRN','SATRN_sm','SEG','Tesseract'], 7, \
+            #            help='Text recognition algorithm. (default = SAR)')
+            #    st.write("###### *More about text recognition models*  👉  \
+            #            [here](https://mmocr.readthedocs.io/en/latest/textrecog_models.html)")
+
+            #with st.expander("Choose recognition hyperparameters for " + reader_type_list[3], \
+            with st.expander("Choose recognition hyperparameters for " + reader_type_list[2], \
+                            expanded=False):
+                t3r_psm = st.selectbox('Page segmentation mode (psm)', \
+                                    [' -  Default', \
+                                    ' 4  Assume a single column of text of variable sizes', \
+                                    ' 5  Assume a single uniform block of vertically aligned \
+                                            text', \
+                                    ' 6  Assume a single uniform block of text', \
+                                    ' 7  Treat the image as a single text line', \
+                                    ' 8  Treat the image as a single word', \
+                                    ' 9  Treat the image as a single word in a circle', \
+                                    '10  Treat the image as a single character', \
+                                    '11  Sparse text. Find as much text as possible in no \
+                                            particular order', \
+                                    '13  Raw line. Treat the image as a single text line, \
+                                            bypassing hacks that are Tesseract-specific'])
+                t3r_oem = st.selectbox('OCR engine mode', ['0  Legacy engine only', \
+                                    '1  Neural nets LSTM engine only', \
+                                    '2  Legacy + LSTM engines', \
+                                    '3  Default, based on what is available'], 3)
+                t3r_whitelist = st.text_input('Limit tesseract to recognize only this \
+                                    characters :', \
+                                    placeholder='Limit tesseract to recognize only this characters', \
+                                    help='Example for numbers only : 0123456789')
+            submit_reco = st.form_submit_button("Launch recognition")
+        if submit_reco:
+            process_detect.clear()
+##----------- Process recognition ------------------------------------------
+            reader_ind = reader_type_dict[st.session_state.detect_reader]
+            list_boxes = list_coordinates[reader_ind]
+            # Construct the config Tesseract parameter
+            t3r_config = ''
+            psm = t3r_psm[:2]
+            if psm != ' -':
+                t3r_config += '--psm ' + psm.strip()
+            oem = t3r_oem[:1]
+            if oem != '3':
+                t3r_config += ' --oem ' + oem
+            if t3r_whitelist != '':
+                t3r_config += ' -c tessedit_char_whitelist=' + t3r_whitelist
+            list_params_rec = \
+                [{'decoder': t0_decoder, 'beamWidth': t0_beamWidth, \
+                'batch_size': t0_batch_size, 'workers': t0_workers, \
+                'allowlist': t0_allowlist, 'blocklist': t0_blocklist, \
+                'detail': t0_detail, 'paragraph': t0_paragraph, \
+                'contrast_ths': t0_contrast_ths, 'adjust_contrast': t0_adjust_contrast
+                },
+                { **list_params_det[1][1], **{'rec_algorithm': t1_rec_algorithm, \
+                'rec_batch_num': t1_rec_batch_num, 'max_text_length': t1_max_text_length, \
+                'use_space_char': t1_use_space_char, 'drop_score': t1_drop_score}, \
+                **{'lang': list_params_det[1][0]}
+                },
+                #{'recog': t2_recog},
+                {'lang': tesserocr_lang, 'config': t3r_config}
+                ]
+            show_info2 = st.empty()
+            with show_info2.container():
+                st.info("Text recognition in progress ...")
+                df_results, df_results_tesseract, list_reco_status = \
+                        process_recog(list_readers, list_images[1], list_boxes, list_params_rec)
+            show_info2.empty()
+            st.session_state.df_results = df_results
+            st.session_state.list_boxes = list_boxes
+            st.session_state.df_results_tesseract = df_results_tesseract
+            st.session_state.list_reco_status = list_reco_status
+        if 'df_results' in st.session_state:
+            if not st.session_state.df_results.empty:
+##----------- Show recognition results ------------------------------------------------------------
+                results_cols = st.session_state.df_results.columns
+                list_col_text = np.arange(1, len(cols_size), 2)
+                list_col_confid = np.arange(2, len(cols_size), 2)
+                dict_draw_reco = {'in_image': st.session_state.list_images[1], \
+                                'in_boxes_coordinates': st.session_state.list_boxes, \
+                                'in_list_texts': [st.session_state.df_results[x].to_list() \
+                                                    for x in results_cols[list_col_text]], \
+                                'in_list_confid': [st.session_state.df_results[x].to_list() \
+                                                    for x in results_cols[list_col_confid]], \
+                                'in_dict_back_colors': dict_back_colors, \
+                                'in_df_results_tesseract' : st.session_state.df_results_tesseract, \
+                                'in_reader_type_list': reader_type_list
+                                }
+                show_reco = st.empty()
+                with st.form("form3"):
+                    st.plotly_chart(fig_colorscale, use_container_width=True)
+                    col_font, col_threshold = st.columns(2)
+                    col_font.slider('Font scale', 0.1, 7., 1., step=0.1, key="font_scale_sld")
+                    col_threshold.slider('% confidence threshold for text color change', 40, 100, 64, \
+                                        step=1, key="conf_threshold_sld")
+                    col_threshold.write("(text color is black below this % confidence threshold, \
+                                        and white above)")
+                    draw_reco_images(**dict_draw_reco)
+                    submit_resize = st.form_submit_button("Refresh")
+                if submit_resize:
+                    draw_reco_images(**dict_draw_reco, \
+                                    in_font_scale=st.session_state.font_scale_sld, \
+                                    in_conf_threshold=st.session_state.conf_threshold_sld)
+                st.subheader("Recognition details")
+                #with st.expander("Detailed areas for EasyOCR, PPOCR, MMOCR", expanded=True):
+                with st.expander("Detailed areas for EasyOCR, PPOCR", expanded=True):
+                    cols = st.columns(cols_size)
+                    cols[0].markdown('#### Detected area')
+                    for i in range(1, (len(reader_type_list)-1)*2, 2):
+                        cols[i].markdown('#### with ' + reader_type_list[i//2])
+                    for row in st.session_state.df_results.itertuples():
+                        #cols = st.columns(1 + len(reader_type_list)*2)
+                        cols = st.columns(cols_size)
+                        cols[0].image(row.cropped_image, width=150)
+                        for ind_col in range(1, len(cols), 2):
+                            cols[ind_col].write(getattr(row, results_cols[ind_col]))
+                            cols[ind_col+1].write("("+str( \
+                                getattr(row, results_cols[ind_col+1]))+"%)")
+                    st.download_button(
+                        label="Download results as CSV file",
+                        data=convert_df(st.session_state.df_results),
+                        file_name='OCR_comparator_results.csv',
+                        mime='text/csv',
+                    )
+                if not st.session_state.df_results_tesseract.empty:
+                    with st.expander("Detailed areas for Tesseract", expanded=False):
+                        cols = st.columns([2,2,1])
+                        cols[0].markdown('#### Detected area')
+                        cols[1].markdown('#### with Tesseract')
+                        for row in st.session_state.df_results_tesseract.itertuples():
+                            cols = st.columns([2,2,1])
+                            cols[0].image(row.cropped, width=150)
+                            cols[1].write(getattr(row, 'text'))
+                            cols[2].write("("+str(getattr(row, 'conf'))+"%)")
+                        st.download_button(
+                            label="Download Tesseract results as CSV file",
+                            data=convert_df(st.session_state.df_results),
+                            file_name='OCR_comparator_Tesseract_results.csv',
+                            mime='text/csv',
+                        )

requirements.txt

@@ -1,22 +1,21 @@
-# https://github.com/streamlit/streamlit/issues/5315
-easyocr
-altair<5.0
-streamlit==1.26.0
-opencv-python-headless #==4.5.5.64
-torch==2.0.0 #==1.12.1
-torchvision==0.15.1 #==0.13.1
-Pillow
-#mmcv-full --no-binary mmcv-full
-#mmcv
-#mmdet #==2.28.2
-#mmengine
-#mmocr #==0.6.3
-paddleocr #==2.6
-paddlepaddle #==2.4.0rc0
-numpy #==1.23.4
-mycolorpy #==1.5.1
-plotly #==5.10.0
-plotly-express #==0.4.1
-pytesseract #==0.3.10
-streamlit_option_menu
-openmim
+easyocr==1.7.1
+streamlit==1.43.0
+opencv-python-headless==4.9.0.80
+torch==2.4.0
+torchvision==0.19.0
+Pillow
+#mmcv-full --no-binary mmcv-full
+#mmcv
+#mmdet #==2.28.2
+#mmengine
+#mmocr #==0.6.3
+paddleocr==2.8.0
+paddlepaddle==2.6.0
+numpy #==1.23.4
+mycolorpy==1.5.1
+plotly-express==0.4.1
+altair==4.0
+pytesseract==0.3.10
+streamlit_option_menu
+#openmim
+imutils