5D_Heredero_Louis_TM2022/python/qr_scanner.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
This module can be used to scan QR-Codes

(C) 2022 Louis Heredero  louis.heredero@edu.vs.ch
"""

import cv2
import numpy as np
from math import sqrt, degrees, atan2, radians, cos, sin
import imutils

DB_WIN = False

TOL_CNT_DIST = 10  # Tolerance distance between finders' centers
MASKS = [
    lambda x,y: (x+y)%2 == 0,
    lambda x,y: y%2 == 0,
    lambda x,y: (x)%3 == 0,
    lambda x,y: (x+y)%3 == 0,
    lambda x,y: (y//2+x//3)%2 == 0,
    lambda x,y: ((x*y)%2 + (x*y)%3) == 0,
    lambda x,y: ((x*y)%2 + (x*y)%3)%2 == 0,
    lambda x,y: ((x+y)%2 + (x*y)%3)%2 == 0
]

ALIGNMENT_PATTERN_LOCATIONS = [
    [],
    [6, 18],
    [6, 22],
    [6, 26],
    [6, 30],
    [6, 34],
    [6, 22, 38],
    [6, 24, 42],
    [6, 26, 46],
    [6, 28, 50],
    [6, 30, 54],
    [6, 32, 58],
    [6, 34, 62],
    [6, 26, 46, 66],
    [6, 26, 48, 70],
    [6, 26, 50, 74],
    [6, 30, 54, 78],
    [6, 30, 56, 82],
    [6, 30, 58, 86],
    [6, 34, 62, 90],
    [6, 28, 50, 72, 94],
    [6, 26, 50, 74, 98],
    [6, 30, 54, 78, 102],
    [6, 28, 54, 80, 106],
    [6, 32, 58, 84, 110],
    [6, 30, 58, 86, 114],
    [6, 34, 62, 90, 118],
    [6, 26, 50, 74, 98, 122],
    [6, 30, 54, 78, 102, 126],
    [6, 26, 52, 78, 104, 130],
    [6, 30, 56, 82, 108, 134],
    [6, 34, 60, 86, 112, 138],
    [6, 30, 58, 86, 114, 142],
    [6, 34, 62, 90, 118, 146],
    [6, 30, 54, 78, 102, 126, 150],
    [6, 24, 50, 76, 102, 128, 154],
    [6, 28, 54, 80, 106, 132, 158],
    [6, 32, 58, 84, 110, 136, 162],
    [6, 26, 54, 82, 110, 138, 166],
    [6, 30, 58, 86, 114, 142, 170]
]

VERSIONS = []
with open("qr_versions.txt", "r") as f:
    versions = f.read().split("\n\n")
    for v in versions:
        lvls = [list(map(int, lvl.split("\t"))) for lvl in v.split("\n")]
        VERSIONS.append(lvls)
VERSIONS = np.array(VERSIONS)

ERROR_CORRECTION =  []
with open("error_correction.txt", "r") as f:
    ecs = f.read().split("\n\n")
    for ec in ecs:
        lvls = [list(map(int, lvl.split("\t"))) for lvl in ec.split("\n")]
        lvls = [lvl + [0]*(6-len(lvl)) for lvl in lvls]
        
        ERROR_CORRECTION.append(lvls)
ERROR_CORRECTION = np.array(ERROR_CORRECTION)

EC_PARAMS =  []
with open("ec_params.txt", "r") as f:
    ecs = f.read().split("\n\n")
    for ec in ecs:
        lvls = [list(map(int, lvl.split("\t"))) for lvl in ec.split("\n") if lvl]
        EC_PARAMS.append(lvls)
EC_PARAMS = np.array(EC_PARAMS)

ALPHANUM = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:"

class GF:
    def __init__(self, val):
        self.val = val

    def copy(self):
        return GF(self.val)

    def __add__(self, n):
        return GF(self.val ^ n.val)

    def __sub__(self, n):
        return GF(self.val ^ n.val)

    def __mul__(self, n):
        if self.val == 0 or n.val == 0:
            return GF(0)

        return GF.EXP[GF.LOG[self.val].val + GF.LOG[n.val].val].copy()

    def __truediv__(self, n):
        if n.val == 0:
            raise ZeroDivisionError
        if self.val == 0:
            return GF(0)

        return GF.EXP[(GF.LOG[self.val].val + 255 - GF.LOG[n.val].val)%255].copy()

    def __pow__(self, n):
        return GF.EXP[(GF.LOG[self.val].val * n.val)%255].copy()

    def __repr__(self):
        return self.val.__repr__()
    
    def log(self):
        return GF.LOG[self.val]

GF.EXP = [GF(0)]*512
GF.LOG = [GF(0)]*256
value = 1
for exponent in range(255):
    GF.LOG[value] = GF(exponent)
    GF.EXP[exponent] = GF(value)
    value = ((value << 1) ^ 285) if value > 127 else value << 1

for i in range(255, 512):
    GF.EXP[i] = GF.EXP[i-255].copy()


class Poly:
    def __init__(self, coefs):
        self.coefs = coefs.copy()

    @property
    def deg(self):
        return len(self.coefs)

    def copy(self):
        return Poly(self.coefs)

    def __add__(self, p):
        d1, d2 = self.deg, p.deg
        deg = max(d1,d2)
        result = [GF(0) for i in range(deg)]
        
        for i in range(d1):
            result[i + deg - d1] = self.coefs[i]

        for i in range(d2):
            result[i + deg - d2] += p.coefs[i]
        
        return Poly(result)

    def __mul__(self, p):
        result = [GF(0) for i in range(self.deg+p.deg-1)]

        for i in range(p.deg):
            for j in range(self.deg):
                result[i+j] += self.coefs[j] * p.coefs[i]

        return Poly(result)

    def __truediv__(self, p):
        dividend = self.coefs.copy()
        dividend += [GF(0) for i in range(p.deg-1)]
        quotient = []

        for i in range(self.deg):
            coef = dividend[i] / p.coefs[0]
            quotient.append(coef)

            for j in range(p.deg):
                dividend[i+j] -= p.coefs[j] * coef

        while dividend[0].val == 0:
            dividend.pop(0)

        return [Poly(quotient), Poly(dividend)]

    def __repr__(self):
        return f"<Poly {self.coefs}>"
    
    def eval(self, x):
        y = GF(0)
        
        for i in range(self.deg):
            y += self.coefs[i] * x**GF(self.deg-i-1)
        
        return y
    
    def del_lead_zeros(self):
        while len(self.coefs) > 1 and self.coefs[0].val == 0:
            self.coefs.pop(0)
        
        if len(self.coefs) == 0:
            self.coefs = [GF(0)]
        
        return self

def center(c):
    M = cv2.moments(c)
    
    if M["m00"] != 0:
        cX = int(M["m10"] / M["m00"])
        cY = int(M["m01"] / M["m00"])
        return (cX, cY)
    
    return (None, None)

def dist(p1, p2):
    return sqrt((p2[0]-p1[0])**2 + (p2[1]-p1[1])**2)

def rotate(o, p, a):
    ox, oy = o
    px, py = p
    a = radians(a)
    c, s = cos(a), sin(a)
    
    return [
        int(ox + c*(px-ox) - s * (py-oy)),
        int(oy + s*(px-ox) + c * (py-oy))
    ]

def rotate_cnt(cnt, o, a):
    c = cnt
    pts = c[:, 0, :]
    pts = np.array([rotate(o, p, a) for p in pts])
    c[:, 0, :] = pts
    
    return c.astype(np.int32)

def is_finder(i, cnts, hrcy):
    c1 = cnts[i]
    h1 = hrcy[0][i]
    cX1, cY1 = center(c1)
    if len(c1) != 4:
        return False
    
    if cX1 is None:
        return False
    
    if h1[2] == -1:
        return False
    
    i2 = h1[2]
    c2 = cnts[i2]
    h2 = hrcy[0][i2]
    cX2, cY2 = center(c2)
    if cX2 is None:
        return False
    
    if len(c2) != 4:
        return False
    
    if abs(dist((cX1, cY1), (cX2, cY2))) > TOL_CNT_DIST:
        return False
    
    if h2[2] == -1:
        return False
    
    i3 = h2[2]
    c3 = cnts[i3]
    h3 = hrcy[0][i3]
    cX3, cY3 = center(c3)
    
    if len(c3) != 4:
        return False
    
    if cX3 is None:
        return False
    
    if abs(dist((cX1, cY1), (cX3, cY3))) > TOL_CNT_DIST:
        return False
    
    return True

def decode(img):
    grey = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    grey = cv2.GaussianBlur(grey, (5,5), 0)
    #if DB_WIN: cv2.imshow("grey", grey)

    bw = cv2.threshold(grey, np.mean(grey), 255, cv2.THRESH_BINARY)[1]
    if DB_WIN: cv2.imshow("bw", bw)
    
    #laplacian = cv2.Laplacian(bw, cv2.CV_8U, 15)
    #cv2.imshow("laplacian", laplacian)
    
    contours, hierarchy = cv2.findContours(bw, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
    if DB_WIN:
        img2 = img.copy()
        cv2.drawContours(img2, contours, -1, (0,255,0), 1)
    
    candidates = []
    
    contours = list(contours)
    for i, cnt in enumerate(contours):
        peri = cv2.arcLength(cnt, True)
        contours[i] = cv2.approxPolyDP(cnt, 0.04 * peri, True)
    
    for i in range(len(contours)):
        if is_finder(i, contours, hierarchy):
            candidates.append(i)
    
    if DB_WIN: 
        for i in candidates:
            cv2.drawContours(img2, contours, i, (0,0,255), 1)
    
        cv2.imshow("contours", img2)
    
    if DB_WIN: img3 = img.copy()
    corners = []
    corners_cnts = []
    for i1 in candidates:
        i2 = hierarchy[0][i1][2]
        i3 = hierarchy[0][i2][2]
        c1 = contours[i1]
        c2 = contours[i2]
        c3 = contours[i3]
        
        x1, y1 = center(c1)
        x2, y2 = center(c2)
        x3, y3 = center(c3)
        x, y = (x1+x2+x3)/3, (y1+y2+y3)/3
        x, y = int(x), int(y)
        corners.append((x,y))
        corners_cnts.append([c1,c2,c3])
        
        if DB_WIN: 
            cv2.line(img3, [x, y-10], [x, y+10], (0,255,0), 1)
            cv2.line(img3, [x-10, y], [x+10, y], (0,255,0), 1)
            #cv2.drawContours(img3, [c1], 0, (255,0,0), 1)
            #cv2.drawContours(img3, [c2], 0, (0,255,0), 1)
            #cv2.drawContours(img3, [c3], 0, (0,0,255), 1)
    
    if DB_WIN: cv2.imshow("lines", img3)
    
    if len(corners) != 3:
        return
    
    d01 = dist(corners[0], corners[1])
    d02 = dist(corners[0], corners[2])
    d12 = dist(corners[1], corners[2])
    diffs = [abs(d01-d02), abs(d01-d12), abs(d02-d12)]
    mdiff = min(diffs)
    i = diffs.index(mdiff)
    
    a = corners.pop(i)
    b, c = corners
    
    V = [img.shape[1], img.shape[0]]
    d = [(b[0]+c[0])/2, (b[1]+c[1])/2]
    v = [d[0]-a[0], d[1]-a[1]]
    
    C = [img.shape[1]/2, img.shape[0]/2]
    
    angle = degrees(atan2(v[1], v[0]))
    angle_diff = angle-45
    
    if DB_WIN: 
        img4 = img.copy()
        cv2.line(img4, a, [int(d[0]), int(d[1])], (0,255,0), 1)
        cv2.imshow("vecs", img4)
    
    cA = corners_cnts[i][0]
    cA = rotate_cnt(cA, C, -angle_diff)
    rA = cv2.boundingRect(cA)
    
    cA2 = corners_cnts[i][1]
    cA2 = rotate_cnt(cA2, C, -angle_diff)
    rA2 = cv2.boundingRect(cA2)
    
    cB = corners_cnts[i-1][0]
    cB = rotate_cnt(cB, C, -angle_diff)
    rB = cv2.boundingRect(cB)
    
    cC = corners_cnts[i-2][0]
    cC = rotate_cnt(cC, C, -angle_diff)
    rC = cv2.boundingRect(cC)
    
    a, b, c = rotate(C, a, -angle_diff), rotate(C, b, -angle_diff), rotate(C, c, -angle_diff)
    
    if DB_WIN: 
        img5 = img.copy()
        img5 = imutils.rotate(img5, angle_diff)
        cv2.rectangle(img5, rA, (255,0,0), 1)
        cv2.rectangle(img5, rB, (0,255,0), 1)
        cv2.rectangle(img5, rC, (0,0,255), 1)
        cv2.line(img5, a, b, (255,255,255), 1)
        cv2.line(img5, a, c, (255,255,255), 1)
        cv2.imshow("rot", img5)
    
    wul = rA[2]
    if rB[1] < rC[1]:
        wur = rB[2]
    else:
        wur = rC[2]
    
    if rB[1] < rC[1]:
        D = dist(a, b)
    else:
        D = dist(a, c)
    
    X = (wul + wur)/14
    V = (D/X - 10)/4
    V = round(V)
    
    size = V*4+17
    grid = np.zeros([size, size])
    bw_rot = imutils.rotate(bw, angle_diff)
    if DB_WIN: 
        img6 = img.copy()
        img6 = imutils.rotate(img6, angle_diff)
    
    OX, OY = (rA[0]+rA2[0])/2, (rA[1]+rA2[1])/2
    
    #Not fully visible
    if (OX + size*X+1 >= bw_rot.shape[1]) or (OY + size*X+1 >= bw_rot.shape[0]):
        return None
    
    for y in range(size):
        for x in range(size):
            zone = bw_rot[
                int(OY + y*X-1): int(OY + y*X+2),
                int(OX + x*X-1): int(OX + x*X+2)
            ]
            grid[y, x] = 1-round(np.mean(zone)/255)
            #cv2.circle(img6, [int(OX+x*X), int(OY+y*X)], 3, (0,0,255), 1)
    
    #print(size)
    #cv2.rectangle(img6, [int(OX-X/2), int(OY-X/2), int(X), int(X)], (0,255,0), 1)
    #cv2.imshow("grid", img6)
    if DB_WIN: 
        cv2.namedWindow("bw_rot", cv2.WINDOW_NORMAL)
        cv2.imshow("bw_rot", bw_rot)
    #cv2.imshow("code", cv2.resize(grid, [size*10,size*10]))
    
    value = _decode(grid, V)
    
    if value is None:
        value = _decode(1-grid, V)
    
    return value

def _decode(grid, V, flipped=None, f2=False):
    if not flipped is None:
        grid = flipped
    
    lvl, mask_i = get_fmt(grid, f2)
    
    mask = MASKS[mask_i]
    unmasked = grid.copy()
    mask_area = np.ones(grid.shape)

    mask_area[:9, :9] = 0
    mask_area[:9, -8:] = 0
    mask_area[-8:, :9] = 0

    #Add alignment patterns
    locations = ALIGNMENT_PATTERN_LOCATIONS[V-1]

    if V > 1:
        for y in locations:
            for x in locations:
                #Check if not overlapping with finders
                if np.all(mask_area[y-2:y+3, x-2:x+3] == 1):
                    mask_area[y-2:y+3, x-2:x+3] = 0
                    mask_area[y-1:y+2, x-1:x+2] = 0
                    mask_area[y, x] = 0

    #Add timing patterns
    timing_length = grid.shape[0]-2*8
    mask_area[6, 8:-8] = np.zeros([timing_length])
    mask_area[8:-8, 6] = np.zeros([timing_length])

    if V >= 7:
        mask_area[-11:-8, :6] = 0
        mask_area[:6, -11:-8] = 0
    
    for y in range(grid.shape[0]):
        for x in range(grid.shape[1]):
            if mask_area[y,x] == 1 and mask(x,y):
                unmasked[y,x] = 1-unmasked[y,x]
    
    if DB_WIN: 
        cv2.namedWindow("grid", cv2.WINDOW_NORMAL)
        cv2.namedWindow("unmasked", cv2.WINDOW_NORMAL)
        #cv2.namedWindow("mask_area", cv2.WINDOW_NORMAL)
        cv2.imshow("grid", 1-grid)
        cv2.imshow("unmasked", 1-unmasked)
        #cv2.imshow("mask_area", mask_area)
    
    #Un-place data
    dir_ = -1 #-1 = up | 1 = down
    x, y = grid.shape[1]-1, grid.shape[0]-1
    i = 0
    zigzag = 0
    
    final_data_bits = ""

    while x >= 0:
        if mask_area[y,x] == 1:
            final_data_bits += str(int(unmasked[y, x]))

        if ((dir_+1)/2 + zigzag)%2 == 0:
            x -= 1

        else:
            y += dir_
            x += 1

        if y == -1 or y == grid.shape[0]:
            dir_ = -dir_
            y += dir_
            x -= 2

        else:
            zigzag = 1-zigzag

        #Vertical timing pattern
        if x == 6:
            x -= 1
    
    #Remove remainder bits
    if 2 <= V < 7:
        final_data_bits = final_data_bits[:-7]

    elif 14 <= V < 21 or 28 <= V < 35:
        final_data_bits = final_data_bits[:-3]

    elif 21 <= V < 28:
        final_data_bits = final_data_bits[:-4]
    
    ec = ERROR_CORRECTION[V-1, lvl]
    #print(ec)
    
    
    codewords = [final_data_bits[i:i+8] for i in range(0,len(final_data_bits),8)]
    
    #Only one block
    if ec[2]+ec[4] == 1:
        data_codewords = codewords[:ec[3]]
        ec_codewords = codewords[ec[3]:]

    else:
        group1, group2 = [], []
        group_ec = []
        
        for b in range(ec[2]):
            block = []
            for i in range(ec[3]):
                block.append(codewords[b+i*(ec[2]+ec[4])])
            
            group1.append(block)
        
        if ec[4] > 0:
            for b in range(ec[2], ec[2]+ec[4]):
                block = []
                for i in range(ec[5]):
                    off = 0
                    if i >= ec[3]:
                        off = (i-ec[3]+1)*ec[2]
                    block.append(codewords[b+i*(ec[2]+ec[4])-off])
                
                group2.append(block)
        
        codewords = codewords[ec[2]*ec[3]+ec[4]*ec[5]:]
        
        for b in range(ec[2]+ec[4]):
            block = []
            for i in range(ec[1]):
                block.append(codewords[b+i*(ec[2]+ec[4])])
            
            group_ec.append(block)
        
        data_codewords = sum(group1, []) + sum(group2, [])
        ec_codewords = sum(group_ec, [])
    
    #print(data_codewords)
    #print(ec_codewords)
    
    try:
        decoded = correct(data_codewords, ec_codewords)
    
    except ReedSolomonException as e:
        #print(e)
        
        if not f2:
            return _decode(grid, V, flipped, True)
        
        elif flipped is None:
            f = grid.copy()
            f = np.rot90(np.fliplr(f))
            return _decode(grid, V, f, False)
        
        else:
            #raise ReedSolomonException("Cannot decode")
            return None
    
    decoded = "".join(list(map(lambda c: f"{c.val:08b}", decoded.coefs)))
    
    mode, decoded = decoded[:4], decoded[4:]
    MODES = ["0001", "0010", "0100", "1000"]
    mode = MODES.index(mode)
    
    if 1 <= V < 10:
        char_count_len = [10,9,8,8][mode]
    elif 10 <= V < 27:
        char_count_len = [12,11,16,10][mode]
    elif 27 <= V < 41:
        char_count_len = [14,13,16,12][mode]
    
    length, decoded = decoded[:char_count_len], decoded[char_count_len:]
    length = int(length, 2)
    
    value = None
    
    if mode == 0:
        value = ""
        
        _ = length//3
        l = _ * 10
        if 10 - _ == 2:
            l += 7
        else:
            l += 4
        
        data = decoded[:l]
        groups = [data[i:i+10] for i in range(0, l, 10)]
        
        for group in groups:
            value += str(int(group,2))
        
        value = int(value)
    
    elif mode == 1:
        value = ""
        
        data = decoded[:length//2 * 11 + (length%2)*6]
        
        for i in range(0, len(data), 11):
            s = data[i:i+11]
            val = int(s, 2)
            
            if len(s) == 6:
                value += ALPHANUM[val]
            
            else:
                value += ALPHANUM[val//45]
                value += ALPHANUM[val%45]
    
    elif mode == 2:
        data = decoded[:length*8]
        data = [data[i:i+8] for i in range(0, length*8, 8)]
        data = list(map(lambda b: int(b, 2), data))
        value = bytes(data).decode("ISO-8859-1")
    
    elif mode == 3:
        value = []
        data = decoded[:length*13]
        
        for i in range(0, len(data), 13):
            val = int(data[i:i+13], 2)
            msb = val // 0xc0
            lsb = val % 0xc0
            
            dbyte = (msb << 8) + lsb
            
            if 0 <= dbyte <= 0x9ffc - 0x8140:
                dbyte += 0x8140
            
            elif 0xe040 - 0xc140 <= dbyte <= 0xebbf - 0xc140:
                dbyte += 0xc140
            
            value.append(dbyte >> 8)
            value.append(dbyte & 0xff)
        
        value = bytes(value).decode("shift_jis")
    
    #print("value:", value)
    
    return value
    
    # If unreadable
    # -> _decode(f2=True)
    # -> mirror image

class ReedSolomonException(Exception):
    pass

def correct(data, ec):
    n = len(ec)
    
    data = Poly([GF(int(cw, 2)) for cw in data+ec])
    ##print("data", list(map(lambda c:c.val, data.coefs)))
    
    syndrome = [0]*n
    corrupted = False
    for i in range(n):
        syndrome[i] = data.eval(GF.EXP[i])
        if syndrome[i].val != 0:
            corrupted = True
    
    if not corrupted:
        print("No errors")
        return data
    
    syndrome = Poly(syndrome[::-1])
    #print("syndrome", syndrome)
    
    #Find locator poly
    sigma, omega = euclidean_algorithm(Poly([GF(1)]+[GF(0) for i in range(n)]), syndrome, n)
    #print("sigma", sigma)
    #print("omega", omega)
    error_loc = find_error_loc(sigma)
    
    error_mag = find_error_mag(omega, error_loc)
    
    for i in range(len(error_loc)):
        pos = GF(error_loc[i]).log()
        pos = data.deg - pos.val - 1
        if pos < 0:
            raise ReedSolomonException("Bad error location")
        
        data.coefs[pos] += GF(error_mag[i])
    
    return data

def euclidean_algorithm(a, b, R):
    if a.deg < b.deg:
        a, b = b, a
    
    r_last = a
    r = b
    t_last = Poly([GF(0)])
    t = Poly([GF(1)])
    
    while r.deg-1 >= int(R/2):
        r_last_last = r_last
        t_last_last = t_last
        r_last = r
        t_last = t
        if r_last.coefs[0] == 0:
            raise ReedSolomonException("r_{i-1} was zero")
        
        r = r_last_last
        q = Poly([GF(0)])
        denom_lead_term = r_last.coefs[0]
        dlt_inv = denom_lead_term ** GF(-1)
        I = 0
        while r.deg >= r_last.deg and r.coefs[0] != 0:
            I += 1
            deg_diff = r.deg - r_last.deg
            scale = r.coefs[0] * dlt_inv
            q += Poly([scale]+[GF(0) for i in range(deg_diff)])
            r += r_last * Poly([scale]+[GF(0) for i in range(deg_diff)])
            q.del_lead_zeros()
            r.del_lead_zeros()
            
            if I > 100:
                raise ReedSolomonException("Too long")
        
        t = (q * t_last).del_lead_zeros() + t_last_last
        t.del_lead_zeros()
        if r.deg >= r_last.deg:
            raise ReedSolomonException("Division algorithm failed to reduce polynomial")
    
    sigma_tilde_at_zero = t.coefs[-1]
    if sigma_tilde_at_zero.val == 0:
        raise ReedSolomonException("sigma_tilde(0) was zero")
    
    inv = Poly([sigma_tilde_at_zero ** GF(-1)])
    sigma = t * inv
    omega = r * inv
    
    return [sigma, omega]

def find_error_loc(error_loc):
    num_errors = error_loc.deg-1
    if num_errors == 1:
        return [error_loc.coefs[-2].val]
    
    result = [0]*num_errors
    e = 0
    i = 1
    while i < 256 and e < num_errors:
        if error_loc.eval(GF(i)).val == 0:
            result[e] = (GF(i) ** GF(-1)).val
            e += 1
        
        i += 1
    
    if e != num_errors:
        raise ReedSolomonException("Error locator degree does not match number of roots")
    
    return result

def find_error_mag(error_eval, error_loc):
    s = len(error_loc)
    result = [0]*s
    for i in range(s):
        xi_inv = GF(error_loc[i]) ** GF(-1)
        denom = GF(1)
        for j in range(s):
            if i != j:
                denom *= GF(1) + GF(error_loc[j]) * xi_inv
        
        result[i] = ( error_eval.eval(xi_inv) * (denom ** GF(-1)) ).val
    
    return result

def get_fmt(grid ,f2=False):
    fmt1 = list(grid[0:6, 8]) + [grid[7,8], grid[8,8], grid[8,7]] + list(grid[8, 0:6][::-1])
    fmt2 = list(grid[8, -8:][::-1]) + list(grid[-7:, 8])
    
    fmt1 = "".join([str(int(b)) for b in fmt1])[::-1]
    fmt2 = "".join([str(int(b)) for b in fmt2])[::-1]
    
    if f2:
        return decode_fmt(fmt2)
    
    return decode_fmt(fmt1)

def decode_fmt(fmt):
    format_data = int(fmt, 2)
    format_data ^= 0b101010000010010
    format_data = f"{format_data:015b}"
    
    closest = None
    
    with open("./valid_format_str.txt", "r") as f:
        for i, format_str in enumerate(f):
            diff = sum(1 for a, b in zip(format_data, format_str) if a != b)
            if closest is None or diff < closest[1]:
                closest = (i, diff)
    
    lvl = closest[0] >> 3
    lvl = (5-lvl)%4
    mask = closest[0]&0b111
    return [lvl, mask]

if __name__ == "__main__":
    cam = cv2.VideoCapture(0)
    
    while True:
        ret_val, img = cam.read()
        if not ret_val:
            continue
        
        cv2.imshow("src", img)
        
        try:
            value = decode(img)
            if not value is None:
                print(value)
            
        except Exception as e:
            #pass
            #raise
            print(e)
        
        cv2.waitKey(1)
    
    cv2.destroyAllWindows()