Upload 163 files

README.md

@@ -1,11 +1,11 @@
 ---
 title: Streamlit OCR
-emoji: 🌖
-colorFrom: yellow
-colorTo: yellow
-sdk: streamlit
-sdk_version: 1.35.0
-app_file: app.py
+emoji: ⚡
+colorFrom: purple
+colorTo: green
+sdk: gradio
+sdk_version: 4.36.1
+app_file: ocr_streamlit.py
 pinned: false
 license: apache-2.0
 ---

app_pages/about.py

@@ -0,0 +1,37 @@
+import streamlit as st
+
+def app():
+    st.title("OCR solutions comparator")
+
+    st.write("")
+    st.write("")
+    st.write("")
+
+    st.markdown("#####  This app allows you to compare, from a given picture, the results of different solutions:")
+    st.markdown("##### *EasyOcr, PaddleOCR, MMOCR, Tesseract*")
+    st.write("")
+    st.write("")
+
+    st.markdown(''' The 1st step is to choose the language for the text recognition (not all solutions \
+    support the same languages), and then choose the picture to consider. It is possible to upload a file, \
+    to take a picture, or to use a demo file. \
+    It is then possible to change the default values for the text area detection process, \
+    before launching the detection task for each solution.''')
+    st.write("")
+
+    st.markdown(''' The different results are then presented. The 2nd step is to choose one of these \
+    detection results, in order to carry out the text recognition process there. It is also possible to change \
+    the default settings for each solution.''')
+    st.write("")
+
+    st.markdown("###### The recognition results appear in 2 formats:")
+    st.markdown(''' - a visual format resumes the initial image, replacing the detected areas with \
+    the recognized text. The background is + or - strongly colored in green according to the \
+    confidence level of the recognition.
+        A slider allows you to change the font size, another \
+    allows you to modify the confidence threshold above which the text color changes: if it is at \
+    70% for example, then all the texts with a confidence threshold higher or equal to 70 will appear \
+    in white, in black otherwise.''')
+
+    st.markdown(" - a detailed format presents the results in a table, for each text box detected. \
+    It is possible to download this results in a local csv file.")

app_pages/home.py

@@ -0,0 +1,19 @@
+import streamlit as st
+
+def app():
+    st.image('ocr.png')
+
+    st.write("")
+
+    st.markdown('''#### OCR, or Optical Character Recognition, is a computer vision task, \
+    which includes the detection of text areas, and the recognition of characters.''')
+    st.write("")
+    st.write("")
+
+    st.markdown("#####  This app allows you to compare, from a given image, the results of different solutions:")
+    st.markdown("##### *EasyOcr, PaddleOCR, MMOCR, Tesseract*")
+    st.write("")
+    st.write("")
+    st.markdown("👈 Select the **About** page from the sidebar for information on how the app works")
+
+    st.markdown("👈 or directly select the **App** page")

app_pages/ocr_comparator.py

@@ -0,0 +1,1447 @@
+"""This Streamlit app allows you to compare, from a given image, the results of different solutions:
+   EasyOcr, PaddleOCR, MMOCR, Tesseract
+"""
+
+#import mim
+#
+#mim.install(['mmengine>=0.7.1,<1.1.0'])
+#mim.install(['mmcv>=2.0.0rc4,<2.1.0'])
+#mim.install(['mmdet>=3.0.rc5,<3.2.0'])
+#mim.install(['mmocr'])
+
+import streamlit as st
+import plotly.express as px
+import numpy as np
+import math
+import pandas as pd
+from time import sleep
+
+import cv2
+from PIL import Image, ImageColor
+import PIL
+import easyocr
+from paddleocr import PaddleOCR
+#from mmocr.utils.ocr import MMOCR
+import pytesseract
+from pytesseract import Output
+import os
+from mycolorpy import colorlist as mcp
+
+
+###################################################################################################
+##   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}
+        out_reader_type_list = ['EasyOCR', 'PPOCR', 'Tesseract']
+        out_reader_type_dict = {'EasyOCR': 0, 'PPOCR': 1, 'Tesseract': 2}
+
+        # Columns for recognition details results
+        out_cols_size = [2] + [2,1]*(len(out_reader_type_list)-1) # Except Tesseract
+
+        # Dicts of laguages supported by each reader
+        out_dict_lang_easyocr = {'Abaza': 'abq', 'Adyghe': 'ady', 'Afrikaans': 'af', 'Angika': 'ang', \
+        'Arabic': 'ar', 'Assamese': 'as', 'Avar': 'ava', 'Azerbaijani': 'az', 'Belarusian': 'be', \
+        'Bulgarian': 'bg', 'Bihari': 'bh', 'Bhojpuri': 'bho', 'Bengali': 'bn', 'Bosnian': 'bs', \
+        'Simplified Chinese': 'ch_sim', 'Traditional Chinese': 'ch_tra', 'Chechen': 'che', \
+        'Czech': 'cs', 'Welsh': 'cy', 'Danish': 'da', 'Dargwa': 'dar', 'German': 'de', \
+        'English': 'en', 'Spanish': 'es', 'Estonian': 'et', 'Persian (Farsi)': 'fa', 'French': 'fr', \
+        'Irish': 'ga', 'Goan Konkani': 'gom', 'Hindi': 'hi', 'Croatian': 'hr', 'Hungarian': 'hu', \
+        'Indonesian': 'id', 'Ingush': 'inh', 'Icelandic': 'is', 'Italian': 'it', 'Japanese': 'ja', \
+        'Kabardian': 'kbd', 'Kannada': 'kn', 'Korean': 'ko', 'Kurdish': 'ku', 'Latin': 'la', \
+        'Lak': 'lbe', 'Lezghian': 'lez', 'Lithuanian': 'lt', 'Latvian': 'lv', 'Magahi': 'mah', \
+        'Maithili': 'mai', 'Maori': 'mi', 'Mongolian': 'mn', 'Marathi': 'mr', 'Malay': 'ms', \
+        'Maltese': 'mt', 'Nepali': 'ne', 'Newari': 'new', 'Dutch': 'nl', 'Norwegian': 'no', \
+        'Occitan': 'oc', 'Pali': 'pi', 'Polish': 'pl', 'Portuguese': 'pt', 'Romanian': 'ro', \
+        'Russian': 'ru', 'Serbian (cyrillic)': 'rs_cyrillic', 'Serbian (latin)': 'rs_latin', \
+        'Nagpuri': 'sck', 'Slovak': 'sk', 'Slovenian': 'sl', 'Albanian': 'sq', 'Swedish': 'sv', \
+        'Swahili': 'sw', 'Tamil': 'ta', 'Tabassaran': 'tab', 'Telugu': 'te', 'Thai': 'th', \
+        'Tajik': 'tjk', 'Tagalog': 'tl', 'Turkish': 'tr', 'Uyghur': 'ug', 'Ukranian': 'uk', \
+        'Urdu': 'ur', 'Uzbek': 'uz', 'Vietnamese': 'vi'}
+
+        out_dict_lang_ppocr = {'Abaza': 'abq', 'Adyghe': 'ady', 'Afrikaans': 'af', 'Albanian': 'sq', \
+        'Angika': 'ang', 'Arabic': 'ar', 'Avar': 'ava', 'Azerbaijani': 'az', 'Belarusian': 'be', \
+        'Bhojpuri': 'bho','Bihari': 'bh','Bosnian': 'bs','Bulgarian': 'bg','Chinese & English': 'ch', \
+        'Chinese Traditional': 'chinese_cht', 'Croatian': 'hr', 'Czech': 'cs', 'Danish': 'da', \
+        'Dargwa': 'dar', 'Dutch': 'nl', 'English': 'en', 'Estonian': 'et', 'French': 'fr', \
+        'German': 'german','Goan Konkani': 'gom','Hindi': 'hi','Hungarian': 'hu','Icelandic': 'is', \
+        'Indonesian': 'id', 'Ingush': 'inh', 'Irish': 'ga', 'Italian': 'it', 'Japan': 'japan', \
+        'Kabardian': 'kbd', 'Korean': 'korean', 'Kurdish': 'ku', 'Lak': 'lbe', 'Latvian': 'lv', \
+        'Lezghian': 'lez', 'Lithuanian': 'lt', 'Magahi': 'mah', 'Maithili': 'mai', 'Malay': 'ms', \
+        'Maltese': 'mt', 'Maori': 'mi', 'Marathi': 'mr', 'Mongolian': 'mn', 'Nagpur': 'sck', \
+        'Nepali': 'ne', 'Newari': 'new', 'Norwegian': 'no', 'Occitan': 'oc', 'Persian': 'fa', \
+        'Polish': 'pl', 'Portuguese': 'pt', 'Romanian': 'ro', 'Russia': 'ru', 'Saudi Arabia': 'sa', \
+        'Serbian(cyrillic)': 'rs_cyrillic', 'Serbian(latin)': 'rs_latin', 'Slovak': 'sk', \
+        'Slovenian': 'sl', 'Spanish': 'es', 'Swahili': 'sw', 'Swedish': 'sv', 'Tabassaran': 'tab', \
+        'Tagalog': 'tl', 'Tamil': 'ta', 'Telugu': 'te', 'Turkish': 'tr', 'Ukranian': 'uk', \
+        'Urdu': 'ur', 'Uyghur': 'ug', 'Uzbek': 'uz', 'Vietnamese': 'vi', 'Welsh': 'cy'}
+
+        #out_dict_lang_mmocr = {'English & Chinese': 'en'}
+
+        out_dict_lang_tesseract = {'Afrikaans': 'afr','Albanian': 'sqi','Amharic': 'amh', \
+        'Arabic': 'ara', 'Armenian': 'hye','Assamese': 'asm','Azerbaijani - Cyrilic': 'aze_cyrl', \
+        'Azerbaijani': 'aze', 'Basque': 'eus','Belarusian': 'bel','Bengali': 'ben','Bosnian': 'bos', \
+        'Breton': 'bre', 'Bulgarian': 'bul','Burmese': 'mya','Catalan; Valencian': 'cat', \
+        'Cebuano': 'ceb', 'Central Khmer': 'khm','Cherokee': 'chr','Chinese - Simplified': 'chi_sim', \
+        'Chinese - Traditional': 'chi_tra','Corsican': 'cos','Croatian': 'hrv','Czech': 'ces', \
+        'Danish':'dan','Dutch; Flemish':'nld','Dzongkha':'dzo','English, Middle (1100-1500)':'enm', \
+        'English': 'eng','Esperanto': 'epo','Estonian': 'est','Faroese': 'fao', \
+        'Filipino (old - Tagalog)': 'fil','Finnish': 'fin','French, Middle (ca.1400-1600)': 'frm', \
+        'French': 'fra','Galician': 'glg','Georgian - Old': 'kat_old','Georgian': 'kat', \
+        'German - Fraktur': 'frk','German': 'deu','Greek, Modern (1453-)': 'ell','Gujarati': 'guj', \
+        'Haitian; Haitian Creole': 'hat','Hebrew': 'heb','Hindi': 'hin','Hungarian': 'hun', \
+        'Icelandic': 'isl','Indonesian': 'ind','Inuktitut': 'iku','Irish': 'gle', \
+        'Italian - Old': 'ita_old','Italian': 'ita','Japanese': 'jpn','Javanese': 'jav', \
+        'Kannada': 'kan','Kazakh': 'kaz','Kirghiz; Kyrgyz': 'kir','Korean (vertical)': 'kor_vert', \
+        'Korean': 'kor','Kurdish (Arabic Script)': 'kur_ara','Lao': 'lao','Latin': 'lat', \
+        'Latvian':'lav','Lithuanian':'lit','Luxembourgish':'ltz','Macedonian':'mkd','Malay':'msa', \
+        'Malayalam': 'mal','Maltese': 'mlt','Maori': 'mri','Marathi': 'mar','Mongolian': 'mon', \
+        'Nepali': 'nep','Norwegian': 'nor','Occitan (post 1500)': 'oci', \
+        'Orientation and script detection module':'osd','Oriya':'ori','Panjabi; Punjabi':'pan', \
+        'Persian':'fas','Polish':'pol','Portuguese':'por','Pushto; Pashto':'pus','Quechua':'que', \
+        'Romanian; Moldavian; Moldovan': 'ron','Russian': 'rus','Sanskrit': 'san', \
+        'Scottish Gaelic': 'gla','Serbian - Latin': 'srp_latn','Serbian': 'srp','Sindhi': 'snd', \
+        'Sinhala; Sinhalese': 'sin','Slovak': 'slk','Slovenian': 'slv', \
+        'Spanish; Castilian - Old': 'spa_old','Spanish; Castilian': 'spa','Sundanese': 'sun', \
+        'Swahili': 'swa','Swedish': 'swe','Syriac': 'syr','Tajik': 'tgk','Tamil': 'tam', \
+        'Tatar':'tat','Telugu':'tel','Thai':'tha','Tibetan':'bod','Tigrinya':'tir','Tonga':'ton', \
+        'Turkish': 'tur','Uighur; Uyghur': 'uig','Ukrainian': 'ukr','Urdu': 'urd', \
+        'Uzbek - Cyrilic': 'uzb_cyrl','Uzbek': 'uzb','Vietnamese': 'vie','Welsh': 'cym', \
+        'Western Frisian': 'fry','Yiddish': 'yid','Yoruba': 'yor'}
+
+        out_list_dict_lang = [out_dict_lang_easyocr, out_dict_lang_ppocr, \
+                              #out_dict_lang_mmocr, \
+                            out_dict_lang_tesseract]
+
+        # Initialization of detection form
+        if 'columns_size' not in st.session_state:
+            st.session_state.columns_size = [2] + [1 for x in out_reader_type_list[1:]]
+        if 'column_width' not in st.session_state:
+            st.session_state.column_width = [400] + [300 for x in out_reader_type_list[1:]]
+        if 'columns_color' not in st.session_state:
+            st.session_state.columns_color = ["rgb(228,26,28)"] + \
+                                            ["rgb(79, 43, 255)" for x in out_reader_type_list[1:]]
+        if 'list_coordinates' not in st.session_state:
+            st.session_state.list_coordinates = []
+
+        # Confidence color scale
+        out_list_confid = list(np.arange(0,101,1))
+        out_list_grad = mcp.gen_color_normalized(cmap="Greens",data_arr=np.array(out_list_confid))
+        out_dict_back_colors = {out_list_confid[i]: out_list_grad[i] \
+                                                    for i in range(len(out_list_confid))}
+
+        list_y = [1 for i in out_list_confid]
+        df_confid = pd.DataFrame({'% confidence scale': out_list_confid, 'y': list_y})
+
+        out_fig = px.scatter(df_confid, x='% confidence scale', y='y', \
+                    hover_data={'% confidence scale': True, 'y': False},
+                    color=out_dict_back_colors.values(), range_y=[0.9,1.1], range_x=[0,100],
+                    color_discrete_map="identity",height=50,symbol='y',symbol_sequence=['square'])
+        out_fig.update_xaxes(showticklabels=False)
+        out_fig.update_yaxes(showticklabels=False, range=[0.1, 1.1], visible=False)
+        out_fig.update_traces(marker_size=50)
+        out_fig.update_layout(paper_bgcolor="white", margin=dict(b=0,r=0,t=0,l=0), xaxis_side="top", \
+                            showlegend=False)
+
+        return out_reader_type_list, out_reader_type_dict, out_list_dict_lang, \
+            out_cols_size, out_dict_back_colors, out_fig
+
+    ###
+    @st.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 ...'):
+            list_ppocr_boxes_coordinates, ppocr_status = ppocr_detect(_in_list_readers[1], in_image_path)
+            ppocr_boxes_coordinates = list_ppocr_boxes_coordinates[0]
+            # 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[2]) #in_list_params[3]
+            # Visualization
+            if tesserocr_status == 'OK':
+                tesserocr_image_detect = draw_detected(_in_list_images[0],tesserocr_boxes_coordinates,\
+                                                    in_color, 'None', 3)
+            else:
+                tesserocr_image_detect = tesserocr_status
+        ##
+        #
+        out_list_images = _in_list_images + [easyocr_image_detect, ppocr_image_detect, \
+                                           # mmocr_image_detect, \
+                                                tesserocr_image_detect]
+        out_list_coordinates = [easyocr_boxes_coordinates, ppocr_boxes_coordinates, \
+                              #  mmocr_boxes_coordinates, \
+                                    tesserocr_boxes_coordinates]
+        #
+
+        return out_list_images, out_list_coordinates
+
+    ###
+    def draw_detected(in_image, in_boxes_coordinates, in_color, posit='None', in_thickness=4):
+        """Draw boxes around detected text
+
+        Args:
+            in_image (PIL.Image)        : original image
+            in_boxes_coordinates (list) : boxes coordinates, from top to bottom and from left to right
+                                        [ [ [x_min, y_min], [x_max, y_min], [x_max, y_max], [x_min, y_max] ],
+                                            [ ...                                                            ]
+                                        ]
+            in_color (tuple)            : color for boxes around text
+            posit (str, optional)       : position for text. Defaults to 'None'.
+            in_thickness (int, optional): thickness of the box. Defaults to 4.
+
+        Returns:
+            PIL.Image : original image with detected areas
+        """
+        work_img = in_image.copy()
+        if in_boxes_coordinates:
+            font = cv2.FONT_HERSHEY_SIMPLEX
+            for ind_box, box in enumerate(in_boxes_coordinates):
+                box = np.reshape(np.array(box), [-1, 1, 2]).astype(np.int64)
+                work_img = cv2.polylines(np.array(work_img), [box], True, in_color, in_thickness)
+                if posit != 'None':
+                    if posit == 'top_left':
+                        pos = tuple(box[0][0])
+                    elif posit == 'top_right':
+                        pos = tuple(box[1][0])
+                    work_img = cv2.putText(work_img, str(ind_box+1), pos, font, 5.5, color, \
+                                        in_thickness,cv2.LINE_AA)
+
+            out_image_drawn = Image.fromarray(work_img)
+        else:
+            out_image_drawn = work_img
+
+        return out_image_drawn
+
+    ###
+    @st.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[2], len(list_cropped_images))
+            #tesserocr_recog(in_image_cv, in_list_dict_params[3], len(list_cropped_images))
+        ##
+
+        # Create results data frame
+        out_df_results = pd.DataFrame({'cropped_image': list_cropped_images,
+                                    'text_easyocr': list_text_easyocr,
+                                    'confidence_easyocr': list_confidence_easyocr,
+                                    'text_ppocr': list_text_ppocr,
+                                    'confidence_ppocr': list_confidence_ppocr,
+                                    #'text_mmocr': list_text_mmocr,
+                                    #'confidence_mmocr': list_confidence_mmocr
+                                    }
+                                    )
+
+        #out_list_reco_status = [status_easyocr, status_ppocr, status_mmocr, status_tesseract]
+        out_list_reco_status = [status_easyocr, status_ppocr, status_tesseract]
+
+        return out_df_results, out_df_results_tesseract, out_list_reco_status
+
+    ###
+    @st.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)
+            nb_steps = 3 * len(in_list_images)
+            for ind_img, cropped in enumerate(in_list_images):
+                result = _in_reader_easyocr.recognize(cropped, **in_params)
+                try:
+                    out_list_text_easyocr.append(result[0][1])
+                    out_list_confidence_easyocr.append(np.round(100*result[0][2], 1))
+                except:
+                    out_list_text_easyocr.append('Not recognize')
+                    out_list_confidence_easyocr.append(100.)
+                progress_bar.progress((step+ind_img+1)/nb_steps)
+            out_status = 'OK'
+        except Exception as e:
+            out_status = e
+        progress_bar.empty()
+
+        return out_list_text_easyocr, out_list_confidence_easyocr, out_status
+
+    ###
+    @st.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)
+            nb_steps = 3 * len(in_list_images)
+            progress_bar = st.progress(step/nb_steps)
+
+            for ind_img, cropped in enumerate(in_list_images):
+                list_result = reader_ppocr.ocr(cropped, det=False, cls=False)
+                result = list_result[0]
+                try:
+                    out_list_text_ppocr.append(result[0][0])
+                    out_list_confidence_ppocr.append(np.round(100*result[0][1], 1))
+                except:
+                    out_list_text_ppocr.append('Not recognize')
+                    out_list_confidence_ppocr.append(100.)
+                progress_bar.progress((step+ind_img+1)/nb_steps)
+            out_status = 'OK'
+        except Exception as e:
+            out_status = e
+        progress_bar.empty()
+
+        return out_list_text_ppocr, out_list_confidence_ppocr, out_status
+
+    ###
+    #@st.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
+        nb_steps = 3 * in_nb_images
+        progress_bar = st.progress(step/nb_steps)
+
+        try:
+            out_df_result = pytesseract.image_to_data(in_img, **in_params,output_type=Output.DATAFRAME)
+
+            out_df_result['box'] = out_df_result.apply(lambda d: [[d['left'], d['top']], \
+                                                        [d['left'] + d['width'], d['top']], \
+                                                        [d['left']+d['width'], d['top']+d['height']], \
+                                                        [d['left'], d['top'] + d['height']], \
+                                                        ], axis=1)
+            out_df_result['cropped'] = out_df_result['box'].apply(lambda b: cropped_1box(b, in_img))
+            out_df_result = out_df_result[(out_df_result.word_num > 0) & (out_df_result.text != ' ')] \
+                                .reset_index(drop=True)
+            out_status = 'OK'
+        except Exception as e:
+            out_df_result = pd.DataFrame([])
+            out_status = e
+
+        progress_bar.progress(1.)
+
+        return out_df_result, out_status
+
+    ###
+    def draw_reco_images(in_image, in_boxes_coordinates, in_list_texts, in_list_confid, \
+                        in_dict_back_colors, in_df_results_tesseract, in_reader_type_list, \
+                        in_font_scale=1, in_conf_threshold=65):
+        """Draw recognized text on original image, for each OCR solution used
+
+        Args:
+            in_image (matrix)        : original image
+            in_boxes_coordinates (list) : list of boxes coordinates
+            in_list_texts (list): list of recognized text for each recognizer (except Tesseract)
+            in_list_confid (list): list of recognition confidence for each recognizer (except Tesseract)
+            in_df_results_tesseract (Pandas data frame): Tesseract recognition results
+            in_font_scale (int, optional): text font scale. Defaults to 3.
+
+        Returns:
+            shows the results container
+        """
+        img = in_image.copy()
+        nb_readers = len(in_reader_type_list)
+        list_reco_images = [img.copy() for i in range(nb_readers)]
+
+        for num, box_ in enumerate(in_boxes_coordinates):
+            box = np.array(box_).astype(np.int64)
+
+            # For each box : draw the results of each recognizer
+            for ind_r in range(nb_readers-1):
+                confid = np.round(in_list_confid[ind_r][num], 0)
+                rgb_color = ImageColor.getcolor(in_dict_back_colors[confid], "RGB")
+                if confid < in_conf_threshold:
+                    text_color = (0, 0, 0)
+                else:
+                    text_color = (255, 255, 255)
+
+                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 = 400
+            for ind_lig in range(0, reco_lines+1, 2):
+                cols = st.columns(2)
+                for ind_col in range(2):
+                    ind = ind_lig + ind_col
+                    if ind < len(in_reader_type_list):
+                        if in_reader_type_list[ind] == 'Tesseract':
+                            column_title = '<p style="font-size: 20px;color:rgb(228,26,28); \
+                                            ">Recognition with ' + in_reader_type_list[ind] + \
+                                            '<sp style="font-size: 17px"> (with its own detector) \
+                                            </sp></p>'
+                        else:
+                            column_title = '<p style="font-size: 20px;color:rgb(228,26,28); \
+                                            ">Recognition with ' + \
+                                            in_reader_type_list[ind]+ '</p>'
+                        cols[ind_col].markdown(column_title, unsafe_allow_html=True)
+                        if st.session_state.list_reco_status[ind] == 'OK':
+                            cols[ind_col].image(list_reco_images[ind], \
+                                                width=column_width, use_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  = [300 for x in reader_type_list]
+            columns_color = ["rgb(12, 5, 105)" for x in reader_type_list]
+            columns_size[reader_type_dict[st.session_state.detect_reader]] = 2
+            column_width[reader_type_dict[st.session_state.detect_reader]] = 400
+            columns_color[reader_type_dict[st.session_state.detect_reader]] = "rgb(228,26,28)"
+            columns = st.columns(columns_size, ) #gap='medium')
+
+            for ind_col, col in enumerate(columns):
+                column_title = '<p style="font-size: 20px;color:'+columns_color[ind_col] + \
+                                ';">Detection with ' + reader_type_list[ind_col]+ '</p>'
+                col.markdown(column_title, unsafe_allow_html=True)
+                if isinstance(list_images[ind_col+2], PIL.Image.Image):
+                    col.image(list_images[ind_col+2], width=column_width[ind_col], \
+                              use_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
+
+        Returns:
+            PIL.Image   : input file opened with Pillow
+            PIL.Image   : input file opened with Pillow
+        """
+
+        out_img_demo_1 = Image.open("img_demo_1.jpg")
+        out_img_demo_2 = Image.open("img_demo_2.jpg")
+
+        return out_img_demo_1, out_img_demo_2
+
+    ###
+    def raz():
+        st.session_state.list_coordinates = []
+        st.session_state.list_images = []
+        st.session_state.detect_reader = reader_type_list[0]
+
+        st.session_state.columns_size = [2] + [1 for x in reader_type_list[1:]]
+        st.session_state.column_width = [400] + [300 for x in reader_type_list[1:]]
+        st.session_state.columns_color = ["rgb(228,26,28)"] + \
+                                         ["rgb(79, 43, 255)" for x in reader_type_list[1:]]
+
+        # Clear caches
+        easyocr_detect.clear()
+        ppocr_detect.clear()
+        #mmocr_detect.clear()
+        tesserocr_detect.clear()
+        process_detect.clear()
+        get_cropped.clear()
+        easyocr_recog.clear()
+        ppocr_recog.clear()
+        #mmocr_recog.clear()
+        tesserocr_recog.clear()
+
+
+    ##----------- Initializations ---------------------------------------------------------------------
+    #print("PID : ", os.getpid())
+
+    st.title("OCR solutions comparator")
+    #st.markdown("##### *EasyOCR, PPOCR, Tesseract*")
+    st.markdown("##### *EasyOCR, PPOCR, MMOCR, Tesseract*")
+    #st.markdown("#### PID : " + str(os.getpid()))
+
+    # Initializations
+    with st.spinner("Initializations in progress ..."):
+        reader_type_list, reader_type_dict, list_dict_lang, \
+        cols_size, dict_back_colors, fig_colorscale = initializations()
+        img_demo_1, img_demo_2 = get_demo()
+
+    ##----------- Choose language & image -------------------------------------------------------------
+    st.markdown("#### Choose languages for the text recognition:")
+    lang_col = st.columns(4)
+    easyocr_key_lang = lang_col[0].selectbox(reader_type_list[0]+" :", list_dict_lang[0].keys(), 26)
+    easyocr_lang = list_dict_lang[0][easyocr_key_lang]
+    ppocr_key_lang = lang_col[1].selectbox(reader_type_list[1]+" :", list_dict_lang[1].keys(), 22)
+    ppocr_lang = list_dict_lang[1][ppocr_key_lang]
+    #mmocr_key_lang = lang_col[2].selectbox(reader_type_list[2]+" :", list_dict_lang[2].keys(), 0)
+    #mmocr_lang = list_dict_lang[2][mmocr_key_lang]
+    #tesserocr_key_lang = lang_col[3].selectbox(reader_type_list[3]+" :", list_dict_lang[3].keys(), 35)
+    #tesserocr_lang = list_dict_lang[3][tesserocr_key_lang]
+    tesserocr_key_lang = lang_col[2].selectbox(reader_type_list[2]+" :", list_dict_lang[2].keys(), 35)
+    tesserocr_lang = list_dict_lang[2][tesserocr_key_lang]
+
+    st.markdown("#### Choose picture:")
+    cols_pict = st.columns([1, 2])
+    img_typ = cols_pict[0].radio("", ['Upload file', 'Take a picture', 'Use a demo file'], \
+                                index=0, on_change=raz)
+
+    if img_typ == 'Upload file':
+        image_file = cols_pict[1].file_uploader("Upload a file:", type=["jpg","jpeg"], 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 " + reader_type_list[2], \
+                            expanded=False):
+                t2_det = st.selectbox('det', ['DB_r18','DB_r50','DBPP_r50','DRRG','FCE_IC15', \
+                                            'FCE_CTW_DCNv2','MaskRCNN_CTW','MaskRCNN_IC15', \
+                                            'MaskRCNN_IC17', 'PANet_CTW','PANet_IC15','PS_CTW',\
+                                            'PS_IC15','Tesseract','TextSnake'], 10, \
+                        help='Text detection algorithm. (default = PANet_IC15)')
+                st.write("###### *More about text detection models*  👉  \
+                        [here](https://mmocr.readthedocs.io/en/latest/textdet_models.html)")
+                t2_merge_xdist = st.slider('merge_xdist', 1, 50, 20, step=1, \
+                        help='The maximum x-axis distance to merge boxes. (defaut=20)')
+            """
+            #with col2.expander("Choose detection hyperparameters for " + reader_type_list[3], \
+            with col2.expander("Choose detection hyperparameters for " + reader_type_list[2], \
+                            expanded=False):
+                t3_psm = st.selectbox('Page segmentation mode (psm)', \
+                                    [' -  Default', \
+                                    ' 4  Assume a single column of text of variable sizes', \
+                                    ' 5  Assume a single uniform block of vertically aligned text', \
+                                    ' 6  Assume a single uniform block of text', \
+                                    ' 7  Treat the image as a single text line', \
+                                    ' 8  Treat the image as a single word', \
+                                    ' 9  Treat the image as a single word in a circle', \
+                                    '10  Treat the image as a single character', \
+                                    '11  Sparse text. Find as much text as possible in no \
+                                            particular order', \
+                                    '13  Raw line. Treat the image as a single text line, \
+                                            bypassing hacks that are Tesseract-specific'])
+                t3_oem = st.selectbox('OCR engine mode', ['0  Legacy engine only', \
+                                    '1  Neural nets LSTM engine only', \
+                                    '2  Legacy + LSTM engines', \
+                                    '3  Default, based on what is available'], 3)
+                t3_whitelist = st.text_input('Limit tesseract to recognize only this characters :', \
+                        placeholder='Limit tesseract to recognize only this characters', \
+                        help='Example for numbers only : 0123456789')
+
+            color_hex = col2.color_picker('Set a color for box outlines:', '#004C99')
+            color_part = color_hex.lstrip('#')
+            color = tuple(int(color_part[i:i+2], 16) for i in (0, 2, 4))
+
+            submit_detect = st.form_submit_button("Launch detection")
+
+    ##----------- Process text detection --------------------------------------------------------------
+        if submit_detect:
+            # Process text detection
+
+            if t0_optimal_num_chars == 0:
+                t0_optimal_num_chars = None
+
+            # Construct the config Tesseract parameter
+            t3_config = ''
+            psm = t3_psm[:2]
+            if psm != ' -':
+                t3_config += '--psm ' + psm.strip()
+            oem = t3_oem[:1]
+            if oem != '3':
+                t3_config += ' --oem ' + oem
+            if t3_whitelist != '':
+                t3_config += ' -c tessedit_char_whitelist=' + t3_whitelist
+
+            list_params_det = \
+                [[easyocr_lang, \
+                {'min_size': t0_min_size, 'text_threshold': t0_text_threshold, \
+                'low_text': t0_low_text, 'link_threshold': t0_link_threshold, \
+                'canvas_size': t0_canvas_size, 'mag_ratio': t0_mag_ratio, \
+                'slope_ths': t0_slope_ths, 'ycenter_ths': t0_ycenter_ths, \
+                'height_ths': t0_height_ths, 'width_ths': t0_width_ths, \
+                'add_margin': t0_add_margin, 'optimal_num_chars': t0_optimal_num_chars \
+                }], \
+                [ppocr_lang, \
+                {'det_algorithm': t1_det_algorithm, 'det_max_side_len': t1_det_max_side_len, \
+                'det_db_thresh': t1_det_db_thresh, 'det_db_box_thresh': t1_det_db_box_thresh, \
+                'det_db_unclip_ratio': t1_det_db_unclip_ratio, \
+                'det_east_score_thresh': t1_det_east_score_thresh, \
+                'det_east_cover_thresh': t1_det_east_cover_thresh, \
+                'det_east_nms_thresh': t1_det_east_nms_thresh, \
+                'det_db_score_mode': t1_det_db_score_mode}],
+                #[mmocr_lang, {'det': t2_det, 'merge_xdist': t2_merge_xdist}],
+                [tesserocr_lang, {'lang': tesserocr_lang, 'config': t3_config}]
+                ]
+
+            show_info1 = st.empty()
+            show_info1.info("Readers initializations in progress (it may take a while) ...")
+            list_readers = init_readers(list_params_det)
+
+            show_info1.info("Text detection in progress ...")
+            list_images, list_coordinates = process_detect(image_path, list_images, list_readers, \
+                                                        list_params_det, color)
+            show_info1.empty()
+
+            # Clear previous recognition results
+            st.session_state.df_results = pd.DataFrame([])
+
+            st.session_state.list_readers = list_readers
+            st.session_state.list_coordinates = list_coordinates
+            st.session_state.list_images = list_images
+            st.session_state.list_params_det = list_params_det
+
+            if 'columns_size' not in st.session_state:
+                st.session_state.columns_size = [2] + [1 for x in reader_type_list[1:]]
+            if 'column_width' not in st.session_state:
+                st.session_state.column_width = [400] + [300 for x in reader_type_list[1:]]
+            if 'columns_color' not in st.session_state:
+                st.session_state.columns_color = ["rgb(228,26,28)"] + \
+                                                ["rgb(79, 43, 255)" for x in reader_type_list[1:]]
+
+        if st.session_state.list_coordinates:
+            list_coordinates = st.session_state.list_coordinates
+            list_images = st.session_state.list_images
+            list_readers = st.session_state.list_readers
+            list_params_det = st.session_state.list_params_det
+
+    ##----------- Text detection results --------------------------------------------------------------
+            st.subheader("Text detection")
+            show_detect = st.empty()
+            list_ok_detect = []
+            with show_detect.container():
+                columns = st.columns(st.session_state.columns_size, ) #gap='medium')
+                for no_col, col in enumerate(columns):
+                    column_title = '<p style="font-size: 20px;color:' + \
+                                st.session_state.columns_color[no_col] + \
+                                ';">Detection with ' + reader_type_list[no_col]+ '</p>'
+                    col.markdown(column_title, unsafe_allow_html=True)
+                    if isinstance(list_images[no_col+2], PIL.Image.Image):
+                        col.image(list_images[no_col+2], width=st.session_state.column_width[no_col], \
+                                  use_column_width=True)
+                        list_ok_detect.append(reader_type_list[no_col])
+                    else:
+                        col.write(list_images[no_col+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], \
+                with st.expander("Choose recognition hyperparameters for " + reader_type_list[2], \
+                                expanded=False):
+                    t3r_psm = st.selectbox('Page segmentation mode (psm)', \
+                                        [' -  Default', \
+                                        ' 4  Assume a single column of text of variable sizes', \
+                                        ' 5  Assume a single uniform block of vertically aligned \
+                                                text', \
+                                        ' 6  Assume a single uniform block of text', \
+                                        ' 7  Treat the image as a single text line', \
+                                        ' 8  Treat the image as a single word', \
+                                        ' 9  Treat the image as a single word in a circle', \
+                                        '10  Treat the image as a single character', \
+                                        '11  Sparse text. Find as much text as possible in no \
+                                                particular order', \
+                                        '13  Raw line. Treat the image as a single text line, \
+                                                bypassing hacks that are Tesseract-specific'])
+                    t3r_oem = st.selectbox('OCR engine mode', ['0  Legacy engine only', \
+                                        '1  Neural nets LSTM engine only', \
+                                        '2  Legacy + LSTM engines', \
+                                        '3  Default, based on what is available'], 3)
+                    t3r_whitelist = st.text_input('Limit tesseract to recognize only this \
+                                        characters :', \
+                                        placeholder='Limit tesseract to recognize only this characters', \
+                                        help='Example for numbers only : 0123456789')
+
+                submit_reco = st.form_submit_button("Launch recognition")
+
+            if submit_reco:
+                process_detect.clear()
+    ##----------- Process recognition ------------------------------------------
+                reader_ind = reader_type_dict[st.session_state.detect_reader]
+                list_boxes = list_coordinates[reader_ind]
+
+                # Construct the config Tesseract parameter
+                t3r_config = ''
+                psm = t3r_psm[:2]
+                if psm != ' -':
+                    t3r_config += '--psm ' + psm.strip()
+                oem = t3r_oem[:1]
+                if oem != '3':
+                    t3r_config += ' --oem ' + oem
+                if t3r_whitelist != '':
+                    t3r_config += ' -c tessedit_char_whitelist=' + t3r_whitelist
+
+                list_params_rec = \
+                    [{'decoder': t0_decoder, 'beamWidth': t0_beamWidth, \
+                    'batch_size': t0_batch_size, 'workers': t0_workers, \
+                    'allowlist': t0_allowlist, 'blocklist': t0_blocklist, \
+                    'detail': t0_detail, 'paragraph': t0_paragraph, \
+                    'contrast_ths': t0_contrast_ths, 'adjust_contrast': t0_adjust_contrast
+                    },
+                    { **list_params_det[1][1], **{'rec_algorithm': t1_rec_algorithm, \
+                    'rec_batch_num': t1_rec_batch_num, 'max_text_length': t1_max_text_length, \
+                    'use_space_char': t1_use_space_char, 'drop_score': t1_drop_score}, \
+                    **{'lang': list_params_det[1][0]}
+                    },
+                    #{'recog': t2_recog},
+                    {'lang': tesserocr_lang, 'config': t3r_config}
+                    ]
+
+                show_info2 = st.empty()
+
+                with show_info2.container():
+                    st.info("Text recognition in progress ...")
+                    df_results, df_results_tesseract, list_reco_status = \
+                            process_recog(list_readers, list_images[1], list_boxes, list_params_rec)
+                show_info2.empty()
+
+                st.session_state.df_results = df_results
+                st.session_state.list_boxes = list_boxes
+                st.session_state.df_results_tesseract = df_results_tesseract
+                st.session_state.list_reco_status = list_reco_status
+
+            if 'df_results' in st.session_state:
+                if not st.session_state.df_results.empty:
+    ##----------- Show recognition results ------------------------------------------------------------
+                    results_cols = st.session_state.df_results.columns
+                    list_col_text = np.arange(1, len(cols_size), 2)
+                    list_col_confid = np.arange(2, len(cols_size), 2)
+
+                    dict_draw_reco = {'in_image': st.session_state.list_images[1], \
+                                    'in_boxes_coordinates': st.session_state.list_boxes, \
+                                    'in_list_texts': [st.session_state.df_results[x].to_list() \
+                                                        for x in results_cols[list_col_text]], \
+                                    'in_list_confid': [st.session_state.df_results[x].to_list() \
+                                                        for x in results_cols[list_col_confid]], \
+                                    'in_dict_back_colors': dict_back_colors, \
+                                    'in_df_results_tesseract' : st.session_state.df_results_tesseract, \
+                                    'in_reader_type_list': reader_type_list
+                                    }
+                    show_reco = st.empty()
+
+                    with st.form("form3"):
+                        st.plotly_chart(fig_colorscale, use_container_width=True)
+
+                        col_font, col_threshold = st.columns(2)
+
+                        col_font.slider('Font scale', 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):
+                    with st.expander("Detailed areas for EasyOCR, PPOCR", expanded=True):
+                        cols = st.columns(cols_size)
+                        cols[0].markdown('#### Detected area')
+                        for i in range(1, (len(reader_type_list)-1)*2, 2):
+                            cols[i].markdown('#### with ' + reader_type_list[i//2])
+
+                        for row in st.session_state.df_results.itertuples():
+                            #cols = st.columns(1 + len(reader_type_list)*2)
+                            cols = st.columns(cols_size)
+                            cols[0].image(row.cropped_image, width=150)
+                            for ind_col in range(1, len(cols), 2):
+                                cols[ind_col].write(getattr(row, results_cols[ind_col]))
+                                cols[ind_col+1].write("("+str( \
+                                    getattr(row, results_cols[ind_col+1]))+"%)")
+
+                        st.download_button(
+                            label="Download results as CSV file",
+                            data=convert_df(st.session_state.df_results),
+                            file_name='OCR_comparator_results.csv',
+                            mime='text/csv',
+                        )
+
+                    if not st.session_state.df_results_tesseract.empty:
+                        with st.expander("Detailed areas for Tesseract", expanded=False):
+                            cols = st.columns([2,2,1])
+                            cols[0].markdown('#### Detected area')
+                            cols[1].markdown('#### with Tesseract')
+
+                            for row in st.session_state.df_results_tesseract.itertuples():
+                                cols = st.columns([2,2,1])
+                                cols[0].image(row.cropped, width=150)
+                                cols[1].write(getattr(row, 'text'))
+                                cols[2].write("("+str(getattr(row, 'conf'))+"%)")
+
+                            st.download_button(
+                                label="Download Tesseract results as CSV file",
+                                data=convert_df(st.session_state.df_results),
+                                file_name='OCR_comparator_Tesseract_results.csv',
+                                mime='text/csv',
+                            )

configs/_base_/default_runtime.py

@@ -0,0 +1,17 @@
+# yapf:disable
+log_config = dict(
+    interval=5,
+    hooks=[
+        dict(type='TextLoggerHook')
+    ])
+# yapf:enable
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+workflow = [('train', 1)]
+
+# disable opencv multithreading to avoid system being overloaded
+opencv_num_threads = 0
+# set multi-process start method as `fork` to speed up the training
+mp_start_method = 'fork'

configs/_base_/det_datasets/ctw1500.py

@@ -0,0 +1,18 @@
+dataset_type = 'IcdarDataset'
+data_root = 'data/ctw1500'
+
+train = dict(
+    type=dataset_type,
+    ann_file=f'{data_root}/instances_training.json',
+    img_prefix=f'{data_root}/imgs',
+    pipeline=None)
+
+test = dict(
+    type=dataset_type,
+    ann_file=f'{data_root}/instances_test.json',
+    img_prefix=f'{data_root}/imgs',
+    pipeline=None)
+
+train_list = [train]
+
+test_list = [test]

configs/_base_/det_datasets/icdar2015.py

@@ -0,0 +1,18 @@
+dataset_type = 'IcdarDataset'
+data_root = 'data/icdar2015'
+
+train = dict(
+    type=dataset_type,
+    ann_file=f'{data_root}/instances_training.json',
+    img_prefix=f'{data_root}/imgs',
+    pipeline=None)
+
+test = dict(
+    type=dataset_type,
+    ann_file=f'{data_root}/instances_test.json',
+    img_prefix=f'{data_root}/imgs',
+    pipeline=None)
+
+train_list = [train]
+
+test_list = [test]

configs/_base_/det_datasets/icdar2017.py

@@ -0,0 +1,18 @@
+dataset_type = 'IcdarDataset'
+data_root = 'data/icdar2017'
+
+train = dict(
+    type=dataset_type,
+    ann_file=f'{data_root}/instances_training.json',
+    img_prefix=f'{data_root}/imgs',
+    pipeline=None)
+
+test = dict(
+    type=dataset_type,
+    ann_file=f'{data_root}/instances_val.json',
+    img_prefix=f'{data_root}/imgs',
+    pipeline=None)
+
+train_list = [train]
+
+test_list = [test]

configs/_base_/det_datasets/synthtext.py

@@ -0,0 +1,18 @@
+dataset_type = 'TextDetDataset'
+data_root = 'data/synthtext'
+
+train = dict(
+    type=dataset_type,
+    ann_file=f'{data_root}/instances_training.lmdb',
+    loader=dict(
+        type='AnnFileLoader',
+        repeat=1,
+        file_format='lmdb',
+        parser=dict(
+            type='LineJsonParser',
+            keys=['file_name', 'height', 'width', 'annotations'])),
+    img_prefix=f'{data_root}/imgs',
+    pipeline=None)
+
+train_list = [train]
+test_list = [train]

configs/_base_/det_datasets/toy_data.py

@@ -0,0 +1,41 @@
+root = 'tests/data/toy_dataset'
+
+# dataset with type='TextDetDataset'
+train1 = dict(
+    type='TextDetDataset',
+    img_prefix=f'{root}/imgs',
+    ann_file=f'{root}/instances_test.txt',
+    loader=dict(
+        type='AnnFileLoader',
+        repeat=4,
+        file_format='txt',
+        parser=dict(
+            type='LineJsonParser',
+            keys=['file_name', 'height', 'width', 'annotations'])),
+    pipeline=None,
+    test_mode=False)
+
+# dataset with type='IcdarDataset'
+train2 = dict(
+    type='IcdarDataset',
+    ann_file=f'{root}/instances_test.json',
+    img_prefix=f'{root}/imgs',
+    pipeline=None)
+
+test = dict(
+    type='TextDetDataset',
+    img_prefix=f'{root}/imgs',
+    ann_file=f'{root}/instances_test.txt',
+    loader=dict(
+        type='AnnFileLoader',
+        repeat=1,
+        file_format='txt',
+        parser=dict(
+            type='LineJsonParser',
+            keys=['file_name', 'height', 'width', 'annotations'])),
+    pipeline=None,
+    test_mode=True)
+
+train_list = [train1, train2]
+
+test_list = [test]

configs/_base_/det_models/dbnet_r18_fpnc.py

@@ -0,0 +1,21 @@
+model = dict(
+    type='DBNet',
+    backbone=dict(
+        type='mmdet.ResNet',
+        depth=18,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=-1,
+        norm_cfg=dict(type='BN', requires_grad=True),
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet18'),
+        norm_eval=False,
+        style='caffe'),
+    neck=dict(
+        type='FPNC', in_channels=[64, 128, 256, 512], lateral_channels=256),
+    bbox_head=dict(
+        type='DBHead',
+        in_channels=256,
+        loss=dict(type='DBLoss', alpha=5.0, beta=10.0, bbce_loss=True),
+        postprocessor=dict(type='DBPostprocessor', text_repr_type='quad')),
+    train_cfg=None,
+    test_cfg=None)

configs/_base_/det_models/dbnet_r50dcnv2_fpnc.py

@@ -0,0 +1,23 @@
+model = dict(
+    type='DBNet',
+    backbone=dict(
+        type='mmdet.ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=-1,
+        norm_cfg=dict(type='BN', requires_grad=True),
+        norm_eval=False,
+        style='pytorch',
+        dcn=dict(type='DCNv2', deform_groups=1, fallback_on_stride=False),
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50'),
+        stage_with_dcn=(False, True, True, True)),
+    neck=dict(
+        type='FPNC', in_channels=[256, 512, 1024, 2048], lateral_channels=256),
+    bbox_head=dict(
+        type='DBHead',
+        in_channels=256,
+        loss=dict(type='DBLoss', alpha=5.0, beta=10.0, bbce_loss=True),
+        postprocessor=dict(type='DBPostprocessor', text_repr_type='quad')),
+    train_cfg=None,
+    test_cfg=None)

configs/_base_/det_models/dbnetpp_r50dcnv2_fpnc.py

@@ -0,0 +1,28 @@
+model = dict(
+    type='DBNet',
+    backbone=dict(
+        type='mmdet.ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=-1,
+        norm_cfg=dict(type='BN', requires_grad=True),
+        norm_eval=False,
+        style='pytorch',
+        dcn=dict(type='DCNv2', deform_groups=1, fallback_on_stride=False),
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50'),
+        stage_with_dcn=(False, True, True, True)),
+    neck=dict(
+        type='FPNC',
+        in_channels=[256, 512, 1024, 2048],
+        lateral_channels=256,
+        asf_cfg=dict(attention_type='ScaleChannelSpatial')),
+    bbox_head=dict(
+        type='DBHead',
+        in_channels=256,
+        loss=dict(type='DBLoss', alpha=5.0, beta=10.0, bbce_loss=True),
+        postprocessor=dict(
+            type='DBPostprocessor', text_repr_type='quad',
+            epsilon_ratio=0.002)),
+    train_cfg=None,
+    test_cfg=None)

configs/_base_/det_models/drrg_r50_fpn_unet.py

@@ -0,0 +1,21 @@
+model = dict(
+    type='DRRG',
+    backbone=dict(
+        type='mmdet.ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=-1,
+        norm_cfg=dict(type='BN', requires_grad=True),
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50'),
+        norm_eval=True,
+        style='caffe'),
+    neck=dict(
+        type='FPN_UNet', in_channels=[256, 512, 1024, 2048], out_channels=32),
+    bbox_head=dict(
+        type='DRRGHead',
+        in_channels=32,
+        text_region_thr=0.3,
+        center_region_thr=0.4,
+        loss=dict(type='DRRGLoss'),
+        postprocessor=dict(type='DRRGPostprocessor', link_thr=0.80)))

configs/_base_/det_models/fcenet_r50_fpn.py

@@ -0,0 +1,33 @@
+model = dict(
+    type='FCENet',
+    backbone=dict(
+        type='mmdet.ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(1, 2, 3),
+        frozen_stages=-1,
+        norm_cfg=dict(type='BN', requires_grad=True),
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50'),
+        norm_eval=False,
+        style='pytorch'),
+    neck=dict(
+        type='mmdet.FPN',
+        in_channels=[512, 1024, 2048],
+        out_channels=256,
+        add_extra_convs='on_output',
+        num_outs=3,
+        relu_before_extra_convs=True,
+        act_cfg=None),
+    bbox_head=dict(
+        type='FCEHead',
+        in_channels=256,
+        scales=(8, 16, 32),
+        fourier_degree=5,
+        loss=dict(type='FCELoss', num_sample=50),
+        postprocessor=dict(
+            type='FCEPostprocessor',
+            text_repr_type='quad',
+            num_reconstr_points=50,
+            alpha=1.2,
+            beta=1.0,
+            score_thr=0.3)))

configs/_base_/det_models/fcenet_r50dcnv2_fpn.py

@@ -0,0 +1,35 @@
+model = dict(
+    type='FCENet',
+    backbone=dict(
+        type='mmdet.ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(1, 2, 3),
+        frozen_stages=-1,
+        norm_cfg=dict(type='BN', requires_grad=True),
+        norm_eval=True,
+        style='pytorch',
+        dcn=dict(type='DCNv2', deform_groups=2, fallback_on_stride=False),
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50'),
+        stage_with_dcn=(False, True, True, True)),
+    neck=dict(
+        type='mmdet.FPN',
+        in_channels=[512, 1024, 2048],
+        out_channels=256,
+        add_extra_convs='on_output',
+        num_outs=3,
+        relu_before_extra_convs=True,
+        act_cfg=None),
+    bbox_head=dict(
+        type='FCEHead',
+        in_channels=256,
+        scales=(8, 16, 32),
+        fourier_degree=5,
+        loss=dict(type='FCELoss', num_sample=50),
+        postprocessor=dict(
+            type='FCEPostprocessor',
+            text_repr_type='poly',
+            num_reconstr_points=50,
+            alpha=1.0,
+            beta=2.0,
+            score_thr=0.3)))

configs/_base_/det_models/ocr_mask_rcnn_r50_fpn_ohem.py

@@ -0,0 +1,126 @@
+# model settings
+model = dict(
+    type='OCRMaskRCNN',
+    backbone=dict(
+        type='mmdet.ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type='BN', requires_grad=True),
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50'),
+        norm_eval=True,
+        style='pytorch'),
+    neck=dict(
+        type='mmdet.FPN',
+        in_channels=[256, 512, 1024, 2048],
+        out_channels=256,
+        num_outs=5),
+    rpn_head=dict(
+        type='RPNHead',
+        in_channels=256,
+        feat_channels=256,
+        anchor_generator=dict(
+            type='AnchorGenerator',
+            scales=[4],
+            ratios=[0.17, 0.44, 1.13, 2.90, 7.46],
+            strides=[4, 8, 16, 32, 64]),
+        bbox_coder=dict(
+            type='DeltaXYWHBBoxCoder',
+            target_means=[.0, .0, .0, .0],
+            target_stds=[1.0, 1.0, 1.0, 1.0]),
+        loss_cls=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
+        loss_bbox=dict(type='L1Loss', loss_weight=1.0)),
+    roi_head=dict(
+        type='StandardRoIHead',
+        bbox_roi_extractor=dict(
+            type='SingleRoIExtractor',
+            roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0),
+            out_channels=256,
+            featmap_strides=[4, 8, 16, 32]),
+        bbox_head=dict(
+            type='Shared2FCBBoxHead',
+            in_channels=256,
+            fc_out_channels=1024,
+            roi_feat_size=7,
+            num_classes=1,
+            bbox_coder=dict(
+                type='DeltaXYWHBBoxCoder',
+                target_means=[0., 0., 0., 0.],
+                target_stds=[0.1, 0.1, 0.2, 0.2]),
+            reg_class_agnostic=False,
+            loss_cls=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
+            loss_bbox=dict(type='L1Loss', loss_weight=1.0)),
+        mask_roi_extractor=dict(
+            type='SingleRoIExtractor',
+            roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0),
+            out_channels=256,
+            featmap_strides=[4, 8, 16, 32]),
+        mask_head=dict(
+            type='FCNMaskHead',
+            num_convs=4,
+            in_channels=256,
+            conv_out_channels=256,
+            num_classes=1,
+            loss_mask=dict(
+                type='CrossEntropyLoss', use_mask=True, loss_weight=1.0))),
+
+    # model training and testing settings
+    train_cfg=dict(
+        rpn=dict(
+            assigner=dict(
+                type='MaxIoUAssigner',
+                pos_iou_thr=0.7,
+                neg_iou_thr=0.3,
+                min_pos_iou=0.3,
+                match_low_quality=True,
+                ignore_iof_thr=-1,
+                gpu_assign_thr=50),
+            sampler=dict(
+                type='RandomSampler',
+                num=256,
+                pos_fraction=0.5,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=False),
+            allowed_border=-1,
+            pos_weight=-1,
+            debug=False),
+        rpn_proposal=dict(
+            nms_across_levels=False,
+            nms_pre=2000,
+            nms_post=1000,
+            max_per_img=1000,
+            nms=dict(type='nms', iou_threshold=0.7),
+            min_bbox_size=0),
+        rcnn=dict(
+            assigner=dict(
+                type='MaxIoUAssigner',
+                pos_iou_thr=0.5,
+                neg_iou_thr=0.5,
+                min_pos_iou=0.5,
+                match_low_quality=True,
+                ignore_iof_thr=-1),
+            sampler=dict(
+                type='OHEMSampler',
+                num=512,
+                pos_fraction=0.25,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=True),
+            mask_size=28,
+            pos_weight=-1,
+            debug=False)),
+    test_cfg=dict(
+        rpn=dict(
+            nms_across_levels=False,
+            nms_pre=1000,
+            nms_post=1000,
+            max_per_img=1000,
+            nms=dict(type='nms', iou_threshold=0.7),
+            min_bbox_size=0),
+        rcnn=dict(
+            score_thr=0.05,
+            nms=dict(type='nms', iou_threshold=0.5),
+            max_per_img=100,
+            mask_thr_binary=0.5)))

configs/_base_/det_models/ocr_mask_rcnn_r50_fpn_ohem_poly.py

@@ -0,0 +1,126 @@
+# model settings
+model = dict(
+    type='OCRMaskRCNN',
+    text_repr_type='poly',
+    backbone=dict(
+        type='mmdet.ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type='BN', requires_grad=True),
+        norm_eval=True,
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50'),
+        style='pytorch'),
+    neck=dict(
+        type='mmdet.FPN',
+        in_channels=[256, 512, 1024, 2048],
+        out_channels=256,
+        num_outs=5),
+    rpn_head=dict(
+        type='RPNHead',
+        in_channels=256,
+        feat_channels=256,
+        anchor_generator=dict(
+            type='AnchorGenerator',
+            scales=[4],
+            ratios=[0.17, 0.44, 1.13, 2.90, 7.46],
+            strides=[4, 8, 16, 32, 64]),
+        bbox_coder=dict(
+            type='DeltaXYWHBBoxCoder',
+            target_means=[.0, .0, .0, .0],
+            target_stds=[1.0, 1.0, 1.0, 1.0]),
+        loss_cls=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
+        loss_bbox=dict(type='L1Loss', loss_weight=1.0)),
+    roi_head=dict(
+        type='StandardRoIHead',
+        bbox_roi_extractor=dict(
+            type='SingleRoIExtractor',
+            roi_layer=dict(type='RoIAlign', output_size=7, sample_num=0),
+            out_channels=256,
+            featmap_strides=[4, 8, 16, 32]),
+        bbox_head=dict(
+            type='Shared2FCBBoxHead',
+            in_channels=256,
+            fc_out_channels=1024,
+            roi_feat_size=7,
+            num_classes=80,
+            bbox_coder=dict(
+                type='DeltaXYWHBBoxCoder',
+                target_means=[0., 0., 0., 0.],
+                target_stds=[0.1, 0.1, 0.2, 0.2]),
+            reg_class_agnostic=False,
+            loss_cls=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
+            loss_bbox=dict(type='L1Loss', loss_weight=1.0)),
+        mask_roi_extractor=dict(
+            type='SingleRoIExtractor',
+            roi_layer=dict(type='RoIAlign', output_size=14, sample_num=0),
+            out_channels=256,
+            featmap_strides=[4, 8, 16, 32]),
+        mask_head=dict(
+            type='FCNMaskHead',
+            num_convs=4,
+            in_channels=256,
+            conv_out_channels=256,
+            num_classes=80,
+            loss_mask=dict(
+                type='CrossEntropyLoss', use_mask=True, loss_weight=1.0))),
+    # model training and testing settings
+    train_cfg=dict(
+        rpn=dict(
+            assigner=dict(
+                type='MaxIoUAssigner',
+                pos_iou_thr=0.7,
+                neg_iou_thr=0.3,
+                min_pos_iou=0.3,
+                match_low_quality=True,
+                ignore_iof_thr=-1),
+            sampler=dict(
+                type='RandomSampler',
+                num=256,
+                pos_fraction=0.5,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=False),
+            allowed_border=-1,
+            pos_weight=-1,
+            debug=False),
+        rpn_proposal=dict(
+            nms_across_levels=False,
+            nms_pre=2000,
+            nms_post=1000,
+            max_per_img=1000,
+            nms=dict(type='nms', iou_threshold=0.7),
+            min_bbox_size=0),
+        rcnn=dict(
+            assigner=dict(
+                type='MaxIoUAssigner',
+                pos_iou_thr=0.5,
+                neg_iou_thr=0.5,
+                min_pos_iou=0.5,
+                match_low_quality=True,
+                ignore_iof_thr=-1,
+                gpu_assign_thr=50),
+            sampler=dict(
+                type='OHEMSampler',
+                num=512,
+                pos_fraction=0.25,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=True),
+            mask_size=28,
+            pos_weight=-1,
+            debug=False)),
+    test_cfg=dict(
+        rpn=dict(
+            nms_across_levels=False,
+            nms_pre=1000,
+            nms_post=1000,
+            max_per_img=1000,
+            nms=dict(type='nms', iou_threshold=0.7),
+            min_bbox_size=0),
+        rcnn=dict(
+            score_thr=0.05,
+            nms=dict(type='nms', iou_threshold=0.5),
+            max_per_img=100,
+            mask_thr_binary=0.5)))

configs/_base_/det_models/panet_r18_fpem_ffm.py

@@ -0,0 +1,43 @@
+model_poly = dict(
+    type='PANet',
+    backbone=dict(
+        type='mmdet.ResNet',
+        depth=18,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=-1,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet18'),
+        norm_eval=True,
+        style='caffe'),
+    neck=dict(type='FPEM_FFM', in_channels=[64, 128, 256, 512]),
+    bbox_head=dict(
+        type='PANHead',
+        in_channels=[128, 128, 128, 128],
+        out_channels=6,
+        loss=dict(type='PANLoss'),
+        postprocessor=dict(type='PANPostprocessor', text_repr_type='poly')),
+    train_cfg=None,
+    test_cfg=None)
+
+model_quad = dict(
+    type='PANet',
+    backbone=dict(
+        type='mmdet.ResNet',
+        depth=18,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=-1,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet18'),
+        norm_eval=True,
+        style='caffe'),
+    neck=dict(type='FPEM_FFM', in_channels=[64, 128, 256, 512]),
+    bbox_head=dict(
+        type='PANHead',
+        in_channels=[128, 128, 128, 128],
+        out_channels=6,
+        loss=dict(type='PANLoss'),
+        postprocessor=dict(type='PANPostprocessor', text_repr_type='quad')),
+    train_cfg=None,
+    test_cfg=None)

configs/_base_/det_models/panet_r50_fpem_ffm.py

@@ -0,0 +1,21 @@
+model = dict(
+    type='PANet',
+    pretrained='torchvision://resnet50',
+    backbone=dict(
+        type='mmdet.ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type='BN', requires_grad=True),
+        norm_eval=True,
+        style='caffe'),
+    neck=dict(type='FPEM_FFM', in_channels=[256, 512, 1024, 2048]),
+    bbox_head=dict(
+        type='PANHead',
+        in_channels=[128, 128, 128, 128],
+        out_channels=6,
+        loss=dict(type='PANLoss', speedup_bbox_thr=32),
+        postprocessor=dict(type='PANPostprocessor', text_repr_type='poly')),
+    train_cfg=None,
+    test_cfg=None)

configs/_base_/det_models/psenet_r50_fpnf.py

@@ -0,0 +1,51 @@
+model_poly = dict(
+    type='PSENet',
+    backbone=dict(
+        type='mmdet.ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=-1,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50'),
+        norm_eval=True,
+        style='caffe'),
+    neck=dict(
+        type='FPNF',
+        in_channels=[256, 512, 1024, 2048],
+        out_channels=256,
+        fusion_type='concat'),
+    bbox_head=dict(
+        type='PSEHead',
+        in_channels=[256],
+        out_channels=7,
+        loss=dict(type='PSELoss'),
+        postprocessor=dict(type='PSEPostprocessor', text_repr_type='poly')),
+    train_cfg=None,
+    test_cfg=None)
+
+model_quad = dict(
+    type='PSENet',
+    backbone=dict(
+        type='mmdet.ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=-1,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50'),
+        norm_eval=True,
+        style='caffe'),
+    neck=dict(
+        type='FPNF',
+        in_channels=[256, 512, 1024, 2048],
+        out_channels=256,
+        fusion_type='concat'),
+    bbox_head=dict(
+        type='PSEHead',
+        in_channels=[256],
+        out_channels=7,
+        loss=dict(type='PSELoss'),
+        postprocessor=dict(type='PSEPostprocessor', text_repr_type='quad')),
+    train_cfg=None,
+    test_cfg=None)

configs/_base_/det_models/textsnake_r50_fpn_unet.py

@@ -0,0 +1,22 @@
+model = dict(
+    type='TextSnake',
+    backbone=dict(
+        type='mmdet.ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=-1,
+        norm_cfg=dict(type='BN', requires_grad=True),
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50'),
+        norm_eval=True,
+        style='caffe'),
+    neck=dict(
+        type='FPN_UNet', in_channels=[256, 512, 1024, 2048], out_channels=32),
+    bbox_head=dict(
+        type='TextSnakeHead',
+        in_channels=32,
+        loss=dict(type='TextSnakeLoss'),
+        postprocessor=dict(
+            type='TextSnakePostprocessor', text_repr_type='poly')),
+    train_cfg=None,
+    test_cfg=None)

configs/_base_/det_pipelines/dbnet_pipeline.py

@@ -0,0 +1,88 @@
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+
+train_pipeline_r18 = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='LoadTextAnnotations',
+        with_bbox=True,
+        with_mask=True,
+        poly2mask=False),
+    dict(type='ColorJitter', brightness=32.0 / 255, saturation=0.5),
+    dict(type='Normalize', **img_norm_cfg),
+    dict(
+        type='ImgAug',
+        args=[['Fliplr', 0.5],
+              dict(cls='Affine', rotate=[-10, 10]), ['Resize', [0.5, 3.0]]]),
+    dict(type='EastRandomCrop', target_size=(640, 640)),
+    dict(type='DBNetTargets', shrink_ratio=0.4),
+    dict(type='Pad', size_divisor=32),
+    dict(
+        type='CustomFormatBundle',
+        keys=['gt_shrink', 'gt_shrink_mask', 'gt_thr', 'gt_thr_mask'],
+        visualize=dict(flag=False, boundary_key='gt_shrink')),
+    dict(
+        type='Collect',
+        keys=['img', 'gt_shrink', 'gt_shrink_mask', 'gt_thr', 'gt_thr_mask'])
+]
+
+test_pipeline_1333_736 = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(1333, 736),  # used by Resize
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='Normalize', **img_norm_cfg),
+            dict(type='Pad', size_divisor=32),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img']),
+        ])
+]
+
+# for dbnet_r50dcnv2_fpnc
+img_norm_cfg_r50dcnv2 = dict(
+    mean=[122.67891434, 116.66876762, 104.00698793],
+    std=[58.395, 57.12, 57.375],
+    to_rgb=True)
+
+train_pipeline_r50dcnv2 = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='LoadTextAnnotations',
+        with_bbox=True,
+        with_mask=True,
+        poly2mask=False),
+    dict(type='ColorJitter', brightness=32.0 / 255, saturation=0.5),
+    dict(type='Normalize', **img_norm_cfg_r50dcnv2),
+    dict(
+        type='ImgAug',
+        args=[['Fliplr', 0.5],
+              dict(cls='Affine', rotate=[-10, 10]), ['Resize', [0.5, 3.0]]]),
+    dict(type='EastRandomCrop', target_size=(640, 640)),
+    dict(type='DBNetTargets', shrink_ratio=0.4),
+    dict(type='Pad', size_divisor=32),
+    dict(
+        type='CustomFormatBundle',
+        keys=['gt_shrink', 'gt_shrink_mask', 'gt_thr', 'gt_thr_mask'],
+        visualize=dict(flag=False, boundary_key='gt_shrink')),
+    dict(
+        type='Collect',
+        keys=['img', 'gt_shrink', 'gt_shrink_mask', 'gt_thr', 'gt_thr_mask'])
+]
+
+test_pipeline_4068_1024 = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(4068, 1024),  # used by Resize
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='Normalize', **img_norm_cfg_r50dcnv2),
+            dict(type='Pad', size_divisor=32),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img']),
+        ])
+]

configs/_base_/det_pipelines/drrg_pipeline.py

@@ -0,0 +1,60 @@
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+
+train_pipeline = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='LoadTextAnnotations',
+        with_bbox=True,
+        with_mask=True,
+        poly2mask=False),
+    dict(type='ColorJitter', brightness=32.0 / 255, saturation=0.5),
+    dict(type='Normalize', **img_norm_cfg),
+    dict(type='RandomScaling', size=800, scale=(0.75, 2.5)),
+    dict(
+        type='RandomCropFlip', crop_ratio=0.5, iter_num=1, min_area_ratio=0.2),
+    dict(
+        type='RandomCropPolyInstances',
+        instance_key='gt_masks',
+        crop_ratio=0.8,
+        min_side_ratio=0.3),
+    dict(
+        type='RandomRotatePolyInstances',
+        rotate_ratio=0.5,
+        max_angle=60,
+        pad_with_fixed_color=False),
+    dict(type='SquareResizePad', target_size=800, pad_ratio=0.6),
+    dict(type='RandomFlip', flip_ratio=0.5, direction='horizontal'),
+    dict(type='DRRGTargets'),
+    dict(type='Pad', size_divisor=32),
+    dict(
+        type='CustomFormatBundle',
+        keys=[
+            'gt_text_mask', 'gt_center_region_mask', 'gt_mask',
+            'gt_top_height_map', 'gt_bot_height_map', 'gt_sin_map',
+            'gt_cos_map', 'gt_comp_attribs'
+        ],
+        visualize=dict(flag=False, boundary_key='gt_text_mask')),
+    dict(
+        type='Collect',
+        keys=[
+            'img', 'gt_text_mask', 'gt_center_region_mask', 'gt_mask',
+            'gt_top_height_map', 'gt_bot_height_map', 'gt_sin_map',
+            'gt_cos_map', 'gt_comp_attribs'
+        ])
+]
+
+test_pipeline = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(1024, 640),  # used by Resize
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='Normalize', **img_norm_cfg),
+            dict(type='Pad', size_divisor=32),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img']),
+        ])
+]

configs/_base_/det_pipelines/fcenet_pipeline.py

@@ -0,0 +1,118 @@
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+
+# for icdar2015
+leval_prop_range_icdar2015 = ((0, 0.4), (0.3, 0.7), (0.6, 1.0))
+train_pipeline_icdar2015 = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='LoadTextAnnotations',
+        with_bbox=True,
+        with_mask=True,
+        poly2mask=False),
+    dict(
+        type='ColorJitter',
+        brightness=32.0 / 255,
+        saturation=0.5,
+        contrast=0.5),
+    dict(type='Normalize', **img_norm_cfg),
+    dict(type='RandomScaling', size=800, scale=(3. / 4, 5. / 2)),
+    dict(
+        type='RandomCropFlip', crop_ratio=0.5, iter_num=1, min_area_ratio=0.2),
+    dict(
+        type='RandomCropPolyInstances',
+        instance_key='gt_masks',
+        crop_ratio=0.8,
+        min_side_ratio=0.3),
+    dict(
+        type='RandomRotatePolyInstances',
+        rotate_ratio=0.5,
+        max_angle=30,
+        pad_with_fixed_color=False),
+    dict(type='SquareResizePad', target_size=800, pad_ratio=0.6),
+    dict(type='RandomFlip', flip_ratio=0.5, direction='horizontal'),
+    dict(type='Pad', size_divisor=32),
+    dict(
+        type='FCENetTargets',
+        fourier_degree=5,
+        level_proportion_range=leval_prop_range_icdar2015),
+    dict(
+        type='CustomFormatBundle',
+        keys=['p3_maps', 'p4_maps', 'p5_maps'],
+        visualize=dict(flag=False, boundary_key=None)),
+    dict(type='Collect', keys=['img', 'p3_maps', 'p4_maps', 'p5_maps'])
+]
+
+img_scale_icdar2015 = (2260, 2260)
+test_pipeline_icdar2015 = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=img_scale_icdar2015,  # used by Resize
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='Normalize', **img_norm_cfg),
+            dict(type='Pad', size_divisor=32),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img']),
+        ])
+]
+
+# for ctw1500
+leval_prop_range_ctw1500 = ((0, 0.25), (0.2, 0.65), (0.55, 1.0))
+train_pipeline_ctw1500 = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='LoadTextAnnotations',
+        with_bbox=True,
+        with_mask=True,
+        poly2mask=False),
+    dict(
+        type='ColorJitter',
+        brightness=32.0 / 255,
+        saturation=0.5,
+        contrast=0.5),
+    dict(type='Normalize', **img_norm_cfg),
+    dict(type='RandomScaling', size=800, scale=(3. / 4, 5. / 2)),
+    dict(
+        type='RandomCropFlip', crop_ratio=0.5, iter_num=1, min_area_ratio=0.2),
+    dict(
+        type='RandomCropPolyInstances',
+        instance_key='gt_masks',
+        crop_ratio=0.8,
+        min_side_ratio=0.3),
+    dict(
+        type='RandomRotatePolyInstances',
+        rotate_ratio=0.5,
+        max_angle=30,
+        pad_with_fixed_color=False),
+    dict(type='SquareResizePad', target_size=800, pad_ratio=0.6),
+    dict(type='RandomFlip', flip_ratio=0.5, direction='horizontal'),
+    dict(type='Pad', size_divisor=32),
+    dict(
+        type='FCENetTargets',
+        fourier_degree=5,
+        level_proportion_range=leval_prop_range_ctw1500),
+    dict(
+        type='CustomFormatBundle',
+        keys=['p3_maps', 'p4_maps', 'p5_maps'],
+        visualize=dict(flag=False, boundary_key=None)),
+    dict(type='Collect', keys=['img', 'p3_maps', 'p4_maps', 'p5_maps'])
+]
+
+img_scale_ctw1500 = (1080, 736)
+test_pipeline_ctw1500 = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=img_scale_ctw1500,  # used by Resize
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='Normalize', **img_norm_cfg),
+            dict(type='Pad', size_divisor=32),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img']),
+        ])
+]

configs/_base_/det_pipelines/maskrcnn_pipeline.py

@@ -0,0 +1,57 @@
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+
+train_pipeline = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+    dict(
+        type='ScaleAspectJitter',
+        img_scale=None,
+        keep_ratio=False,
+        resize_type='indep_sample_in_range',
+        scale_range=(640, 2560)),
+    dict(type='RandomFlip', flip_ratio=0.5),
+    dict(type='Normalize', **img_norm_cfg),
+    dict(
+        type='RandomCropInstances',
+        target_size=(640, 640),
+        mask_type='union_all',
+        instance_key='gt_masks'),
+    dict(type='Pad', size_divisor=32),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels', 'gt_masks']),
+]
+
+# for ctw1500
+img_scale_ctw1500 = (1600, 1600)
+test_pipeline_ctw1500 = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=img_scale_ctw1500,  # used by Resize
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(type='Normalize', **img_norm_cfg),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img']),
+        ])
+]
+
+# for icdar2015
+img_scale_icdar2015 = (1920, 1920)
+test_pipeline_icdar2015 = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=img_scale_icdar2015,  # used by Resize
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(type='Normalize', **img_norm_cfg),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img']),
+        ])
+]

configs/_base_/det_pipelines/panet_pipeline.py

@@ -0,0 +1,156 @@
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+
+# for ctw1500
+img_scale_train_ctw1500 = [(3000, 640)]
+shrink_ratio_train_ctw1500 = (1.0, 0.7)
+target_size_train_ctw1500 = (640, 640)
+train_pipeline_ctw1500 = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='LoadTextAnnotations',
+        with_bbox=True,
+        with_mask=True,
+        poly2mask=False),
+    dict(type='ColorJitter', brightness=32.0 / 255, saturation=0.5),
+    dict(type='Normalize', **img_norm_cfg),
+    dict(
+        type='ScaleAspectJitter',
+        img_scale=img_scale_train_ctw1500,
+        ratio_range=(0.7, 1.3),
+        aspect_ratio_range=(0.9, 1.1),
+        multiscale_mode='value',
+        keep_ratio=False),
+    # shrink_ratio is from big to small. The 1st must be 1.0
+    dict(type='PANetTargets', shrink_ratio=shrink_ratio_train_ctw1500),
+    dict(type='RandomFlip', flip_ratio=0.5, direction='horizontal'),
+    dict(type='RandomRotateTextDet'),
+    dict(
+        type='RandomCropInstances',
+        target_size=target_size_train_ctw1500,
+        instance_key='gt_kernels'),
+    dict(type='Pad', size_divisor=32),
+    dict(
+        type='CustomFormatBundle',
+        keys=['gt_kernels', 'gt_mask'],
+        visualize=dict(flag=False, boundary_key='gt_kernels')),
+    dict(type='Collect', keys=['img', 'gt_kernels', 'gt_mask'])
+]
+
+img_scale_test_ctw1500 = (3000, 640)
+test_pipeline_ctw1500 = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=img_scale_test_ctw1500,  # used by Resize
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='Normalize', **img_norm_cfg),
+            dict(type='Pad', size_divisor=32),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img']),
+        ])
+]
+
+# for icdar2015
+img_scale_train_icdar2015 = [(3000, 736)]
+shrink_ratio_train_icdar2015 = (1.0, 0.5)
+target_size_train_icdar2015 = (736, 736)
+train_pipeline_icdar2015 = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='LoadTextAnnotations',
+        with_bbox=True,
+        with_mask=True,
+        poly2mask=False),
+    dict(type='ColorJitter', brightness=32.0 / 255, saturation=0.5),
+    dict(type='Normalize', **img_norm_cfg),
+    dict(
+        type='ScaleAspectJitter',
+        img_scale=img_scale_train_icdar2015,
+        ratio_range=(0.7, 1.3),
+        aspect_ratio_range=(0.9, 1.1),
+        multiscale_mode='value',
+        keep_ratio=False),
+    dict(type='PANetTargets', shrink_ratio=shrink_ratio_train_icdar2015),
+    dict(type='RandomFlip', flip_ratio=0.5, direction='horizontal'),
+    dict(type='RandomRotateTextDet'),
+    dict(
+        type='RandomCropInstances',
+        target_size=target_size_train_icdar2015,
+        instance_key='gt_kernels'),
+    dict(type='Pad', size_divisor=32),
+    dict(
+        type='CustomFormatBundle',
+        keys=['gt_kernels', 'gt_mask'],
+        visualize=dict(flag=False, boundary_key='gt_kernels')),
+    dict(type='Collect', keys=['img', 'gt_kernels', 'gt_mask'])
+]
+
+img_scale_test_icdar2015 = (1333, 736)
+test_pipeline_icdar2015 = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=img_scale_test_icdar2015,  # used by Resize
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='Normalize', **img_norm_cfg),
+            dict(type='Pad', size_divisor=32),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img']),
+        ])
+]
+
+# for icdar2017
+img_scale_train_icdar2017 = [(3000, 800)]
+shrink_ratio_train_icdar2017 = (1.0, 0.5)
+target_size_train_icdar2017 = (800, 800)
+train_pipeline_icdar2017 = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='LoadTextAnnotations',
+        with_bbox=True,
+        with_mask=True,
+        poly2mask=False),
+    dict(type='ColorJitter', brightness=32.0 / 255, saturation=0.5),
+    dict(type='Normalize', **img_norm_cfg),
+    dict(
+        type='ScaleAspectJitter',
+        img_scale=img_scale_train_icdar2017,
+        ratio_range=(0.7, 1.3),
+        aspect_ratio_range=(0.9, 1.1),
+        multiscale_mode='value',
+        keep_ratio=False),
+    dict(type='PANetTargets', shrink_ratio=shrink_ratio_train_icdar2017),
+    dict(type='RandomFlip', flip_ratio=0.5, direction='horizontal'),
+    dict(type='RandomRotateTextDet'),
+    dict(
+        type='RandomCropInstances',
+        target_size=target_size_train_icdar2017,
+        instance_key='gt_kernels'),
+    dict(type='Pad', size_divisor=32),
+    dict(
+        type='CustomFormatBundle',
+        keys=['gt_kernels', 'gt_mask'],
+        visualize=dict(flag=False, boundary_key='gt_kernels')),
+    dict(type='Collect', keys=['img', 'gt_kernels', 'gt_mask'])
+]
+
+img_scale_test_icdar2017 = (1333, 800)
+test_pipeline_icdar2017 = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=img_scale_test_icdar2017,  # used by Resize
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='Normalize', **img_norm_cfg),
+            dict(type='Pad', size_divisor=32),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img']),
+        ])
+]

configs/_base_/det_pipelines/psenet_pipeline.py

@@ -0,0 +1,70 @@
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+
+train_pipeline = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='LoadTextAnnotations',
+        with_bbox=True,
+        with_mask=True,
+        poly2mask=False),
+    dict(type='ColorJitter', brightness=32.0 / 255, saturation=0.5),
+    dict(type='Normalize', **img_norm_cfg),
+    dict(
+        type='ScaleAspectJitter',
+        img_scale=[(3000, 736)],
+        ratio_range=(0.5, 3),
+        aspect_ratio_range=(1, 1),
+        multiscale_mode='value',
+        long_size_bound=1280,
+        short_size_bound=640,
+        resize_type='long_short_bound',
+        keep_ratio=False),
+    dict(type='PSENetTargets'),
+    dict(type='RandomFlip', flip_ratio=0.5, direction='horizontal'),
+    dict(type='RandomRotateTextDet'),
+    dict(
+        type='RandomCropInstances',
+        target_size=(640, 640),
+        instance_key='gt_kernels'),
+    dict(type='Pad', size_divisor=32),
+    dict(
+        type='CustomFormatBundle',
+        keys=['gt_kernels', 'gt_mask'],
+        visualize=dict(flag=False, boundary_key='gt_kernels')),
+    dict(type='Collect', keys=['img', 'gt_kernels', 'gt_mask'])
+]
+
+# for ctw1500
+img_scale_test_ctw1500 = (1280, 1280)
+test_pipeline_ctw1500 = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=img_scale_test_ctw1500,  # used by Resize
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='Normalize', **img_norm_cfg),
+            dict(type='Pad', size_divisor=32),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img']),
+        ])
+]
+
+# for icdar2015
+img_scale_test_icdar2015 = (2240, 2240)
+test_pipeline_icdar2015 = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=img_scale_test_icdar2015,  # used by Resize
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='Normalize', **img_norm_cfg),
+            dict(type='Pad', size_divisor=32),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img']),
+        ])
+]

configs/_base_/det_pipelines/textsnake_pipeline.py

@@ -0,0 +1,65 @@
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+
+train_pipeline = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='LoadTextAnnotations',
+        with_bbox=True,
+        with_mask=True,
+        poly2mask=False),
+    dict(type='ColorJitter', brightness=32.0 / 255, saturation=0.5),
+    dict(type='Normalize', **img_norm_cfg),
+    dict(
+        type='RandomCropPolyInstances',
+        instance_key='gt_masks',
+        crop_ratio=0.65,
+        min_side_ratio=0.3),
+    dict(
+        type='RandomRotatePolyInstances',
+        rotate_ratio=0.5,
+        max_angle=20,
+        pad_with_fixed_color=False),
+    dict(
+        type='ScaleAspectJitter',
+        img_scale=[(3000, 736)],  # unused
+        ratio_range=(0.7, 1.3),
+        aspect_ratio_range=(0.9, 1.1),
+        multiscale_mode='value',
+        long_size_bound=800,
+        short_size_bound=480,
+        resize_type='long_short_bound',
+        keep_ratio=False),
+    dict(type='SquareResizePad', target_size=800, pad_ratio=0.6),
+    dict(type='RandomFlip', flip_ratio=0.5, direction='horizontal'),
+    dict(type='TextSnakeTargets'),
+    dict(type='Pad', size_divisor=32),
+    dict(
+        type='CustomFormatBundle',
+        keys=[
+            'gt_text_mask', 'gt_center_region_mask', 'gt_mask',
+            'gt_radius_map', 'gt_sin_map', 'gt_cos_map'
+        ],
+        visualize=dict(flag=False, boundary_key='gt_text_mask')),
+    dict(
+        type='Collect',
+        keys=[
+            'img', 'gt_text_mask', 'gt_center_region_mask', 'gt_mask',
+            'gt_radius_map', 'gt_sin_map', 'gt_cos_map'
+        ])
+]
+
+test_pipeline = [
+    dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(1333, 736),  # used by Resize
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='Normalize', **img_norm_cfg),
+            dict(type='Pad', size_divisor=32),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img']),
+        ])
+]

configs/_base_/recog_datasets/MJ_train.py

@@ -0,0 +1,21 @@
+# Text Recognition Training set, including:
+# Synthetic Datasets: Syn90k
+
+train_root = 'data/mixture/Syn90k'
+
+train_img_prefix = f'{train_root}/mnt/ramdisk/max/90kDICT32px'
+train_ann_file = f'{train_root}/label.lmdb'
+
+train = dict(
+    type='OCRDataset',
+    img_prefix=train_img_prefix,
+    ann_file=train_ann_file,
+    loader=dict(
+        type='AnnFileLoader',
+        repeat=1,
+        file_format='lmdb',
+        parser=dict(type='LineJsonParser', keys=['filename', 'text'])),
+    pipeline=None,
+    test_mode=False)
+
+train_list = [train]

configs/_base_/recog_datasets/ST_MJ_alphanumeric_train.py

@@ -0,0 +1,31 @@
+# Text Recognition Training set, including:
+# Synthetic Datasets: SynthText, Syn90k
+# Both annotations are filtered so that
+# only alphanumeric terms are left
+
+train_root = 'data/mixture'
+
+train_img_prefix1 = f'{train_root}/Syn90k/mnt/ramdisk/max/90kDICT32px'
+train_ann_file1 = f'{train_root}/Syn90k/label.lmdb'
+
+train1 = dict(
+    type='OCRDataset',
+    img_prefix=train_img_prefix1,
+    ann_file=train_ann_file1,
+    loader=dict(
+        type='AnnFileLoader',
+        repeat=1,
+        file_format='lmdb',
+        parser=dict(type='LineJsonParser', keys=['filename', 'text'])),
+    pipeline=None,
+    test_mode=False)
+
+train_img_prefix2 = f'{train_root}/SynthText/' + \
+    'synthtext/SynthText_patch_horizontal'
+train_ann_file2 = f'{train_root}/SynthText/alphanumeric_label.lmdb'
+
+train2 = {key: value for key, value in train1.items()}
+train2['img_prefix'] = train_img_prefix2
+train2['ann_file'] = train_ann_file2
+
+train_list = [train1, train2]

configs/_base_/recog_datasets/ST_MJ_train.py

@@ -0,0 +1,29 @@
+# Text Recognition Training set, including:
+# Synthetic Datasets: SynthText, Syn90k
+
+train_root = 'data/mixture'
+
+train_img_prefix1 = f'{train_root}/Syn90k/mnt/ramdisk/max/90kDICT32px'
+train_ann_file1 = f'{train_root}/Syn90k/label.lmdb'
+
+train1 = dict(
+    type='OCRDataset',
+    img_prefix=train_img_prefix1,
+    ann_file=train_ann_file1,
+    loader=dict(
+        type='AnnFileLoader',
+        repeat=1,
+        file_format='lmdb',
+        parser=dict(type='LineJsonParser', keys=['filename', 'text'])),
+    pipeline=None,
+    test_mode=False)
+
+train_img_prefix2 = f'{train_root}/SynthText/' + \
+    'synthtext/SynthText_patch_horizontal'
+train_ann_file2 = f'{train_root}/SynthText/label.lmdb'
+
+train2 = {key: value for key, value in train1.items()}
+train2['img_prefix'] = train_img_prefix2
+train2['ann_file'] = train_ann_file2
+
+train_list = [train1, train2]

configs/_base_/recog_datasets/ST_SA_MJ_real_train.py

@@ -0,0 +1,81 @@
+# Text Recognition Training set, including:
+# Synthetic Datasets: SynthText, SynthAdd, Syn90k
+# Real Dataset: IC11, IC13, IC15, COCO-Test, IIIT5k
+
+train_prefix = 'data/mixture'
+
+train_img_prefix1 = f'{train_prefix}/icdar_2011'
+train_img_prefix2 = f'{train_prefix}/icdar_2013'
+train_img_prefix3 = f'{train_prefix}/icdar_2015'
+train_img_prefix4 = f'{train_prefix}/coco_text'
+train_img_prefix5 = f'{train_prefix}/IIIT5K'
+train_img_prefix6 = f'{train_prefix}/SynthText_Add'
+train_img_prefix7 = f'{train_prefix}/SynthText'
+train_img_prefix8 = f'{train_prefix}/Syn90k'
+
+train_ann_file1 = f'{train_prefix}/icdar_2011/train_label.txt',
+train_ann_file2 = f'{train_prefix}/icdar_2013/train_label.txt',
+train_ann_file3 = f'{train_prefix}/icdar_2015/train_label.txt',
+train_ann_file4 = f'{train_prefix}/coco_text/train_label.txt',
+train_ann_file5 = f'{train_prefix}/IIIT5K/train_label.txt',
+train_ann_file6 = f'{train_prefix}/SynthText_Add/label.txt',
+train_ann_file7 = f'{train_prefix}/SynthText/shuffle_labels.txt',
+train_ann_file8 = f'{train_prefix}/Syn90k/shuffle_labels.txt'
+
+train1 = dict(
+    type='OCRDataset',
+    img_prefix=train_img_prefix1,
+    ann_file=train_ann_file1,
+    loader=dict(
+        type='AnnFileLoader',
+        repeat=20,
+        file_format='txt',
+        parser=dict(
+            type='LineStrParser',
+            keys=['filename', 'text'],
+            keys_idx=[0, 1],
+            separator=' ')),
+    pipeline=None,
+    test_mode=False)
+
+train2 = {key: value for key, value in train1.items()}
+train2['img_prefix'] = train_img_prefix2
+train2['ann_file'] = train_ann_file2
+
+train3 = {key: value for key, value in train1.items()}
+train3['img_prefix'] = train_img_prefix3
+train3['ann_file'] = train_ann_file3
+
+train4 = {key: value for key, value in train1.items()}
+train4['img_prefix'] = train_img_prefix4
+train4['ann_file'] = train_ann_file4
+
+train5 = {key: value for key, value in train1.items()}
+train5['img_prefix'] = train_img_prefix5
+train5['ann_file'] = train_ann_file5
+
+train6 = dict(
+    type='OCRDataset',
+    img_prefix=train_img_prefix6,
+    ann_file=train_ann_file6,
+    loader=dict(
+        type='AnnFileLoader',
+        repeat=1,
+        file_format='txt',
+        parser=dict(
+            type='LineStrParser',
+            keys=['filename', 'text'],
+            keys_idx=[0, 1],
+            separator=' ')),
+    pipeline=None,
+    test_mode=False)
+
+train7 = {key: value for key, value in train6.items()}
+train7['img_prefix'] = train_img_prefix7
+train7['ann_file'] = train_ann_file7
+
+train8 = {key: value for key, value in train6.items()}
+train8['img_prefix'] = train_img_prefix8
+train8['ann_file'] = train_ann_file8
+
+train_list = [train1, train2, train3, train4, train5, train6, train7, train8]

configs/_base_/recog_datasets/ST_SA_MJ_train.py

@@ -0,0 +1,48 @@
+# Text Recognition Training set, including:
+# Synthetic Datasets: SynthText, Syn90k
+
+train_root = 'data/mixture'
+
+train_img_prefix1 = f'{train_root}/Syn90k/mnt/ramdisk/max/90kDICT32px'
+train_ann_file1 = f'{train_root}/Syn90k/label.lmdb'
+
+train1 = dict(
+    type='OCRDataset',
+    img_prefix=train_img_prefix1,
+    ann_file=train_ann_file1,
+    loader=dict(
+        type='AnnFileLoader',
+        repeat=1,
+        file_format='lmdb',
+        parser=dict(type='LineJsonParser', keys=['filename', 'text'])),
+    pipeline=None,
+    test_mode=False)
+
+train_img_prefix2 = f'{train_root}/SynthText/' + \
+    'synthtext/SynthText_patch_horizontal'
+train_ann_file2 = f'{train_root}/SynthText/label.lmdb'
+
+train_img_prefix3 = f'{train_root}/SynthText_Add'
+train_ann_file3 = f'{train_root}/SynthText_Add/label.txt'
+
+train2 = {key: value for key, value in train1.items()}
+train2['img_prefix'] = train_img_prefix2
+train2['ann_file'] = train_ann_file2
+
+train3 = dict(
+    type='OCRDataset',
+    img_prefix=train_img_prefix3,
+    ann_file=train_ann_file3,
+    loader=dict(
+        type='AnnFileLoader',
+        repeat=1,
+        file_format='txt',
+        parser=dict(
+            type='LineStrParser',
+            keys=['filename', 'text'],
+            keys_idx=[0, 1],
+            separator=' ')),
+    pipeline=None,
+    test_mode=False)
+
+train_list = [train1, train2, train3]

configs/_base_/recog_datasets/ST_charbox_train.py

@@ -0,0 +1,23 @@
+# Text Recognition Training set, including:
+# Synthetic Datasets: SynthText (with character level boxes)
+
+train_img_root = 'data/mixture'
+
+train_img_prefix = f'{train_img_root}/SynthText'
+
+train_ann_file = f'{train_img_root}/SynthText/instances_train.txt'
+
+train = dict(
+    type='OCRSegDataset',
+    img_prefix=train_img_prefix,
+    ann_file=train_ann_file,
+    loader=dict(
+        type='AnnFileLoader',
+        repeat=1,
+        file_format='txt',
+        parser=dict(
+            type='LineJsonParser', keys=['file_name', 'annotations', 'text'])),
+    pipeline=None,
+    test_mode=False)
+
+train_list = [train]

configs/_base_/recog_datasets/academic_test.py

@@ -0,0 +1,57 @@
+# Text Recognition Testing set, including:
+# Regular Datasets: IIIT5K, SVT, IC13
+# Irregular Datasets: IC15, SVTP, CT80
+
+test_root = 'data/mixture'
+
+test_img_prefix1 = f'{test_root}/IIIT5K/'
+test_img_prefix2 = f'{test_root}/svt/'
+test_img_prefix3 = f'{test_root}/icdar_2013/'
+test_img_prefix4 = f'{test_root}/icdar_2015/'
+test_img_prefix5 = f'{test_root}/svtp/'
+test_img_prefix6 = f'{test_root}/ct80/'
+
+test_ann_file1 = f'{test_root}/IIIT5K/test_label.txt'
+test_ann_file2 = f'{test_root}/svt/test_label.txt'
+test_ann_file3 = f'{test_root}/icdar_2013/test_label_1015.txt'
+test_ann_file4 = f'{test_root}/icdar_2015/test_label.txt'
+test_ann_file5 = f'{test_root}/svtp/test_label.txt'
+test_ann_file6 = f'{test_root}/ct80/test_label.txt'
+
+test1 = dict(
+    type='OCRDataset',
+    img_prefix=test_img_prefix1,
+    ann_file=test_ann_file1,
+    loader=dict(
+        type='AnnFileLoader',
+        repeat=1,
+        file_format='txt',
+        parser=dict(
+            type='LineStrParser',
+            keys=['filename', 'text'],
+            keys_idx=[0, 1],
+            separator=' ')),
+    pipeline=None,
+    test_mode=True)
+
+test2 = {key: value for key, value in test1.items()}
+test2['img_prefix'] = test_img_prefix2
+test2['ann_file'] = test_ann_file2
+
+test3 = {key: value for key, value in test1.items()}
+test3['img_prefix'] = test_img_prefix3
+test3['ann_file'] = test_ann_file3
+
+test4 = {key: value for key, value in test1.items()}
+test4['img_prefix'] = test_img_prefix4
+test4['ann_file'] = test_ann_file4
+
+test5 = {key: value for key, value in test1.items()}
+test5['img_prefix'] = test_img_prefix5
+test5['ann_file'] = test_ann_file5
+
+test6 = {key: value for key, value in test1.items()}
+test6['img_prefix'] = test_img_prefix6
+test6['ann_file'] = test_ann_file6
+
+test_list = [test1, test2, test3, test4, test5, test6]

configs/_base_/recog_datasets/seg_toy_data.py

@@ -0,0 +1,34 @@
+prefix = 'tests/data/ocr_char_ann_toy_dataset/'
+
+train = dict(
+    type='OCRSegDataset',
+    img_prefix=f'{prefix}/imgs',
+    ann_file=f'{prefix}/instances_train.txt',
+    loader=dict(
+        type='AnnFileLoader',
+        repeat=100,
+        file_format='txt',
+        parser=dict(
+            type='LineJsonParser', keys=['file_name', 'annotations', 'text'])),
+    pipeline=None,
+    test_mode=True)
+
+test = dict(
+    type='OCRDataset',
+    img_prefix=f'{prefix}/imgs',
+    ann_file=f'{prefix}/instances_test.txt',
+    loader=dict(
+        type='AnnFileLoader',
+        repeat=1,
+        file_format='txt',
+        parser=dict(
+            type='LineStrParser',
+            keys=['filename', 'text'],
+            keys_idx=[0, 1],
+            separator=' ')),
+    pipeline=None,
+    test_mode=True)
+
+train_list = [train]
+
+test_list = [test]

configs/_base_/recog_datasets/toy_data.py

@@ -0,0 +1,54 @@
+dataset_type = 'OCRDataset'
+
+root = 'tests/data/ocr_toy_dataset'
+img_prefix = f'{root}/imgs'
+train_anno_file1 = f'{root}/label.txt'
+
+train1 = dict(
+    type=dataset_type,
+    img_prefix=img_prefix,
+    ann_file=train_anno_file1,
+    loader=dict(
+        type='AnnFileLoader',
+        repeat=100,
+        file_format='txt',
+        file_storage_backend='disk',
+        parser=dict(
+            type='LineStrParser',
+            keys=['filename', 'text'],
+            keys_idx=[0, 1],
+            separator=' ')),
+    pipeline=None,
+    test_mode=False)
+
+train_anno_file2 = f'{root}/label.lmdb'
+train2 = dict(
+    type=dataset_type,
+    img_prefix=img_prefix,
+    ann_file=train_anno_file2,
+    loader=dict(
+        type='AnnFileLoader',
+        repeat=100,
+        file_format='lmdb',
+        file_storage_backend='disk',
+        parser=dict(type='LineJsonParser', keys=['filename', 'text'])),
+    pipeline=None,
+    test_mode=False)
+
+test_anno_file1 = f'{root}/label.lmdb'
+test = dict(
+    type=dataset_type,
+    img_prefix=img_prefix,
+    ann_file=test_anno_file1,
+    loader=dict(
+        type='AnnFileLoader',
+        repeat=1,
+        file_format='lmdb',
+        file_storage_backend='disk',
+        parser=dict(type='LineJsonParser', keys=['filename', 'text'])),
+    pipeline=None,
+    test_mode=True)
+
+train_list = [train1, train2]
+
+test_list = [test]

configs/_base_/recog_models/abinet.py

@@ -0,0 +1,70 @@
+# num_chars depends on the configuration of label_convertor. The actual
+# dictionary size is 36 + 1 (<BOS/EOS>).
+# TODO: Automatically update num_chars based on the configuration of
+# label_convertor
+num_chars = 37
+max_seq_len = 26
+
+label_convertor = dict(
+    type='ABIConvertor',
+    dict_type='DICT36',
+    with_unknown=False,
+    with_padding=False,
+    lower=True,
+)
+
+model = dict(
+    type='ABINet',
+    backbone=dict(type='ResNetABI'),
+    encoder=dict(
+        type='ABIVisionModel',
+        encoder=dict(
+            type='TransformerEncoder',
+            n_layers=3,
+            n_head=8,
+            d_model=512,
+            d_inner=2048,
+            dropout=0.1,
+            max_len=8 * 32,
+        ),
+        decoder=dict(
+            type='ABIVisionDecoder',
+            in_channels=512,
+            num_channels=64,
+            attn_height=8,
+            attn_width=32,
+            attn_mode='nearest',
+            use_result='feature',
+            num_chars=num_chars,
+            max_seq_len=max_seq_len,
+            init_cfg=dict(type='Xavier', layer='Conv2d')),
+    ),
+    decoder=dict(
+        type='ABILanguageDecoder',
+        d_model=512,
+        n_head=8,
+        d_inner=2048,
+        n_layers=4,
+        dropout=0.1,
+        detach_tokens=True,
+        use_self_attn=False,
+        pad_idx=num_chars - 1,
+        num_chars=num_chars,
+        max_seq_len=max_seq_len,
+        init_cfg=None),
+    fuser=dict(
+        type='ABIFuser',
+        d_model=512,
+        num_chars=num_chars,
+        init_cfg=None,
+        max_seq_len=max_seq_len,
+    ),
+    loss=dict(
+        type='ABILoss',
+        enc_weight=1.0,
+        dec_weight=1.0,
+        fusion_weight=1.0,
+        num_classes=num_chars),
+    label_convertor=label_convertor,
+    max_seq_len=max_seq_len,
+    iter_size=3)

configs/_base_/recog_models/crnn.py

@@ -0,0 +1,12 @@
+label_convertor = dict(
+    type='CTCConvertor', dict_type='DICT36', with_unknown=False, lower=True)
+
+model = dict(
+    type='CRNNNet',
+    preprocessor=None,
+    backbone=dict(type='VeryDeepVgg', leaky_relu=False, input_channels=1),
+    encoder=None,
+    decoder=dict(type='CRNNDecoder', in_channels=512, rnn_flag=True),
+    loss=dict(type='CTCLoss'),
+    label_convertor=label_convertor,
+    pretrained=None)

configs/_base_/recog_models/crnn_tps.py

@@ -0,0 +1,18 @@
+# model
+label_convertor = dict(
+    type='CTCConvertor', dict_type='DICT36', with_unknown=False, lower=True)
+
+model = dict(
+    type='CRNNNet',
+    preprocessor=dict(
+        type='TPSPreprocessor',
+        num_fiducial=20,
+        img_size=(32, 100),
+        rectified_img_size=(32, 100),
+        num_img_channel=1),
+    backbone=dict(type='VeryDeepVgg', leaky_relu=False, input_channels=1),
+    encoder=None,
+    decoder=dict(type='CRNNDecoder', in_channels=512, rnn_flag=True),
+    loss=dict(type='CTCLoss'),
+    label_convertor=label_convertor,
+    pretrained=None)

configs/_base_/recog_models/master.py

@@ -0,0 +1,61 @@
+label_convertor = dict(
+    type='AttnConvertor', dict_type='DICT90', with_unknown=True)
+
+model = dict(
+    type='MASTER',
+    backbone=dict(
+        type='ResNet',
+        in_channels=3,
+        stem_channels=[64, 128],
+        block_cfgs=dict(
+            type='BasicBlock',
+            plugins=dict(
+                cfg=dict(
+                    type='GCAModule',
+                    ratio=0.0625,
+                    n_head=1,
+                    pooling_type='att',
+                    is_att_scale=False,
+                    fusion_type='channel_add'),
+                position='after_conv2')),
+        arch_layers=[1, 2, 5, 3],
+        arch_channels=[256, 256, 512, 512],
+        strides=[1, 1, 1, 1],
+        plugins=[
+            dict(
+                cfg=dict(type='Maxpool2d', kernel_size=2, stride=(2, 2)),
+                stages=(True, True, False, False),
+                position='before_stage'),
+            dict(
+                cfg=dict(type='Maxpool2d', kernel_size=(2, 1), stride=(2, 1)),
+                stages=(False, False, True, False),
+                position='before_stage'),
+            dict(
+                cfg=dict(
+                    type='ConvModule',
+                    kernel_size=3,
+                    stride=1,
+                    padding=1,
+                    norm_cfg=dict(type='BN'),
+                    act_cfg=dict(type='ReLU')),
+                stages=(True, True, True, True),
+                position='after_stage')
+        ],
+        init_cfg=[
+            dict(type='Kaiming', layer='Conv2d'),
+            dict(type='Constant', val=1, layer='BatchNorm2d'),
+        ]),
+    encoder=None,
+    decoder=dict(
+        type='MasterDecoder',
+        d_model=512,
+        n_head=8,
+        attn_drop=0.,
+        ffn_drop=0.,
+        d_inner=2048,
+        n_layers=3,
+        feat_pe_drop=0.2,
+        feat_size=6 * 40),
+    loss=dict(type='TFLoss', reduction='mean'),
+    label_convertor=label_convertor,
+    max_seq_len=30)

configs/_base_/recog_models/nrtr_modality_transform.py

@@ -0,0 +1,11 @@
+label_convertor = dict(
+    type='AttnConvertor', dict_type='DICT36', with_unknown=True, lower=True)
+
+model = dict(
+    type='NRTR',
+    backbone=dict(type='NRTRModalityTransform'),
+    encoder=dict(type='NRTREncoder', n_layers=12),
+    decoder=dict(type='NRTRDecoder'),
+    loss=dict(type='TFLoss'),
+    label_convertor=label_convertor,
+    max_seq_len=40)