diff --git a/README.md b/README.md index 2224b1b..43591e1 100644 --- a/README.md +++ b/README.md @@ -281,8 +281,6 @@ is required `-f` is also required. Supplied examples are: * `font10.py` FreeSans 17 high. * `freesans20.py` FreeSans 20 high. -The directory `gui/fonts/bitmaps` is only required for the `bitmap.py` demo. - ###### [Contents](./README.md#0-contents) ## 1.4 Navigation @@ -638,6 +636,16 @@ gui.demos.simple.test() ``` Before running a different demo the host should be reset (ctrl-d) to clear RAM. +It is possible to run the demos without installing. Copy the directory tree to +the PC with +```bash +$ git clone https://github.com/peterhinch/micropython-micro-gui +``` +Ensure your hardware_setup.py is in the GUI root and the hardware is connected. +Then issue (e.g.) +```bash +$ mpremote mount . exec "import gui.demos.simple" +``` These will run on screens of 128x128 pixels or above. The initial ones are minimal and aim to demonstrate a single technique. * `simple.py` Minimal demo discussed below. `Button` presses print to REPL. @@ -663,7 +671,7 @@ minimal and aim to demonstrate a single technique. * `adjust_vec.py` A pair of `Adjuster`s vary a vector. * `bitmap.py` Demo of the `BitMap` widget showing a changing image. (See widget docs). - * `qrcode.py` Display a QR code. Requires the uQR module. + * `qrcode.py` Display a QR code. Requires the uQR module: see widget docs. * `calendar.py` Demo of grid widget. * `epaper.py` Warts-and-all demo for an ePaper display. Currently the only supported display is the @@ -2829,8 +2837,9 @@ Because of the use of file storage when an update occurs there will be a brief is displayed when a screen initialises, or if it changes in response to a user action. Use in animations is questionable. -See `gui/demos/bitmap.py` for a usage example. Files must be copied from -`gui/fonts/bitmaps/` to the root directory of the device. +See `gui/demos/bitmap.py` for a usage example. Example bitmaps are in +`optional_extras/bitmaps/`. This directory structure should be copied to the +device. ###### [Contents](./README.md#0-contents) @@ -2884,7 +2893,7 @@ If memory errors are encountered try cross-compiling or the use of frozen byte code. See `gui/demos/qrcode.py` for a usage example. The demo expects `uQR.py` to be -located in the root directory of the target. +located in 'optional_extras/py/' on the target. ###### [Contents](./README.md#0-contents) diff --git a/gui/demos/bitmap.py b/gui/demos/bitmap.py index 1a137ee..fcdbb1a 100644 --- a/gui/demos/bitmap.py +++ b/gui/demos/bitmap.py @@ -23,12 +23,15 @@ class BaseScreen(Screen): row = 25 self.graphic = BitMap(wri, row, col, 99, 99, fgcolor=WHITE, bgcolor=BLACK) col = 120 - Button(wri, row, col, text="Next", callback=self.cb) + Button(wri, row, col, text="Next", litcolor=WHITE, callback=self.cb) CloseButton(wri) # Quit the application self.image = 0 def cb(self, _): - self.graphic.value(f"/m{self.image:02d}") + try: + self.graphic.value(path := f"optional_extras/bitmaps/m{self.image:02d}") + except OSError: + print(f"File {path} not found.") self.image += 1 self.image %= 4 if self.image == 3: diff --git a/gui/widgets/qrcode.py b/gui/widgets/qrcode.py index 96bd76d..fea8157 100644 --- a/gui/widgets/qrcode.py +++ b/gui/widgets/qrcode.py @@ -6,10 +6,10 @@ from framebuf import FrameBuffer, MONO_HLSB from gui.core.ugui import Widget from gui.core.colors import * from gui.core.ugui import ssd -from uQR import QRCode - +from optional_extras.py.uQR import QRCode from utime import ticks_diff, ticks_ms + class QRMap(Widget): @staticmethod def len_side(version): @@ -20,7 +20,7 @@ class QRMap(Widget): side = QRMap.len_side(version) * scale width = (side >> 3) + int(side & 7 > 0) # Width in bytes return bytearray(side * width) - + def __init__(self, writer, row, col, version=4, scale=1, *, bdcolor=RED, buf=None): self._version = version self._scale = scale diff --git a/hardware_setup.py b/hardware_setup.py deleted file mode 100644 index b648a5b..0000000 --- a/hardware_setup.py +++ /dev/null @@ -1,59 +0,0 @@ -# pico_epaper_42.py on my PCB (non-standard connection) - -# Released under the MIT License (MIT). See LICENSE. -# Copyright (c) 2023 Peter Hinch - -# This Hardware_setup.py is for # https://www.waveshare.com/pico-epaper-4.2.htm -# wired to the Pico using the ribbon cable rather than the default socket. -# This was to enable testing using my ILI9341 PCB and its pushbuttons. -# Use commented-out code below if using the built-in Pico socket. - -# WIRING -# Pico Display -# GPIO Pin -# 3v3 36 Vin -# IO6 9 CLK Hardware SPI0 -# IO7 10 DATA (AKA SI MOSI) -# IO8 11 DC -# IO9 12 Rst -# Gnd 13 Gnd -# IO10 14 CS - -# Pushbuttons are wired between the pin and Gnd -# Pico pin Meaning -# 16 Operate current control -# 17 Decrease value of current control -# 18 Select previous control -# 19 Select next control -# 20 Increase value of current control - -from machine import Pin, SPI, freq -import gc -from drivers.epaper.pico_epaper_42 import EPD as SSD -freq(250_000_000) # RP2 overclock -# Create and export an SSD instance -prst = Pin(9, Pin.OUT, value=1) -pcs = Pin(10, Pin.OUT, value=1) -pdc = Pin(8, Pin.OUT, value=0) # Arbitrary pins -busy = Pin(15, Pin.IN) -# Datasheet allows 10MHz -spi = SPI(0, sck=Pin(6), mosi=Pin(7), miso=Pin(4), baudrate=10_000_000) -gc.collect() # Precaution before instantiating framebuf - -# Using normal socket connection default args apply -# ssd = SSD() -ssd = SSD(spi, pcs, pdc, prst, busy) -gc.collect() -from gui.core.ugui import Display, quiet -# quiet() -# Create and export a Display instance -# Define control buttons -nxt = Pin(19, Pin.IN, Pin.PULL_UP) # Move to next control -sel = Pin(16, Pin.IN, Pin.PULL_UP) # Operate current control -prev = Pin(18, Pin.IN, Pin.PULL_UP) # Move to previous control -increase = Pin(20, Pin.IN, Pin.PULL_UP) # Increase control's value -decrease = Pin(17, Pin.IN, Pin.PULL_UP) # Decrease control's value -# display = Display(ssd, nxt, sel, prev) # 3-button mode -display = Display(ssd, nxt, sel, prev, increase, decrease) # 5-button mode -ssd.wait_until_ready() # Blocking wait -ssd.set_partial() # Subsequent refreshes are partial diff --git a/gui/fonts/bitmaps/m00 b/optional_extras/bitmaps/m00 similarity index 100% rename from gui/fonts/bitmaps/m00 rename to optional_extras/bitmaps/m00 diff --git a/gui/fonts/bitmaps/m01 b/optional_extras/bitmaps/m01 similarity index 100% rename from gui/fonts/bitmaps/m01 rename to optional_extras/bitmaps/m01 diff --git a/gui/fonts/bitmaps/m02 b/optional_extras/bitmaps/m02 similarity index 100% rename from gui/fonts/bitmaps/m02 rename to optional_extras/bitmaps/m02 diff --git a/gui/fonts/bitmaps/m03 b/optional_extras/bitmaps/m03 similarity index 100% rename from gui/fonts/bitmaps/m03 rename to optional_extras/bitmaps/m03 diff --git a/optional_extras/py/uQR.py b/optional_extras/py/uQR.py new file mode 100644 index 0000000..d587581 --- /dev/null +++ b/optional_extras/py/uQR.py @@ -0,0 +1,1295 @@ +import ure as re + +""" +Exceptions + +Formerly in exceptions.py +""" + +class DataOverflowError(Exception): + pass + +""" +Constants + +Formerly in constants.py +""" + +# QR error correct levels +ERROR_CORRECT_L = 1 +ERROR_CORRECT_M = 0 +ERROR_CORRECT_Q = 3 +ERROR_CORRECT_H = 2 + +""" +LUT + +Formerly in LUT.py +""" +# Store all kinds of lookup table. + + +# # generate rsPoly lookup table. + +# from qrcode import base + +# def create_bytes(rs_blocks): +# for r in range(len(rs_blocks)): +# dcCount = rs_blocks[r].data_count +# ecCount = rs_blocks[r].total_count - dcCount +# rsPoly = base.Polynomial([1], 0) +# for i in range(ecCount): +# rsPoly = rsPoly * base.Polynomial([1, base.gexp(i)], 0) +# return ecCount, rsPoly + +# rsPoly_LUT = {} +# for version in range(1,41): +# for error_correction in range(4): +# rs_blocks_list = base.rs_blocks(version, error_correction) +# ecCount, rsPoly = create_bytes(rs_blocks_list) +# rsPoly_LUT[ecCount]=rsPoly.num +# print(rsPoly_LUT) + +# Result. Usage: input: ecCount, output: Polynomial.num +# e.g. rsPoly = base.Polynomial(LUT.rsPoly_LUT[ecCount], 0) +rsPoly_LUT = { + 7: b'\x01\x7fz\x9a\xa4\x0bDu', + 10: b'\x01\xd8\xc2\x9fo\xc7^_q\x9d\xc1', + 13: b'\x01\x89I\xe3\x11\xb1\x114\r.+S\x84x', + 15: b'\x01\x1d\xc4o\xa3pJ\nii\x8b\x84\x97 \x86\x1a', + 16: b'\x01;\rh\xbdD\xd1\x1e\x08\xa3A)\xe5b2$;', + 17: b'\x01wBSxw\x16\xc5S\xf9)\x8f\x86U5}cO', + 18: b'\x01\xef\xfb\xb7q\x95\xaf\xc7\xd7\xf0\xdcIR\xadK C\xd9\x92', + 20: b'\x01\x98\xb9\xf0\x05oc\x06\xdcp\x96E$\xbb\x16\xe4\xc6yy\xa5\xae', + 22: b'\x01Y\xb3\x83\xb0\xb6\xf4\x13\xbdE(\x1c\x89\x1d{C\xfdV\xda\xe6\x1a\x91\xf5', + 24: b'\x01zv\xa9F\xb2\xed\xd8fs\x96\xe5I\x82H=+\xce\x01\xed\xf7\x7f\xd9\x90u', + 26: b'\x01\xf63\xb7\x04\x88b\xc7\x98M8\xce\x18\x91(\xd1u\xe9*\x87DF\x90\x92M+^', + 28: b'\x01\xfc\t\x1c\r\x12\xfb\xd0\x96g\xaed)\xa7\x0c\xf78uw\xe9\x7f\xb5dy\x93\xb0J:\xc5', + 30: b'\x01\xd4\xf6MI\xc3\xc0Kb\x05Fg\xb1\x16\xd9\x8a3\xb5\xf6H\x19\x12.\xe4J\xd8\xc3\x0bj\x82\x96', +} + +""" +Base + +Formerly in base.py +""" + +EXP_TABLE = list(range(256)) + +LOG_TABLE = list(range(256)) + +for i in range(8): + EXP_TABLE[i] = 1 << i + +for i in range(8, 256): + EXP_TABLE[i] = ( + EXP_TABLE[i - 4] ^ EXP_TABLE[i - 5] ^ EXP_TABLE[i - 6] ^ + EXP_TABLE[i - 8]) + +for i in range(255): + LOG_TABLE[EXP_TABLE[i]] = i + +RS_BLOCK_OFFSET = { + ERROR_CORRECT_L: 0, + ERROR_CORRECT_M: 1, + ERROR_CORRECT_Q: 2, + ERROR_CORRECT_H: 3, +} + +RS_BLOCK_TABLE = [ + b'\x01\x1a\x13', + b'\x01\x1a\x10', + b'\x01\x1a\r', + b'\x01\x1a\t', + b'\x01,"', + b'\x01,\x1c', + b'\x01,\x16', + b'\x01,\x10', + b'\x01F7', + b'\x01F,', + b'\x02#\x11', + b'\x02#\r', + b'\x01dP', + b'\x022 ', + b'\x022\x18', + b'\x04\x19\t', + b'\x01\x86l', + b'\x02C+', + b'\x02!\x0f\x02"\x10', + b'\x02!\x0b\x02"\x0c', + b'\x02VD', + b'\x04+\x1b', + b'\x04+\x13', + b'\x04+\x0f', + b'\x02bN', + b'\x041\x1f', + b'\x02 \x0e\x04!\x0f', + b"\x04'\r\x01(\x0e", + b'\x02ya', + b"\x02<&\x02='", + b'\x04(\x12\x02)\x13', + b'\x04(\x0e\x02)\x0f', + b'\x02\x92t', + b'\x03:$\x02;%', + b'\x04$\x10\x04%\x11', + b'\x04$\x0c\x04%\r', + b'\x02VD\x02WE', + b'\x04E+\x01F,', + b'\x06+\x13\x02,\x14', + b'\x06+\x0f\x02,\x10', + b'\x04eQ', + b'\x01P2\x04Q3', + b'\x042\x16\x043\x17', + b'\x03$\x0c\x08%\r', + b'\x02t\\\x02u]', + b'\x06:$\x02;%', + b'\x04.\x14\x06/\x15', + b'\x07*\x0e\x04+\x0f', + b'\x04\x85k', + b'\x08;%\x01<&', + b'\x08,\x14\x04-\x15', + b'\x0c!\x0b\x04"\x0c', + b'\x03\x91s\x01\x92t', + b'\x04@(\x05A)', + b'\x0b$\x10\x05%\x11', + b'\x0b$\x0c\x05%\r', + b'\x05mW\x01nX', + b'\x05A)\x05B*', + b'\x056\x18\x077\x19', + b'\x0b$\x0c\x07%\r', + b'\x05zb\x01{c', + b'\x07I-\x03J.', + b'\x0f+\x13\x02,\x14', + b'\x03-\x0f\r.\x10', + b'\x01\x87k\x05\x88l', + b'\nJ.\x01K/', + b'\x012\x16\x0f3\x17', + b'\x02*\x0e\x11+\x0f', + b'\x05\x96x\x01\x97y', + b'\tE+\x04F,', + b'\x112\x16\x013\x17', + b'\x02*\x0e\x13+\x0f', + b'\x03\x8dq\x04\x8er', + b'\x03F,\x0bG-', + b'\x11/\x15\x040\x16', + b"\t'\r\x10(\x0e", + b'\x03\x87k\x05\x88l', + b'\x03C)\rD*', + b'\x0f6\x18\x057\x19', + b'\x0f+\x0f\n,\x10', + b'\x04\x90t\x04\x91u', + b'\x11D*', + b'\x112\x16\x063\x17', + b'\x13.\x10\x06/\x11', + b'\x02\x8bo\x07\x8cp', + b'\x11J.', + b'\x076\x18\x107\x19', + b'"%\r', + b'\x04\x97y\x05\x98z', + b'\x04K/\x0eL0', + b'\x0b6\x18\x0e7\x19', + b'\x10-\x0f\x0e.\x10', + b'\x06\x93u\x04\x94v', + b'\x06I-\x0eJ.', + b'\x0b6\x18\x107\x19', + b'\x1e.\x10\x02/\x11', + b'\x08\x84j\x04\x85k', + b'\x08K/\rL0', + b'\x076\x18\x167\x19', + b'\x16-\x0f\r.\x10', + b'\n\x8er\x02\x8fs', + b'\x13J.\x04K/', + b'\x1c2\x16\x063\x17', + b'!.\x10\x04/\x11', + b'\x08\x98z\x04\x99{', + b'\x16I-\x03J.', + b'\x085\x17\x1a6\x18', + b'\x0c-\x0f\x1c.\x10', + b'\x03\x93u\n\x94v', + b'\x03I-\x17J.', + b'\x046\x18\x1f7\x19', + b'\x0b-\x0f\x1f.\x10', + b'\x07\x92t\x07\x93u', + b'\x15I-\x07J.', + b'\x015\x17%6\x18', + b'\x13-\x0f\x1a.\x10', + b'\x05\x91s\n\x92t', + b'\x13K/\nL0', + b'\x0f6\x18\x197\x19', + b'\x17-\x0f\x19.\x10', + b'\r\x91s\x03\x92t', + b'\x02J.\x1dK/', + b'*6\x18\x017\x19', + b'\x17-\x0f\x1c.\x10', + b'\x11\x91s', + b'\nJ.\x17K/', + b'\n6\x18#7\x19', + b'\x13-\x0f#.\x10', + b'\x11\x91s\x01\x92t', + b'\x0eJ.\x15K/', + b'\x1d6\x18\x137\x19', + b'\x0b-\x0f..\x10', + b'\r\x91s\x06\x92t', + b'\x0eJ.\x17K/', + b',6\x18\x077\x19', + b';.\x10\x01/\x11', + b'\x0c\x97y\x07\x98z', + b'\x0cK/\x1aL0', + b"'6\x18\x0e7\x19", + b'\x16-\x0f).\x10', + b'\x06\x97y\x0e\x98z', + b'\x06K/"L0', + b'.6\x18\n7\x19', + b'\x02-\x0f@.\x10', + b'\x11\x98z\x04\x99{', + b'\x1dJ.\x0eK/', + b'16\x18\n7\x19', + b'\x18-\x0f..\x10', + b'\x04\x98z\x12\x99{', + b'\rJ. K/', + b'06\x18\x0e7\x19', + b'*-\x0f .\x10', + b'\x14\x93u\x04\x94v', + b'(K/\x07L0', + b'+6\x18\x167\x19', + b'\n-\x0fC.\x10', + b'\x13\x94v\x06\x95w', + b'\x12K/\x1fL0', + b'"6\x18"7\x19', + b'\x14-\x0f=.\x10', +] + +def glog(n): + if n < 1: # pragma: no cover + raise ValueError("glog(%s)" % n) + return LOG_TABLE[n] + + +def gexp(n): + return EXP_TABLE[n % 255] + + +class Polynomial: + + def __init__(self, num, shift): + if not num: # pragma: no cover + raise Exception("%s/%s" % (len(num), shift)) + + for offset in range(len(num)): + if num[offset] != 0: + break + else: + offset += 1 + if isinstance(num[offset:], bytes): + shift_chunk = b'\x00'*shift + elif isinstance(num[offset:], list): + shift_chunk = [0]*shift + self.num = bytearray(num[offset:]+shift_chunk) + + def __getitem__(self, index): + return self.num[index] + + def __iter__(self): + return iter(self.num) + + def __len__(self): + return len(self.num) + + def __mul__(self, other): + num = [0] * (len(self) + len(other) - 1) + + for i, item in enumerate(self): + for j, other_item in enumerate(other): + num[i + j] ^= gexp(glog(item) + glog(other_item)) + + return Polynomial(num, 0) + + """ + EDIT + """ + + def __mod__(self, other): + + this = self + + while True: + difference = len(this) - len(other) + + if difference < 0: + break + + ratio = glog(this[0]) - glog(other[0]) + + num = [ + item ^ gexp(glog(other_item) + ratio) + for item, other_item in zip(this, other)] + if difference: + num.extend(this[-difference:]) + + this = Polynomial(num, 0) + + return this + + +class RSBlock: + + def __init__(self, total_count, data_count): + self.total_count = total_count + self.data_count = data_count + + +def make_rs_blocks(version, error_correction): + if error_correction not in RS_BLOCK_OFFSET: # pragma: no cover + raise Exception( + "bad rs block @ version: %s / error_correction: %s" % + (version, error_correction)) + offset = RS_BLOCK_OFFSET[error_correction] + rs_block = RS_BLOCK_TABLE[(version - 1) * 4 + offset] + + blocks = [] + + for i in range(0, len(rs_block), 3): + count, total_count, data_count = rs_block[i:i + 3] + for j in range(count): + blocks.append(RSBlock(total_count, data_count)) + + return blocks + + +""" +Utilities + +Formerly in utils.py +""" + +# QR encoding modes. +MODE_NUMBER = 1 << 0 +MODE_ALPHA_NUM = 1 << 1 +MODE_8BIT_BYTE = 1 << 2 +MODE_KANJI = 1 << 3 + +# Encoding mode sizes. +MODE_SIZE_SMALL = { + MODE_NUMBER: 10, + MODE_ALPHA_NUM: 9, + MODE_8BIT_BYTE: 8, + MODE_KANJI: 8, +} +MODE_SIZE_MEDIUM = { + MODE_NUMBER: 12, + MODE_ALPHA_NUM: 11, + MODE_8BIT_BYTE: 16, + MODE_KANJI: 10, +} +MODE_SIZE_LARGE = { + MODE_NUMBER: 14, + MODE_ALPHA_NUM: 13, + MODE_8BIT_BYTE: 16, + MODE_KANJI: 12, +} + +ALPHA_NUM = b'0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:' + +RE_ALPHA_NUM = re.compile(b'^[' + ALPHA_NUM + b']*') +# The number of bits for numeric delimited data lengths. +NUMBER_LENGTH = {3: 10, 2: 7, 1: 4} + +PATTERN_POSITION_TABLE = [ + b'', + b'\x06\x12', + b'\x06\x16', + b'\x06\x1a', + b'\x06\x1e', + b'\x06"', + b'\x06\x16&', + b'\x06\x18*', + b'\x06\x1a.', + b'\x06\x1c2', + b'\x06\x1e6', + b'\x06 :', + b'\x06">', + b'\x06\x1a.B', + b'\x06\x1a0F', + b'\x06\x1a2J', + b'\x06\x1e6N', + b'\x06\x1e8R', + b'\x06\x1e:V', + b'\x06">Z', + b'\x06\x1c2H^', + b'\x06\x1a2Jb', + b'\x06\x1e6Nf', + b'\x06\x1c6Pj', + b'\x06 :Tn', + b'\x06\x1e:Vr', + b'\x06">Zv', + b'\x06\x1a2Jbz', + b'\x06\x1e6Nf~', + b'\x06\x1a4Nh\x82', + b'\x06\x1e8Rl\x86', + b'\x06"Zv\x92', + b'\x06\x1e6Nf~\x96', + b'\x06\x182Lf\x80\x9a', + b'\x06\x1c6Pj\x84\x9e', + b'\x06 :Tn\x88\xa2', + b'\x06\x1a6Rn\x8a\xa6', + b'\x06\x1e:Vr\x8e\xaa', +] + +G15 = ( + (1 << 10) | (1 << 8) | (1 << 5) | (1 << 4) | (1 << 2) | (1 << 1) | + (1 << 0)) +G18 = ( + (1 << 12) | (1 << 11) | (1 << 10) | (1 << 9) | (1 << 8) | (1 << 5) | + (1 << 2) | (1 << 0)) +G15_MASK = (1 << 14) | (1 << 12) | (1 << 10) | (1 << 4) | (1 << 1) + +PAD0 = 0xEC +PAD1 = 0x11 + +# Precompute bit count limits, indexed by error correction level and code size +_data_count = lambda block: block.data_count +BIT_LIMIT_TABLE = [ + [0] + [8*sum(map(_data_count, make_rs_blocks(version, error_correction))) + for version in range(1, 41)] + for error_correction in range(4) +] + + +def BCH_type_info(data): + d = data << 10 + while BCH_digit(d) - BCH_digit(G15) >= 0: + d ^= (G15 << (BCH_digit(d) - BCH_digit(G15))) + + return ((data << 10) | d) ^ G15_MASK + + +def BCH_type_number(data): + d = data << 12 + while BCH_digit(d) - BCH_digit(G18) >= 0: + d ^= (G18 << (BCH_digit(d) - BCH_digit(G18))) + return (data << 12) | d + + +def BCH_digit(data): + digit = 0 + while data != 0: + digit += 1 + data >>= 1 + return digit + + +def pattern_position(version): + return PATTERN_POSITION_TABLE[version - 1] + + +def make_mask_func(pattern): + """ + Return the mask function for the given mask pattern. + """ + if pattern == 0: # 000 + return lambda i, j: (i + j) % 2 == 0 + if pattern == 1: # 001 + return lambda i, j: i % 2 == 0 + if pattern == 2: # 010 + return lambda i, j: j % 3 == 0 + if pattern == 3: # 011 + return lambda i, j: (i + j) % 3 == 0 + if pattern == 4: # 100 + return lambda i, j: (int(i / 2) + int(j / 3)) % 2 == 0 + if pattern == 5: # 101 + return lambda i, j: (i * j) % 2 + (i * j) % 3 == 0 + if pattern == 6: # 110 + return lambda i, j: ((i * j) % 2 + (i * j) % 3) % 2 == 0 + if pattern == 7: # 111 + return lambda i, j: ((i * j) % 3 + (i + j) % 2) % 2 == 0 + raise TypeError("Bad mask pattern: " + pattern) # pragma: no cover + + +def mode_sizes_for_version(version): + if version < 10: + return MODE_SIZE_SMALL + elif version < 27: + return MODE_SIZE_MEDIUM + else: + return MODE_SIZE_LARGE + + +def length_in_bits(mode, version): + if mode not in ( + MODE_NUMBER, MODE_ALPHA_NUM, MODE_8BIT_BYTE, MODE_KANJI): + raise TypeError("Invalid mode (%s)" % mode) # pragma: no cover + + if version < 1 or version > 40: # pragma: no cover + raise ValueError( + "Invalid version (was %s, expected 1 to 40)" % version) + + return mode_sizes_for_version(version)[mode] + + +def make_lost_point(modules): + modules_count = len(modules) + + lost_point = 0 + + lost_point = _lost_point_level1(modules, modules_count) + lost_point += _lost_point_level2(modules, modules_count) + lost_point += _lost_point_level3(modules, modules_count) + lost_point += _lost_point_level4(modules, modules_count) + + return lost_point + + +def _lost_point_level1(modules, modules_count): + lost_point = 0 + + modules_range = range(modules_count) + container = [0] * (modules_count + 1) + + for row in modules_range: + this_row = modules[row] + previous_color = this_row[0] + length = 0 + for col in modules_range: + if this_row[col] == previous_color: + length += 1 + else: + if length >= 5: + container[length] += 1 + length = 1 + previous_color = this_row[col] + if length >= 5: + container[length] += 1 + + for col in modules_range: + previous_color = modules[0][col] + length = 0 + for row in modules_range: + if modules[row][col] == previous_color: + length += 1 + else: + if length >= 5: + container[length] += 1 + length = 1 + previous_color = modules[row][col] + if length >= 5: + container[length] += 1 + + lost_point += sum(container[each_length] * (each_length - 2) + for each_length in range(5, modules_count + 1)) + + return lost_point + + +def _lost_point_level2(modules, modules_count): + lost_point = 0 + + modules_range = range(modules_count - 1) + for row in modules_range: + this_row = modules[row] + next_row = modules[row + 1] + # use iter() and next() to skip next four-block. e.g. + # d a f if top-right a != b botton-right, + # c b e then both abcd and abef won't lost any point. + modules_range_iter = iter(modules_range) + for col in modules_range_iter: + top_right = this_row[col + 1] + if top_right != next_row[col + 1]: + # reduce 33.3% of runtime via next(). + # None: raise nothing if there is no next item. + try: + next(modules_range_iter) + except StopIteration: + pass + elif top_right != this_row[col]: + continue + elif top_right != next_row[col]: + continue + else: + lost_point += 3 + + return lost_point + + +def _lost_point_level3(modules, modules_count): + # 1 : 1 : 3 : 1 : 1 ratio (dark:light:dark:light:dark) pattern in + # row/column, preceded or followed by light area 4 modules wide. From ISOIEC. + # pattern1: 10111010000 + # pattern2: 00001011101 + modules_range = range(modules_count) + modules_range_short = range(modules_count-10) + lost_point = 0 + + for row in modules_range: + this_row = modules[row] + modules_range_short_iter = iter(modules_range_short) + col = 0 + for col in modules_range_short_iter: + if ( + not this_row[col + 1] + and this_row[col + 4] + and not this_row[col + 5] + and this_row[col + 6] + and not this_row[col + 9] + and ( + this_row[col + 0] + and this_row[col + 2] + and this_row[col + 3] + and not this_row[col + 7] + and not this_row[col + 8] + and not this_row[col + 10] + or + not this_row[col + 0] + and not this_row[col + 2] + and not this_row[col + 3] + and this_row[col + 7] + and this_row[col + 8] + and this_row[col + 10] + ) + ): + lost_point += 40 +# horspool algorithm. +# if this_row[col + 10] == True, pattern1 shift 4, pattern2 shift 2. So min=2. +# if this_row[col + 10] == False, pattern1 shift 1, pattern2 shift 1. So min=1. + if this_row[col + 10]: + try: + next(modules_range_short_iter) + except StopIteration: + pass + + for col in modules_range: + modules_range_short_iter = iter(modules_range_short) + row = 0 + for row in modules_range_short_iter: + if ( + not modules[row + 1][col] + and modules[row + 4][col] + and not modules[row + 5][col] + and modules[row + 6][col] + and not modules[row + 9][col] + and ( + modules[row + 0][col] + and modules[row + 2][col] + and modules[row + 3][col] + and not modules[row + 7][col] + and not modules[row + 8][col] + and not modules[row + 10][col] + or + not modules[row + 0][col] + and not modules[row + 2][col] + and not modules[row + 3][col] + and modules[row + 7][col] + and modules[row + 8][col] + and modules[row + 10][col] + ) + ): + lost_point += 40 + if modules[row + 10][col]: + try: + next(modules_range_short_iter) + except StopIteration: + pass + + return lost_point + + +def _lost_point_level4(modules, modules_count): + dark_count = sum(map(sum, modules)) + percent = float(dark_count) / (modules_count**2) + # Every 5% departure from 50%, rating++ + rating = int(abs(percent * 100 - 50) / 5) + return rating * 10 + + +def optimal_data_chunks(data, minimum=4): + """ + An iterator returning QRData chunks optimized to the data content. + + :param minimum: The minimum number of bytes in a row to split as a chunk. + """ + data = to_bytestring(data) + num_pattern = re.compile(b'\d?'*minimum) + num_bits = _optimal_split(data, num_pattern) + alpha_pattern = re.compile( b"("+ + (b'[' + ALPHA_NUM + b']?') * minimum + b")") + for is_num, chunk in num_bits: + if is_num: + yield QRData(chunk, mode=MODE_NUMBER, check_data=False) + else: + for is_alpha, sub_chunk in _optimal_split(chunk, alpha_pattern): + if is_alpha: + mode = MODE_ALPHA_NUM + else: + mode = MODE_8BIT_BYTE + yield QRData(sub_chunk, mode=mode, check_data=False) + + +def _optimal_split(data, pattern): + while data: + #match = re.search(pattern), data) + match = pattern.search(data) + if not match: + break + matched = match.group(0) + start = data.rfind(matched) + end = len(matched) + start + #start, end = match.start(), match.end() + if start: + yield False, data[:start] + yield True, data[start:end] + data = data[end:] + if data: + yield False, data + + +def to_bytestring(data): + """ + Convert data to a (utf-8 encoded) byte-string if it isn't a byte-string + already. + """ + if not isinstance(data, bytes): + data = str(data).encode('utf-8') + return data + + +def optimal_mode(data): + """ + Calculate the optimal mode for this chunk of data. + """ + if data.isdigit(): + return MODE_NUMBER + + if all(b in ALPHA_NUM for b in data): + return MODE_ALPHA_NUM + return MODE_8BIT_BYTE + + +class QRData: + """ + Data held in a QR compatible format. + + Doesn't currently handle KANJI. + """ + + def __init__(self, data, mode=None, check_data=True): + """ + If ``mode`` isn't provided, the most compact QR data type possible is + chosen. + """ + if check_data: + data = to_bytestring(data) + + if mode is None: + self.mode = optimal_mode(data) + else: + self.mode = mode + if mode not in (MODE_NUMBER, MODE_ALPHA_NUM, MODE_8BIT_BYTE): + raise TypeError("Invalid mode (%s)" % mode) # pragma: no cover + if check_data and mode < optimal_mode(data): # pragma: no cover + raise ValueError( + "Provided data can not be represented in mode " + "{0}".format(mode)) + + self.data = data + + def __len__(self): + return len(self.data) + + def write(self, buffer): + if self.mode == MODE_NUMBER: + for i in range(0, len(self.data), 3): + chars = self.data[i:i + 3] + bit_length = NUMBER_LENGTH[len(chars)] + buffer.put(int(chars), bit_length) + elif self.mode == MODE_ALPHA_NUM: + for i in range(0, len(self.data), 2): + chars = self.data[i:i + 2] + if len(chars) > 1: + buffer.put( + ALPHA_NUM.find(chars[0]) * 45 + + ALPHA_NUM.find(chars[1]), 11) + else: + buffer.put(ALPHA_NUM.find(chars), 6) + else: + data = self.data + for c in data: + buffer.put(c, 8) + + def __repr__(self): + return repr(self.data) + + +class BitBuffer: + + def __init__(self): + self.buffer = [] + self.length = 0 + + def __repr__(self): + return ".".join([str(n) for n in self.buffer]) + + def get(self, index): + buf_index = int(index / 8) + return ((self.buffer[buf_index] >> (7 - index % 8)) & 1) == 1 + + def put(self, num, length): + for i in range(length): + self.put_bit(((num >> (length - i - 1)) & 1) == 1) + + def __len__(self): + return self.length + + def put_bit(self, bit): + buf_index = self.length // 8 + if len(self.buffer) <= buf_index: + self.buffer.append(0) + if bit: + self.buffer[buf_index] |= (0x80 >> (self.length % 8)) + self.length += 1 + + +def create_bytes(buffer, rs_blocks): + offset = 0 + + maxDcCount = 0 + maxEcCount = 0 + + dcdata = [0] * len(rs_blocks) + ecdata = [0] * len(rs_blocks) + + for r in range(len(rs_blocks)): + + dcCount = rs_blocks[r].data_count + ecCount = rs_blocks[r].total_count - dcCount + + maxDcCount = max(maxDcCount, dcCount) + maxEcCount = max(maxEcCount, ecCount) + + dcdata[r] = [0] * dcCount + + for i in range(len(dcdata[r])): + dcdata[r][i] = 0xff & buffer.buffer[i + offset] + offset += dcCount + + # Get error correction polynomial. + if ecCount in rsPoly_LUT: + rsPoly = Polynomial(rsPoly_LUT[ecCount], 0) + else: + rsPoly = Polynomial([1], 0) + for i in range(ecCount): + rsPoly = rsPoly * Polynomial([1, gexp(i)], 0) + + rawPoly = Polynomial(dcdata[r], len(rsPoly) - 1) + + modPoly = rawPoly % rsPoly + ecdata[r] = [0] * (len(rsPoly) - 1) + for i in range(len(ecdata[r])): + modIndex = i + len(modPoly) - len(ecdata[r]) + if (modIndex >= 0): + ecdata[r][i] = modPoly[modIndex] + else: + ecdata[r][i] = 0 + + totalCodeCount = 0 + for rs_block in rs_blocks: + totalCodeCount += rs_block.total_count + + data = [None] * totalCodeCount + index = 0 + + for i in range(maxDcCount): + for r in range(len(rs_blocks)): + if i < len(dcdata[r]): + data[index] = dcdata[r][i] + index += 1 + + for i in range(maxEcCount): + for r in range(len(rs_blocks)): + if i < len(ecdata[r]): + data[index] = ecdata[r][i] + index += 1 + + return data + + +def create_data(version, error_correction, data_list): + + buffer = BitBuffer() + for data in data_list: + buffer.put(data.mode, 4) + buffer.put(len(data), length_in_bits(data.mode, version)) + data.write(buffer) + + # Calculate the maximum number of bits for the given version. + rs_blocks = make_rs_blocks(version, error_correction) + bit_limit = 0 + for block in rs_blocks: + bit_limit += block.data_count * 8 + + if len(buffer) > bit_limit: + raise exceptions.DataOverflowError( + "Code length overflow. Data size (%s) > size available (%s)" % + (len(buffer), bit_limit)) + + # Terminate the bits (add up to four 0s). + for i in range(min(bit_limit - len(buffer), 4)): + buffer.put_bit(False) + + # Delimit the string into 8-bit words, padding with 0s if necessary. + delimit = len(buffer) % 8 + if delimit: + for i in range(8 - delimit): + buffer.put_bit(False) + + # Add special alternating padding bitstrings until buffer is full. + bytes_to_fill = (bit_limit - len(buffer)) // 8 + for i in range(bytes_to_fill): + if i % 2 == 0: + buffer.put(PAD0, 8) + else: + buffer.put(PAD1, 8) + + return create_bytes(buffer, rs_blocks) + + +""" +Main + +Formerly in main.py +""" + +def make(data=None, **kwargs): + qr = QRCode(**kwargs) + qr.add_data(data) + return qr.get_matrix() + + +def _check_version(version): + if version < 1 or version > 40: + raise ValueError( + "Invalid version (was %s, expected 1 to 40)" % version) + + +def _check_box_size(size): + if int(size) <= 0: + raise ValueError( + "Invalid box size (was %s, expected larger than 0)" % size) + + +def _check_mask_pattern(mask_pattern): + if mask_pattern is None: + return + if not isinstance(mask_pattern, int): + raise TypeError( + "Invalid mask pattern (was %s, expected int)" % type(mask_pattern)) + if mask_pattern < 0 or mask_pattern > 7: + raise ValueError( + "Mask pattern should be in range(8) (got %s)" % mask_pattern) + +class QRCode: + + def __init__(self, version=None, + error_correction=ERROR_CORRECT_M, + box_size=10, border=4, + mask_pattern=None): + _check_box_size(box_size) + self.version = version and int(version) + self.error_correction = int(error_correction) + self.box_size = int(box_size) + # Spec says border should be at least four boxes wide, but allow for + # any (e.g. for producing printable QR codes). + self.border = int(border) + _check_mask_pattern(mask_pattern) + self.mask_pattern = mask_pattern + + self.clear() + + def clear(self): + """ + Reset the internal data. + """ + self.modules = None + self.modules_count = 0 + self.data_cache = None + self.data_list = [] + + def add_data(self, data, optimize=20): + """ + Add data to this QR Code. + + :param optimize: Data will be split into multiple chunks to optimize + the QR size by finding to more compressed modes of at least this + length. Set to ``0`` to avoid optimizing at all. + """ + if isinstance(data, QRData): + self.data_list.append(data) + else: + if optimize: + self.data_list.extend( + optimal_data_chunks(data, minimum=optimize)) + else: + self.data_list.append(QRData(data)) + self.data_cache = None + + def make(self, fit=True): + """ + Compile the data into a QR Code array. + + :param fit: If ``True`` (or if a size has not been provided), find the + best fit for the data to avoid data overflow errors. + """ + if fit or (self.version is None): + self.best_fit(start=self.version) + if self.mask_pattern is None: + self.makeImpl(False, self.best_mask_pattern()) + else: + self.makeImpl(False, self.mask_pattern) + + def makeImpl(self, test, mask_pattern): + _check_version(self.version) + self.modules_count = self.version * 4 + 17 + self.modules = [None] * self.modules_count + + for row in range(self.modules_count): + + self.modules[row] = [None] * self.modules_count + + for col in range(self.modules_count): + self.modules[row][col] = None # (col + row) % 3 + + self.setup_position_probe_pattern(0, 0) + self.setup_position_probe_pattern(self.modules_count - 7, 0) + self.setup_position_probe_pattern(0, self.modules_count - 7) + self.setup_position_adjust_pattern() + self.setup_timing_pattern() + self.setup_type_info(test, mask_pattern) + + if self.version >= 7: + self.setup_type_number(test) + + if self.data_cache is None: + self.data_cache = create_data( + self.version, self.error_correction, self.data_list) + self.map_data(self.data_cache, mask_pattern) + + def setup_position_probe_pattern(self, row, col): + for r in range(-1, 8): + + if row + r <= -1 or self.modules_count <= row + r: + continue + + for c in range(-1, 8): + + if col + c <= -1 or self.modules_count <= col + c: + continue + + if (0 <= r and r <= 6 and (c == 0 or c == 6) + or (0 <= c and c <= 6 and (r == 0 or r == 6)) + or (2 <= r and r <= 4 and 2 <= c and c <= 4)): + self.modules[row + r][col + c] = True + else: + self.modules[row + r][col + c] = False + + def best_fit(self, start=None): + """ + Find the minimum size required to fit in the data. + """ + if start is None: + start = 1 + _check_version(start) + + # Corresponds to the code in create_data, except we don't yet know + # version, so optimistically assume start and check later + mode_sizes = mode_sizes_for_version(start) + buffer = BitBuffer() + for data in self.data_list: + buffer.put(data.mode, 4) + buffer.put(len(data), mode_sizes[data.mode]) + data.write(buffer) + + needed_bits = len(buffer) + + self.version = start + end = len(BIT_LIMIT_TABLE[self.error_correction]) + + while (self.version < end and + needed_bits > BIT_LIMIT_TABLE[self.error_correction][self.version]): + self.version += 1 + + if self.version == 41: + raise DataOverflowError() + + # Now check whether we need more bits for the mode sizes, recursing if + # our guess was too low + if mode_sizes is not mode_sizes_for_version(self.version): + self.best_fit(start=self.version) + return self.version + + def best_mask_pattern(self): + """ + Find the most efficient mask pattern. + """ + min_lost_point = 0 + pattern = 0 + + for i in range(8): + self.makeImpl(True, i) + + lost_point = make_lost_point(self.modules) + + if i == 0 or min_lost_point > lost_point: + min_lost_point = lost_point + pattern = i + + return pattern + + + def setup_timing_pattern(self): + for r in range(8, self.modules_count - 8): + if self.modules[r][6] is not None: + continue + self.modules[r][6] = (r % 2 == 0) + + for c in range(8, self.modules_count - 8): + if self.modules[6][c] is not None: + continue + self.modules[6][c] = (c % 2 == 0) + + def setup_position_adjust_pattern(self): + pos = pattern_position(self.version) + + for i in range(len(pos)): + + for j in range(len(pos)): + + row = pos[i] + col = pos[j] + + if self.modules[row][col] is not None: + continue + + for r in range(-2, 3): + + for c in range(-2, 3): + + if (r == -2 or r == 2 or c == -2 or c == 2 or + (r == 0 and c == 0)): + self.modules[row + r][col + c] = True + else: + self.modules[row + r][col + c] = False + + def setup_type_number(self, test): + bits = BCH_type_number(self.version) + + for i in range(18): + mod = (not test and ((bits >> i) & 1) == 1) + self.modules[i // 3][i % 3 + self.modules_count - 8 - 3] = mod + + for i in range(18): + mod = (not test and ((bits >> i) & 1) == 1) + self.modules[i % 3 + self.modules_count - 8 - 3][i // 3] = mod + + def setup_type_info(self, test, mask_pattern): + data = (self.error_correction << 3) | mask_pattern + bits = BCH_type_info(data) + + # vertical + for i in range(15): + + mod = (not test and ((bits >> i) & 1) == 1) + + if i < 6: + self.modules[i][8] = mod + elif i < 8: + self.modules[i + 1][8] = mod + else: + self.modules[self.modules_count - 15 + i][8] = mod + + # horizontal + for i in range(15): + + mod = (not test and ((bits >> i) & 1) == 1) + + if i < 8: + self.modules[8][self.modules_count - i - 1] = mod + elif i < 9: + self.modules[8][15 - i - 1 + 1] = mod + else: + self.modules[8][15 - i - 1] = mod + + # fixed module + self.modules[self.modules_count - 8][8] = (not test) + + def map_data(self, data, mask_pattern): + inc = -1 + row = self.modules_count - 1 + bitIndex = 7 + byteIndex = 0 + + mask_func = make_mask_func(mask_pattern) + + data_len = len(data) + + for col in range(self.modules_count - 1, 0, -2): + + if col <= 6: + col -= 1 + + col_range = (col, col-1) + + while True: + + for c in col_range: + + if self.modules[row][c] is None: + + dark = False + + if byteIndex < data_len: + dark = (((data[byteIndex] >> bitIndex) & 1) == 1) + + if mask_func(row, c): + dark = not dark + + self.modules[row][c] = dark + bitIndex -= 1 + + if bitIndex == -1: + byteIndex += 1 + bitIndex = 7 + + row += inc + + if row < 0 or self.modules_count <= row: + row -= inc + inc = -inc + break + + def get_matrix(self): + """ + Return the QR Code as a multidimensonal array, including the border. + + To return the array without a border, set ``self.border`` to 0 first. + """ + if self.data_cache is None: + self.make() + + if not self.border: + return self.modules + + width = len(self.modules) + self.border*2 + code = [[False]*width] * self.border + x_border = [False]*self.border + for module in self.modules: + code.append(x_border + module + x_border) + code += [[False]*width] * self.border + + return code + + def render_matrix(self): + out = "" + for row in self.get_matrix(): + out += "".join([{False: " ", True: "█"}[x] if x in (False, True) else "╳" for x in row]) + out += "\n" + return out