Upload 14 files

utils/__init__.py

@@ -0,0 +1,4 @@
+from utils.angelina_utils import *
+from utils.dsbi_utils import *
+from utils.kaggle_utils import *
+from utils.braille_natural_utils import *

utils/alpha_map.json

@@ -0,0 +1,65 @@
+{
+  "000001": "⠠",
+  "000010": "⠐",
+  "000011": "⠰",
+  "000100": "⠈",
+  "000101": "⠨",
+  "000110": "⠘",
+  "000111": "⠸",
+  "001000": "⠄",
+  "001001": "⠤",
+  "001010": "⠔",
+  "001011": "⠴",
+  "001100": "⠌",
+  "001101": "⠬",
+  "001110": "⠜",
+  "001111": "⠼",
+  "010000": "⠂",
+  "010001": "⠢",
+  "010010": "⠒",
+  "010011": "⠲",
+  "010100": "i",
+  "010101": "⠪",
+  "010110": "j",
+  "010111": "w",
+  "011000": "⠆",
+  "011001": "⠦",
+  "011010": "⠖",
+  "011011": "⠶",
+  "011100": "s",
+  "011101": "⠮",
+  "011110": "t",
+  "011111": "⠾",
+  "100000": "a",
+  "100001": "⠡",
+  "100010": "e",
+  "100011": "⠱",
+  "100100": "c",
+  "100101": "⠩",
+  "100110": "d",
+  "100111": "⠹",
+  "101000": "k",
+  "101001": "u",
+  "101010": "o",
+  "101011": "z",
+  "101100": "m",
+  "101101": "x",
+  "101110": "n",
+  "101111": "y",
+  "110000": "basement",
+  "110001": "⠣",
+  "110010": "h",
+  "110011": "⠳",
+  "110100": "f",
+  "110101": "⠫",
+  "110110": "g",
+  "110111": "⠻",
+  "111000": "l",
+  "111001": "⠧",
+  "111010": "r",
+  "111011": "⠷",
+  "111100": "p",
+  "111101": "v",
+  "111110": "q",
+  "111111": "⠿"
+}

utils/alphabet_map.json

@@ -0,0 +1,34 @@
+{
+  "a": "100000",
+  "b": "110000",
+  "c": "100100",
+  "d": "100110",
+  "e": "100010",
+  "f": "110100",
+  "g": "110110",
+  "h": "110010",
+
+  "i": "010100",
+  "j": "010110",
+
+  "k": "101000",
+  "l": "111000",
+  "m": "101100",
+  "n": "101110",
+  "o": "101010",
+  "p": "111100",
+  "q": "111110",
+  "r": "111010",
+
+  "s": "011100",
+  "t": "011110",
+
+  "u": "101001",
+  "v": "111001",
+
+  "w": "010111",
+  
+  "x": "101101",
+  "y": "101111",
+  "z": "101011"
+}

utils/angelina_utils.py

@@ -0,0 +1,387 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+"""
+Braille symbols declaration
+"""
+
+import numpy as np
+
+
+def angelina_label_map():
+    # constants for special symbols label
+    num_sign = "##"
+    caps_sign = "CC"
+    markout_sign = "XX"
+
+    # general symbols common for various languages
+    sym_map = {
+        "256": ".",
+        "2": ",",
+        "25": ":",
+        "26": "?",
+        "23": ";",
+        "235": "!",
+        "2356": "()",  # postprocess to (, ). Labeled as ((, )), ()
+        "126": "(",
+        "345": ")",
+        "36": "-",
+        "34": "/",
+        "3456": num_sign,
+        "123456": markout_sign,
+        # '6': "en",
+        # '46': "EN",  # TODO only for Russian ?
+    }
+
+    # RU symbols
+    alpha_map_RU = {
+        "1": "а",
+        "12": "б",
+        "2456": "в",
+        "1245": "г",
+        "145": "д",
+        "15": "е",
+        "16": "ё",
+        "245": "ж",
+        "1356": "з",
+        "24": "и",
+        "12346": "й",
+        "13": "к",
+        "123": "л",
+        "134": "м",
+        "1345": "н",  # preprocess to № if followed by number
+        "135": "о",
+        "1234": "п",
+        "1235": "р",
+        "234": "с",
+        "2345": "т",
+        "136": "у",
+        "124": "ф",
+        "125": "х",
+        "14": "ц",
+        "12345": "ч",
+        "156": "ш",
+        "1346": "щ",
+        "12356": "ъ",
+        "2346": "ы",
+        "23456": "ь",
+        "246": "э",
+        "1256": "ю",
+        "1246": "я",
+        "45": caps_sign,
+        "236": "«",  # <<
+        "356": "»",  # >>
+        "4": "'",
+        "456": "|",
+        "346": "§",  # mark as &&
+    }
+
+    # UZ symbols
+    alpha_map_UZ = {
+        **alpha_map_RU,
+        "1236": "ў",
+        "13456": "қ",
+        "12456": "ғ",
+        "1456": "ҳ",
+    }
+
+    # EN symbols
+    alpha_map_EN = {
+        "1": "a",
+        "12": "b",
+        "14": "c",
+        "145": "d",
+        "15": "e",
+        "124": "f",
+        "1245": "g",
+        "125": "h",
+        "24": "i",
+        "245": "j",
+        "13": "k",
+        "123": "l",
+        "134": "m",
+        "1345": "n",
+        "135": "o",
+        "1234": "p",
+        "12345": "q",
+        "1235": "r",
+        "234": "s",
+        "2345": "t",
+        "136": "u",
+        "1236": "v",
+        "2456": "w",
+        "1346": "x",
+        "13456": "y",
+        "1356": "z",
+        #'6': caps_sign, # TODO duplicate оf RU caps_sign
+        "3": "'",
+        "236": "«",  # <<
+        "356": "»",  # >>
+        # '236': '"',  # mark as <<
+        # '356': '"',  # mark as >>
+    }
+
+    # UZL symbols
+    alpha_map_UZL = {
+        **alpha_map_EN,
+        "1236": "o`",
+        "12456": "g`",
+        "156": "sh",
+        "12345": "ch",
+    }
+
+    # Greek letters
+    alpha_map_GR = {
+        "1": "α",
+        "12": "β",
+        "1245": "γ",
+        "145": "δ",
+        "15": "ε",
+        "1356": "ζ",
+        "345": "η",
+        "1456": "θ",
+        "24": "ι",
+        "13": "κ",
+        "123": "λ",
+        "134": "μ",
+        "1345": "ν",
+        "1346": "ξ",
+        "135": "ο",
+        "1234": "π",
+        "1235": "ρ",
+        "234": "σ",
+        "2345": "τ",
+        "13456": "υ",
+        "124": "φ",
+        "125": "χ",
+        "12346": "ψ",
+        "245": "ω",
+        "46": caps_sign,
+        "5": "'",  # stress
+        "126": "αι",
+        "146": "ει",
+        "246": "οι",
+        "12456": "υι",
+        "16": "αυ",
+        "156": "ευ",
+        "1256": "ηυ",
+        "136": "ου",
+    }
+
+    # Latvian letters
+    alpha_map_LV = {
+        "1": "a",
+        "16": "ā",
+        "12": "b",
+        "14": "c",
+        "146": "č",
+        "145": "d",
+        "15": "e",
+        "156": "ē",
+        "124": "f",
+        "1245": "g",
+        "12456": "ģ",
+        "125": "h",
+        "24": "i",
+        "246": "ī",
+        "245": "j",
+        "13": "k",
+        "136": "ķ",
+        "123": "l",
+        "1236": "ļ",
+        "134": "m",
+        "1345": "n",
+        "13456": "ņ",
+        "135": "o",
+        "1234": "p",
+        "1235": "r",
+        "234": "s",
+        "2346": "š",
+        "2345": "t",
+        "34": "u",
+        "346": "ū",
+        "2456": "v",
+        "345": "z",
+        "3456": "ž",
+        "46": caps_sign,
+    }
+
+    # PL symbols
+    alpha_map_PL = {
+        **alpha_map_EN,
+        "16": "ą",
+        "146": "ć",
+        "156": "ę",
+        "126": "ł",
+        "1456": "ń",
+        "346": "ó",
+        "246": "ś",
+        "2346": "ź",
+        "12346": "ż",
+        "3": ".",
+        "256": "/",
+        "34": "\\",
+    }
+
+    # DE symbols
+    alpha_map_DE = {
+        "236": '"',
+        "356": '"',
+        "35": "*",
+        "235": "+",
+        "2": ",",
+        "36": "-",
+        "3": ".",
+        "346": "ie",
+        "16": "au",
+        "126": "eu",
+        "146": "ei",
+        "1456": "ch",
+        "156": "sch",
+        "1256": "ü",
+        "246": "ö",
+        "25": ":",
+        "23": ";",
+        "2356": "=",
+        "26": "?",
+        "345": "ä",
+        "1": "a",
+        "12": "b",
+        "14": "c",
+        "145": "d",
+        "15": "e",
+        "124": "f",
+        "1245": "g",
+        "125": "h",
+        "24": "i",
+        "245": "j",
+        "13": "k",
+        "123": "l",
+        "134": "m",
+        "1345": "n",
+        "135": "o",
+        "1234": "p",
+        "12345": "q",
+        "1235": "r",
+        "234": "s",
+        "2345": "t",
+        "136": "u",
+        "1236": "v",
+        "2456": "w",
+        "1346": "x",
+        "13456": "y",
+        "1356": "z",
+        "34": "äu",
+        "23456": "st",
+        "2346": "ß",
+        "46": caps_sign,
+    }
+
+    # Digit symbols (after num_sign)
+    num_map = {
+        "1": "1",
+        "12": "2",
+        "14": "3",
+        "145": "4",
+        "15": "5",
+        "124": "6",
+        "1245": "7",
+        "125": "8",
+        "24": "9",
+        "245": "0",
+    }
+
+    # Digits in denominators of fraction
+    num_denominator_map = {
+        "2": "/1",
+        "23": "/2",
+        "25": "/3",
+        "256": "/4",
+        "26": "/5",
+        "235": "/6",
+        "2356": "/7",
+        "236": "/8",
+        "35": "/9",
+        "356": "/0",  # postprocess num 0 /0 to %
+    }
+
+    # Symbols for Math Braille (in Russian braille, I suppose)
+    math_RU = {
+        "2": ",",  # decimal separator
+        "3": "..",  # postprocess to "." (thousand separator) if between digits else to * (multiplication).
+        "235": "+",
+        "36": "-",
+        "236": "*",
+        "256": "::",  # postprocess to ":" (division).
+        "246": "<",
+        "135": ">",
+        "2356": "=",
+        "126": "(",
+        "345": ")",
+        "12356": "[",
+        "23456": "]",
+        "246": "{",
+        "135": "}",
+        "456": "|",
+        "6": "en",
+        "46": "EN",
+    }
+
+    # Codes for dicts
+    letter_dicts = {
+        "SYM": sym_map,
+        "RU": alpha_map_RU,
+        "EN": alpha_map_EN,
+        "EN2": alpha_map_EN,
+        "GR": alpha_map_GR,
+        "LV": alpha_map_LV,
+        "PL": alpha_map_PL,
+        "DE": alpha_map_DE,
+        "UZ": alpha_map_UZ,
+        "UZL": alpha_map_UZL,
+        "NUM": num_map,
+        "NUM_DENOMINATOR": num_denominator_map,
+        "MATH_RU": math_RU,
+    }
+
+    return letter_dicts
+
+
+def reversed_mapping(angelina_map=angelina_label_map()):
+    concat_dict = {}
+
+    for key in angelina_map.keys():
+        single_dict = angelina_map[key]
+        # invert single_dict
+        inverted_dict = {v: k for k, v in single_dict.items()}
+        for k, v in inverted_dict.items():
+            concat_dict[k] = v
+
+    return concat_dict
+
+
+def transform_angelina_label(russian_label, mapping=reversed_mapping()):
+    russian_label = russian_label.strip()
+    if russian_label in mapping.keys():
+        return mapping[russian_label]
+    else:
+        # remove "~" from russian_label if russian_label is numeric
+        russian_label = russian_label.replace("~", "")
+        if russian_label.isnumeric():
+            return russian_label
+        # other cases where letters are capitalized
+        else:
+            if russian_label.lower() in mapping.keys():
+                return mapping[russian_label.lower()]
+            # other cases where letters are special letters
+            else:
+                if russian_label == "CC" or russian_label == "CC":  # capitalize
+                    return "46"
+                elif russian_label == "ХХ":  # markout
+                    return "123456"
+                elif russian_label == ">>":
+                    return "356"
+                elif russian_label == "<<":
+                    return "236"
+                else:
+                    print(russian_label)
+                    return "46"

utils/braille_map.json

@@ -0,0 +1,65 @@
+{
+  "000001": "⠠",
+  "000010": "⠐",
+  "000011": "⠰",
+  "000100": "⠈",
+  "000101": "⠨",
+  "000110": "⠘",
+  "000111": "⠸",
+  "001000": "⠄",
+  "001001": "⠤",
+  "001010": "⠔",
+  "001011": "⠴",
+  "001100": "⠌",
+  "001101": "⠬",
+  "001110": "⠜",
+  "001111": "⠼",
+  "010000": "⠂",
+  "010001": "⠢",
+  "010010": "⠒",
+  "010011": "⠲",
+  "010100": "⠊",
+  "010101": "⠪",
+  "010110": "⠚",
+  "010111": "⠺",
+  "011000": "⠆",
+  "011001": "⠦",
+  "011010": "⠖",
+  "011011": "⠶",
+  "011100": "⠎",
+  "011101": "⠮",
+  "011110": "⠞",
+  "011111": "⠾",
+  "100000": "⠁",
+  "100001": "⠡",
+  "100010": "⠑",
+  "100011": "⠱",
+  "100100": "⠉",
+  "100101": "⠩",
+  "100110": "⠙",
+  "100111": "⠹",
+  "101000": "⠅",
+  "101001": "⠥",
+  "101010": "⠕",
+  "101011": "⠵",
+  "101100": "⠍",
+  "101101": "⠭",
+  "101110": "⠝",
+  "101111": "⠽",
+  "110000": "⠃",
+  "110001": "⠣",
+  "110010": "⠓",
+  "110011": "⠳",
+  "110100": "⠋",
+  "110101": "⠫",
+  "110110": "⠛",
+  "110111": "⠻",
+  "111000": "⠇",
+  "111001": "⠧",
+  "111010": "⠗",
+  "111011": "⠷",
+  "111100": "⠏",
+  "111101": "⠯",
+  "111110": "⠟",
+  "111111": "⠿"
+}

utils/braille_natural_utils.py

@@ -0,0 +1,19 @@
+from PIL import Image
+
+
+def get_label(label_path):
+    with open(label_path, "r") as f:
+        label = f.readlines()
+    label = [line.strip().split(" ") for line in label]
+    # label is in yolo format, remove class in the first item of the row
+    label = [line[1:] for line in label]
+
+    # convert to float
+    label = [[float(item) for item in line] for line in label]
+
+    return label
+
+
+def get_image(img_path):
+    img = Image.open(img_path)
+    return img

utils/dsbi_utils.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python
+# coding: utf-8
+"""
+Utils for DSBI dataset (https://github.com/yeluo1994/DSBI)
+Written by IlyaOvodov (https://github.com/IlyaOvodov/AngelinaDataset)
+"""
+import collections
+
+CellInfo = collections.namedtuple(
+    "CellInfo",
+    [
+        "row",
+        "col",  # row and column in a symbol grid
+        "left",
+        "top",
+        "right",
+        "bottom",  # symbol corner coordinates in pixels
+        "label",
+    ],
+)  # symbol label either like '246' or '010101' format
+
+
+def read_txt(file_txt, binary_label=True):
+    """
+    Loads Braille annotation from DSBI annotation txt file
+    :param file_txt: filename of txt file
+    :param binary_label: return symbol label in binary format, like '010101' (if True),
+        or human readable like '246' (if False)
+    :return: tuple (
+        angle: value from 1st line of annotation file,
+        h_lines: list of horizontal lines Y-coordinates,
+        v_lines: list of vertical lines X-coordinates,,
+        cells: symbols as list of CellInfo
+    )
+    None, None, None, None for empty annotation
+    """
+    with open(file_txt, "r") as f:
+        l = f.readlines()
+        if len(l) < 3:
+            return None, None, None, None
+        angle = eval(l[0])
+        v_lines = list(map(eval, l[1].split(" ")))
+        assert len(v_lines) % 2 == 0, (file_txt, len(v_lines))
+        h_lines = list(map(eval, l[2].split(" ")))
+        assert len(h_lines) % 3 == 0, (file_txt, len(h_lines))
+        cells = []
+        for cell_ln in l[3:]:
+            cell_nums = list(cell_ln[:-1].split(" "))  # exclude last '\n'
+            assert len(cell_nums) == 8, (file_txt, cell_ln)
+            row = eval(cell_nums[0])
+            col = eval(cell_nums[1])
+            if binary_label:
+                label = "".join(cell_nums[2:])
+            else:
+                label = ""
+                for i, c in enumerate(cell_nums[2:]):
+                    if c == "1":
+                        label += str(i + 1)
+                    else:
+                        assert c == "0", (file_txt, cell_ln, i, c)
+            left = v_lines[(col - 1) * 2]
+            right = v_lines[(col - 1) * 2 + 1]
+            top = h_lines[(row - 1) * 3]
+            bottom = h_lines[(row - 1) * 3 + 2]
+            cells.append(
+                CellInfo(
+                    row=row,
+                    col=col,
+                    left=left,
+                    top=top,
+                    right=right,
+                    bottom=bottom,
+                    label=label,
+                )
+            )
+    return angle, h_lines, v_lines, cells
+
+
+def read_DSBI_annotation(label_filename, width, height, rect_margin, get_points):
+    """
+    Loads Braille annotation from DSBI annotation txt file in albumentations format
+    :param label_filename: filename of txt file
+    :param width: image width
+    :param height: image height
+    :param rect_margin:
+    :param get_points: Points or Symbols mode
+    :return:
+        List of symbol rects if get_points==False. Each rect is a tuple (left, top, right, bottom, label) where
+        left..bottom are in [0,1], label is int in [1..63]. Symbol size is extended to rect_margin*width of symbol
+        in every side.
+        List of points rects if get_points==True. Each point is a tuple (left, top, right, bottom, label) where
+        left..bottom are in [0,1], label is 0. Width and height of point is 2*rect_margin*width of symbol
+    """
+    _, _, _, cells = read_txt(label_filename, binary_label=True)
+    if cells is not None:
+        if get_points:
+            rects = []
+            for cl in cells:
+                w = int((cl.right - cl.left) * rect_margin)
+                h = w
+                for i in range(6):
+                    if cl.label[i] == "1":
+                        iy = i % 3
+                        ix = i - iy
+                        if ix == 0:
+                            xc = cl.left
+                        else:
+                            xc = cl.right
+                        left, right = xc - w, xc + w
+                        if iy == 0:
+                            yc = cl.top
+                        elif iy == 1:
+                            yc = (cl.top + cl.bottom) // 2
+                        else:
+                            yc = cl.bottom
+                        top, bottom = yc - h, yc + h
+                        rects.append(
+                            [
+                                left / width,
+                                top / height,
+                                right / width,
+                                bottom / height,
+                                0,
+                            ]
+                        )
+        else:
+            rects = [
+                (
+                    (c.left - rect_margin * (c.right - c.left)),
+                    (c.top - rect_margin * (c.right - c.left)),
+                    (c.right + rect_margin * (c.right - c.left)),
+                    (c.bottom + rect_margin * (c.right - c.left)),
+                    c.label,
+                )
+                for c in cells
+                if c.label != "000000"
+            ]
+    else:
+        rects = []
+    return rects

utils/kaggle_utils.py

@@ -0,0 +1,9 @@
+import json
+
+
+def get_alphabet_map(path="./src/utils/alphabet_map.json"):
+
+    with open(path, "r") as f:
+        alphabet_map = json.load(f)
+
+    return alphabet_map

utils/number_map.json

@@ -0,0 +1,66 @@
+{
+    "000001": "⠠",
+    "000010": "⠐",
+    "000011": "⠰",
+    "000100": "⠈",
+    "000101": "⠨",
+    "000110": "⠘",
+    "000111": "⠸",
+    "001000": "⠄",
+    "001001": "⠤",
+    "001010": "⠔",
+    "001011": "⠴",
+    "001100": "⠌",
+    "001101": "⠬",
+    "001110": "⠜",
+    "001111": "floor",
+    "010000": "⠂",
+    "010001": "⠢",
+    "010010": "⠒",
+    "010011": "⠲",
+    "010100": "9",
+    "010101": "⠪",
+    "010110": "0",
+    "010111": "⠺",
+    "011000": "⠆",
+    "011001": "⠦",
+    "011010": "⠖",
+    "011011": "⠶",
+    "011100": "⠎",
+    "011101": "⠮",
+    "011110": "⠞",
+    "011111": "⠾",
+    "100000": "1",
+    "100001": "⠡",
+    "100010": "5",
+    "100011": "⠱",
+    "100100": "3",
+    "100101": "⠩",
+    "100110": "4",
+    "100111": "⠹",
+    "101000": "⠅",
+    "101001": "⠥",
+    "101010": "⠕",
+    "101011": "⠵",
+    "101100": "⠍",
+    "101101": "⠭",
+    "101110": "⠝",
+    "101111": "⠽",
+    "110000": "2",
+    "110001": "⠣",
+    "110010": "8",
+    "110011": "⠳",
+    "110100": "6",
+    "110101": "⠫",
+    "110110": "7",
+    "110111": "⠻",
+    "111000": "⠇",
+    "111001": "⠧",
+    "111010": "⠗",
+    "111011": "⠷",
+    "111100": "⠏",
+    "111101": "⠯",
+    "111110": "⠟",
+    "111111": "⠿"
+  }
+