aonestar.public

Parameters

Name	Type	Mode
i_text	text	IN
i_scale	integer	IN (DEFAULT 6)
i_border	integer	IN (DEFAULT 4)

Definition

import zlib, struct, binascii

# (data_codewords, ec_codewords_per_block, num_blocks) per version, ECC level M.
# v1-6 มี block group เดียวทั้งหมด จึงไม่ต้องรองรับ group 2
_SPEC = {
    1: (16, 10, 1), 2: (28, 16, 1), 3: (44, 26, 1),
    4: (64, 18, 2), 5: (86, 24, 2), 6: (108, 16, 4),
}
_REMAINDER = {1: 0, 2: 7, 3: 7, 4: 7, 5: 7, 6: 7}

# ---- GF(256), primitive polynomial 0x11d ----------------------------------
_EXP = [0] * 512
_LOG = [0] * 256
_x = 1
for _i in range(255):
    _EXP[_i] = _x
    _LOG[_x] = _i
    _x <<= 1
    if _x & 0x100:
        _x ^= 0x11D
for _i in range(255, 512):
    _EXP[_i] = _EXP[_i - 255]

def _gf_mul(a, b):
    if a == 0 or b == 0:
        return 0
    return _EXP[_LOG[a] + _LOG[b]]

def _rs_generator(n):
    g = [1]
    for i in range(n):
        ng = [0] * (len(g) + 1)
        for j, c in enumerate(g):
            ng[j] ^= _gf_mul(c, 1)
            ng[j + 1] ^= _gf_mul(c, _EXP[i])
        g = ng
    return g

def _rs_ec(data, n):
    gen = _rs_generator(n)
    res = list(data) + [0] * n
    for i in range(len(data)):
        coef = res[i]
        if coef:
            for j in range(len(gen)):
                res[i + j] ^= _gf_mul(gen[j], coef)
    return res[len(data):]

def _encode_bits(payload, version):
    total_data_cw = _SPEC[version][0]
    capacity_bits = total_data_cw * 8
    bits = []

def put(value, length):
        for k in range(length - 1, -1, -1):
            bits.append((value >> k) & 1)

put(0b0100, 4)          # byte mode
    put(len(payload), 8)    # character count: 8 bits for versions 1-9
    for b in payload:
        put(b, 8)

# terminator (ไม่เกิน 4 bit) แล้ว pad ให้ครบ codeword boundary
    put(0, min(4, capacity_bits - len(bits)))
    while len(bits) % 8:
        bits.append(0)

codewords = [int(''.join(str(b) for b in bits[i:i + 8]), 2)
                 for i in range(0, len(bits), 8)]

# pad codewords 11101100 / 00010001 สลับกัน (ISO/IEC 18004 7.4.10)
    pad = (0xEC, 0x11)
    for i in range(total_data_cw - len(codewords)):
        codewords.append(pad[i % 2])
    return codewords

def _interleave(codewords, version):
    data_cw, ec_per_block, nblocks = _SPEC[version]
    per = data_cw // nblocks
    blocks = [codewords[i * per:(i + 1) * per] for i in range(nblocks)]
    ecblocks = [_rs_ec(b, ec_per_block) for b in blocks]

out = []
    for i in range(per):
        for b in blocks:
            out.append(b[i])
    for i in range(ec_per_block):
        for e in ecblocks:
            out.append(e[i])
    return out

def _new_matrix(version):
    size = 17 + 4 * version
    m = [[None] * size for _ in range(size)]

def finder(r0, c0):
        for dr in range(-1, 8):
            for dc in range(-1, 8):
                r, c = r0 + dr, c0 + dc
                if not (0 <= r < size and 0 <= c < size):
                    continue
                if dr in (-1, 7) or dc in (-1, 7):
                    m[r][c] = 0                      # separator
                elif dr in (0, 6) or dc in (0, 6) or (2 <= dr <= 4 and 2 <= dc <= 4):
                    m[r][c] = 1
                else:
                    m[r][c] = 0

finder(0, 0)
    finder(0, size - 7)
    finder(size - 7, 0)

# version 2-6 มี alignment pattern ตัวเดียวที่มุมล่างขวา
    if version >= 2:
        cr = cc = size - 7
        for dr in range(-2, 3):
            for dc in range(-2, 3):
                m[cr + dr][cc + dc] = 1 if max(abs(dr), abs(dc)) != 1 else 0

for i in range(size):
        if m[6][i] is None:
            m[6][i] = 1 if i % 2 == 0 else 0
        if m[i][6] is None:
            m[i][6] = 1 if i % 2 == 0 else 0

m[4 * version + 9][8] = 1                        # dark module

# จอง 2 พื้นที่ของ format information
    for i in range(9):
        if m[8][i] is None:
            m[8][i] = 'F'
        if m[i][8] is None:
            m[i][8] = 'F'
    for i in range(8):
        if m[8][size - 1 - i] is None:
            m[8][size - 1 - i] = 'F'
        if m[size - 1 - i][8] is None:
            m[size - 1 - i][8] = 'F'
    return m, size

def _place_data(m, size, codewords, version):
    bits = []
    for cw in codewords:
        for k in range(7, -1, -1):
            bits.append((cw >> k) & 1)
    bits.extend([0] * _REMAINDER[version])

idx = 0
    col = size - 1
    upward = True
    while col > 0:
        if col == 6:                                 # ข้าม timing column
            col -= 1
        rows = range(size - 1, -1, -1) if upward else range(size)
        for r in rows:
            for c in (col, col - 1):
                if m[r][c] is None:
                    m[r][c] = bits[idx] if idx < len(bits) else 0
                    idx += 1
        col -= 2
        upward = not upward

_MASKS = (
    lambda i, j: (i + j) % 2 == 0,
    lambda i, j: i % 2 == 0,
    lambda i, j: j % 3 == 0,
    lambda i, j: (i + j) % 3 == 0,
    lambda i, j: (i // 2 + j // 3) % 2 == 0,
    lambda i, j: (i * j) % 2 + (i * j) % 3 == 0,
    lambda i, j: ((i * j) % 2 + (i * j) % 3) % 2 == 0,
    lambda i, j: ((i + j) % 2 + (i * j) % 3) % 2 == 0,
)

def _format_bits(mask):
    data = (0b00 << 3) | mask                        # ECC level M = 00
    v = data << 10
    for i in range(4, -1, -1):
        if v & (1 << (i + 10)):
            v ^= 0x537 << i
    return ((data << 10) | v) ^ 0x5412

def _penalty(g, size):
    score = 0
    lines = list(g) + [[g[r][c] for r in range(size)] for c in range(size)]
    # rule 1: run ยาว 5 ขึ้นไป
    for line in lines:
        run, prev = 1, line[0]
        for v in line[1:]:
            if v == prev:
                run += 1
            else:
                if run >= 5:
                    score += 3 + (run - 5)
                run, prev = 1, v
        if run >= 5:
            score += 3 + (run - 5)
    # rule 2: บล็อค 2x2 สีเดียวกัน
    for r in range(size - 1):
        for c in range(size - 1):
            if g[r][c] == g[r][c + 1] == g[r + 1][c] == g[r + 1][c + 1]:
                score += 3
    # rule 3: pattern 1:1:3:1:1 ที่มี 4 light modules ข้างใดข้างหนึ่ง
    p1 = [1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0]
    p2 = [0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1]
    for line in lines:
        for i in range(size - 10):
            seg = line[i:i + 11]
            if seg == p1 or seg == p2:
                score += 40
    # rule 4: สัดส่วน dark module ห่างจาก 50%
    dark = sum(sum(row) for row in g)
    pct = dark * 100.0 / (size * size)
    score += 10 * int(abs(pct - 50) / 5)
    return score

def _write_format(g, size, mask):
    fmt = _format_bits(mask)
    bits = [(fmt >> (14 - i)) & 1 for i in range(15)]
    coords1 = [(8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 7), (8, 8),
               (7, 8), (5, 8), (4, 8), (3, 8), (2, 8), (1, 8), (0, 8)]
    coords2 = [(size - 1, 8), (size - 2, 8), (size - 3, 8), (size - 4, 8),
               (size - 5, 8), (size - 6, 8), (size - 7, 8),
               (8, size - 8), (8, size - 7), (8, size - 6), (8, size - 5),
               (8, size - 4), (8, size - 3), (8, size - 2), (8, size - 1)]
    for bit, (r, c) in zip(bits, coords1):
        g[r][c] = bit
    for bit, (r, c) in zip(bits, coords2):
        g[r][c] = bit

def _build_matrix(text):
    payload = text.encode('utf-8')
    version = None
    for v in range(1, 7):
        if len(payload) * 8 + 12 <= _SPEC[v][0] * 8:
            version = v
            break
    if version is None:
        plpy.error('QR payload too long: %d bytes (max 106 at version 6, ECC M)'
                   % len(payload))

codewords = _interleave(_encode_bits(payload, version), version)
    m, size = _new_matrix(version)
    func = [[m[r][c] is not None for c in range(size)] for r in range(size)]
    _place_data(m, size, codewords, version)

best, best_score = None, None
    for mask in range(8):
        g = [[0] * size for _ in range(size)]
        for r in range(size):
            for c in range(size):
                v = m[r][c]
                v = 0 if v == 'F' else v
                if not func[r][c] and _MASKS[mask](r, c):
                    v ^= 1
                g[r][c] = v
        _write_format(g, size, mask)
        s = _penalty(g, size)
        if best_score is None or s < best_score:
            best, best_score = g, s
    return best

scale = max(1, int(i_scale))
border = max(0, int(i_border))
grid = _build_matrix(i_text)
size = len(grid)
width = (size + border * 2) * scale

# PNG 8-bit grayscale, filter 0 -- แต่ละ scanline ขึ้นต้นด้วย byte filter type
rows = []
blank = b'\xff' * width
for _ in range(border * scale):
    rows.append(b'\x00' + blank)
for row in grid:
    line = bytearray(b'\xff' * (border * scale))
    for v in row:
        line += (b'\x00' if v else b'\xff') * scale
    line += b'\xff' * (border * scale)
    for _ in range(scale):
        rows.append(b'\x00' + bytes(line))
for _ in range(border * scale):
    rows.append(b'\x00' + blank)

def _chunk(tag, data):
    return (struct.pack('>I', len(data)) + tag + data
            + struct.pack('>I', binascii.crc32(tag + data) & 0xFFFFFFFF))

png = b'\x89PNG\r\n\x1a\n'
png += _chunk(b'IHDR', struct.pack('>IIBBBBB', width, width, 8, 0, 0, 0, 0))
png += _chunk(b'IDAT', zlib.compress(b''.join(rows), 9))
png += _chunk(b'IEND', b'')
return png

fn_qr_png

Description

Parameters

Definition