Custom multipage

app_pages/ocr_comparator.py

@@ -19,917 +19,910 @@ from pytesseract import Output
 import os
 from mycolorpy import colorlist as mcp
 
+
 ###################################################################################################
-##   FUNCTIONS
+##   MAIN
 ###################################################################################################
+def app():
 
-@st.cache
-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(show_spinner=False)
-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}
-
-    # 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 = [500] + [400 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(0,0,0)" 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.experimental_memo(show_spinner=False)
-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
-
-###
-@st.cache(show_spinner=False)
-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.experimental_memo(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.experimental_memo(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.experimental_memo(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.experimental_memo(show_spinner=False)
-def mmocr_detect(_in_reader, in_image_path):
-    """Detection with MMOCR
-
-    Args:
-        _in_reader (EasyORC 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.experimental_memo(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.experimental_memo(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 ...'):
-        ppocr_boxes_coordinates, ppocr_status = ppocr_detect(_in_list_readers[1], in_image_path)
-        # Visualization
-        if ppocr_boxes_coordinates:
-            ppocr_image_detect = draw_detected(_in_list_images[0], ppocr_boxes_coordinates, \
-                                               in_color, 'None', 3)
-        else:
-            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[3])
-        # Visualization
-        if tesserocr_status == 'OK':
-            tesserocr_image_detect = draw_detected(_in_list_images[0],tesserocr_boxes_coordinates,\
-                                                   in_color, 'None', 3)
+    ###################################################################################################
+    ##   FUNCTIONS
+    ###################################################################################################
+
+    @st.cache
+    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(show_spinner=False)
+    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}
+
+        # 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 = [500] + [400 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(0,0,0)" 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.experimental_memo(show_spinner=False)
+    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
+
+    ###
+    @st.cache(show_spinner=False)
+    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.experimental_memo(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:
-            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.experimental_memo(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[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]
-
-    return out_df_results, out_df_results_tesseract, out_list_reco_status
-
-###
-@st.experimental_memo(suppress_st_warning=True, show_spinner=False)
-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)
-        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.experimental_memo(suppress_st_warning=True, show_spinner=False)
-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)
-        progress_bar = st.progress(step/nb_steps)
-
-        for ind_img, cropped in enumerate(in_list_images):
-            result = reader_ppocr.ocr(cropped, det=False, cls=False)
-            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.experimental_memo(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.experimental_memo(suppress_st_warning=True, show_spinner=False)
-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
-    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']], \
+            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.experimental_memo(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.experimental_memo(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.experimental_memo(show_spinner=False)
+    def mmocr_detect(_in_reader, in_image_path):
+        """Detection with MMOCR
+
+        Args:
+            _in_reader (EasyORC 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.experimental_memo(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['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)
+                                                ], 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.experimental_memo(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:
-                text_color = (255, 255, 255)
-
-            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, 2)
-
-    # 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)
+                easyocr_boxes_coordinates = easyocr_status
+        ##
+
+        ## ------- PPOCR Text detection
+        with st.spinner('PPOCR Text detection in progress ...'):
+            ppocr_boxes_coordinates, ppocr_status = ppocr_detect(_in_list_readers[1], in_image_path)
+            # Visualization
+            if ppocr_boxes_coordinates:
+                ppocr_image_detect = draw_detected(_in_list_images[0], ppocr_boxes_coordinates, \
+                                                in_color, 'None', 3)
+            else:
+                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:
-                text_color = (255, 255, 255)
+                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[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.experimental_memo(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[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]
+
+        return out_df_results, out_df_results_tesseract, out_list_reco_status
+
+    ###
+    @st.experimental_memo(suppress_st_warning=True, show_spinner=False)
+    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)
+            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.experimental_memo(suppress_st_warning=True, show_spinner=False)
+    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)
+            progress_bar = st.progress(step/nb_steps)
+
+            for ind_img, cropped in enumerate(in_list_images):
+                result = reader_ppocr.ocr(cropped, det=False, cls=False)
+                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.experimental_memo(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.experimental_memo(suppress_st_warning=True, show_spinner=False)
+    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
+        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)
+
+                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, 2)
+
+        # 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 = 500
-        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(0,0,0); \
-                                        ">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(0,0,0); \
-                                        ">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_column_width=True)
-                    else:
-                        cols[ind_col].write(list_reco_status[ind], \
-                                            use_column_width=True)
-
-        st.markdown(' 💡 Bad font size? you can adjust it below and refresh:')
-
-###
-def highlight():
-    """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
-    """
-    with show_detect.container():
-        columns_size = [1 for x in reader_type_list]
-        column_width  = [400 for x in reader_type_list]
-        columns_color = ["rgb(0,0,0)" 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]] = 500
-        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_column_width=True)
-            else:
-                col.write(list_images[ind_col+2], use_column_width=True)
-        st.session_state.columns_size = columns_size
-        st.session_state.column_width = column_width
-        st.session_state.columns_color = columns_color
+                    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 = 500
+            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(0,0,0); \
+                                            ">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(0,0,0); \
+                                            ">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_column_width=True)
+                        else:
+                            cols[ind_col].write(list_reco_status[ind], \
+                                                use_column_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  = [400 for x in reader_type_list]
+            columns_color = ["rgb(0,0,0)" 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]] = 500
+            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_column_width=True)
+                else:
+                    col.write(list_images[ind_col+2], use_column_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
+    ###
+    @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
-    """
+        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")
+        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 = []
 
-    return out_img_demo_1, out_img_demo_2
 
-###
-def raz():
-    st.session_state.list_coordinates = []
 
-###################################################################################################
-##   MAIN
-###################################################################################################
-def app():
     ##----------- Initializations ---------------------------------------------------------------------
     #print("PID : ", os.getpid())
 
@@ -987,7 +980,7 @@ def app():
         with st.form("form1"):
             col1, col2 = st.columns(2, ) #gap="medium")
             col1.markdown("##### Original image")
-            col1.image(list_images[0], width=500, use_column_width=True)
+            col1.image(list_images[0], width=400)
             col2.markdown("##### Hyperparameters values for detection")
 
             with col2.expander("Choose detection hyperparameters for " + reader_type_list[0], \