Update app.py

app.py

@@ -1,1381 +1,17 @@
-"""This Streamlit app allows you to compare, from a given image, the results of different solutions:
-   EasyOcr, PaddleOCR, MMOCR, Tesseract
-"""
 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
-
-
-###################################################################################################
-##   MAIN
-###################################################################################################
-def app():
-
-    ###################################################################################################
-    ##   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': '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(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[0])
-
-        out_list_readers = [reader_mmocr]
-
-        # 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('Text detection in progress ...'):
-            mmocr_boxes_coordinates, mmocr_status = mmocr_detect(_in_list_readers[0], 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)
-        #     else:
-        #         tesserocr_image_detect = tesserocr_status
-        ##
-        #
-        out_list_images = _in_list_images + [ mmocr_image_detect]
-        out_list_coordinates = [mmocr_boxes_coordinates]
-        # 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('Text recognition in progress ...'):
-            list_text_mmocr, list_confidence_mmocr, status_mmocr = \
-                mmocr_recog(list_cropped_images, in_list_dict_params[0])
-        ##
-
-        # # 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_mmocr': list_text_mmocr,
-                                    'confidence_mmocr': list_confidence_mmocr
-                                    }
-                                    )
-
-        out_list_reco_status = [status_mmocr]
-
-        return out_df_results, 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_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 = 1
-        # list_reco_images = img.copy()
-
-        for num, box_ in enumerate(in_boxes_coordinates):
-            box = np.array(box_).astype(np.int64)
-
-            # For each box : draw the results of each recognizer
-        
-            confid = np.round(in_list_confid[0][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 = cv2.rectangle(img, \
-                                                (box[0][0], box[0][1]), \
-                                                (box[2][0], box[2][1]), rgb_color, -1)
-            list_reco_images = cv2.putText(img, \
-                                                in_list_texts[0][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():
-            # column_width = 400
-
-            cols = st.columns((1,1))
-            cols[0].image(list_reco_images,use_column_width=True)
-        # 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(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 MMOCR results """
-        with show_detect.container():
-            column_title = '<p style="font-size: 20px;color: rgb(228,26,28);">Detection with MMOCR</p>'
-            show_detect.markdown(column_title, unsafe_allow_html=True)
-            if isinstance(list_images[2], PIL.Image.Image):
-                show_detect.image(list_images[2], width=400, use_column_width=True)
-            else:
-                show_detect.write(list_images[2], use_column_width=True)
-
-
-    ###
-    @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(0,0,0)" 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()
-
-
-    ##----------- Initializations ---------------------------------------------------------------------
-    #print("PID : ", os.getpid())
-
-    st.title("Scene text detection DEMO apps")
-    #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:")
-    lang_col = st.columns((1,3))  # 1/4 of the space for the dropdown, 3/4 for the rest of the content
-    mmocr_key_lang = lang_col[0].selectbox("", list_dict_lang[0].keys(), 0)
-    mmocr_lang = list_dict_lang[0][mmocr_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"], 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:
-        image_path, image_orig, image_cv2 = load_image(image_file)
-        list_images = [image_orig, image_cv2]
-
-    ##----------- 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 detection model" ,expanded=False):
-                t2_det = 'DBPP_r50'
-                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], \
-            #                 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 = [[mmocr_lang, {'det': t2_det, 'merge_xdist': t2_merge_xdist}]]
-                # [[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}],
-                # [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(0,0,0)" 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():
-                column_title = '<p style="font-size: 20px;color:' + \
-                            st.session_state.columns_color[0] + \
-                            ';">Detection with MMOCR</p>'
-                show_detect.markdown(column_title, unsafe_allow_html=True)
-                if isinstance(list_images[2], PIL.Image.Image):
-                    show_detect.image(list_images[2], width=st.session_state.column_width[0], use_column_width=True)
-                    list_ok_detect.append('MMOCR')
-                else:
-                    show_detect.write(list_images[2], use_column_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], \
-                #                 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[0]
-
-                # # 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 = \
-                    [
-                    {'recog': t2_recog},
-                    ]
-
-                show_info2 = st.empty()
-
-                with show_info2.container():
-                    st.info("Text recognition in progress ...")
-                    df_results, 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[results_cols[1]].to_list() ], \
-                                    'in_list_confid': [st.session_state.df_results[results_cols[2]].to_list()], \
-                                    'in_dict_back_colors': dict_back_colors, \
-                                    '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', 1, 7, 1, step=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):
-                        cols = st.columns(3)
-                        cols[0].markdown('#### Detected area')
-                        cols[1].markdown('#### text ' + "OCR")
-                        cols[2].markdown('#### confidence_score')
-                        for row in st.session_state.df_results.itertuples():
-                            #cols = st.columns(1 + len(reader_type_list)*2)
-                            cols = st.columns(3)
-                            cols[0].image(row.cropped_image, width=150)
-                            cols[1].write(getattr(row, results_cols[1]))
-                            cols[2].write("("+str( \
-                                    getattr(row, results_cols[2]))+"%)")
-
-                        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',
-                    #         )
+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("App", "cast", ocr_comparator.app)
+# app.add_page("Home", "house", home.app)
+app.add_page("About", "info-circle", about.app)
+
+# The main app
+app.run()