max/timely-reference
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Full color support, rework the directory structure

Browse Source
This commit is contained in:
Max Regan
2019-08-05 22:15:40 -07:00
parent 77f09bca16
commit d5ddd76bef
121 changed files with 93737 additions and 702 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
firmware/Gen/__init__.py Normal file
View File

@@ -0,0 +1,18 @@
# Copyright (C) 2019 Max Regan
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.

189
firmware/Gen/fixedfont-to-c.py Executable file
View File

@@ -0,0 +1,189 @@
#!/usr/bin/env python3
# Copyright (C) 2019 Max Regan
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
import font
import argparse
import string
def emit_license(output):
output.write(
"""/*
* Copyright (C) 2019 Max Regan
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
""")
def emit_include(output, header_dir):
if header_dir:
if header_dir[-1] == '/':
header_dir = header_dir[:-1]
header = header_dir + "/font.h"
else:
header = "font.h"
output.write(f"#include \"{header}\"\n\n")
def ceildiv(num, den):
return (num + (den - 1)) // den
def to_c_name(name):
return name.replace("-","_")
def emit_bmp(output, font_name, char, glyph, bmp):
width_bytes = ceildiv(bmp.width, 8)
output.write(f"// Bitmap for '{char}'\n")
name = to_c_name(f"{font_name}_{ord(char)}")
output.write(f"static const uint8_t {name}_bitmap[] = {{\n")
byte = 0
for y in range(bmp.height):
output.write(" ")
for x in range(bmp.width):
bit_idx = 7 - (x % 8)
bit = bmp.pixels[y * bmp.width + x]
byte |= bit << bit_idx
if bit_idx == 0 or x == bmp.width - 1:
output.write('0x{:02x}, '.format(byte))
byte = 0
output.write("\n")
output.write("};\n\n")
output.write(f"// Glyph data for '{char}'\n")
output.write(f"static const struct glyph {name}_glyph = {{\n")
output.write(f" .width = {bmp.width},\n")
output.write(f" .width_bytes = {width_bytes},\n")
output.write(f" .height = {bmp.height},\n")
output.write(f" .top = {glyph.top},\n")
output.write(f" .left = {glyph.left},\n")
output.write(f" .bitmap = {name}_bitmap,\n")
output.write("};\n\n")
def emit_font(output, ff, font_name, charset, height, width):
c_font_name = to_c_name(font_name)
output.write(f"const struct font {c_font_name} = {{\n")
output.write(f" .name = \"{font_name}\",\n")
output.write(f" .height = {height},\n")
output.write(f" .width = {width},\n")
output.write(f" .glyphs = {{\n")
for i in range(128):
if chr(i) in charset:
name = to_c_name(f"{font_name}_{i}_glyph")
output.write(f" [{i}] = &{name},\n")
else:
output.write(f" [{i}] = NULL,\n")
output.write(f" }}\n")
output.write("};\n\n")
def gen_c_font_file(ttf, output, charset, width=None, size=None, header_dir=None, font_name=None):
ff = font.FixedFont(ttf, width=width, height=size)
if font_name is None:
font_name = ff.face.postscript_name.decode('ASCII')
emit_license(output)
emit_include(output, header_dir)
max_advance = None
max_height = None
for char in charset:
bmp = ff.render_character(char)
glyph = ff.glyph_for_character(char)
emit_bmp(output, font_name, char, glyph, bmp)
advance = glyph.advance_width
if not max_advance or advance > max_advance:
max_advance = advance
height = glyph.top
if not max_height or height > max_height:
max_height = height
emit_font(output, ff, font_name, charset, max_height, max_advance)
def gen_h_font_file(ttf, output, header_dir=None, font_name=None):
if font_name is None:
font_name = ff.face.postscript_name.decode('ASCII')
c_font_name = to_c_name(font_name)
define_name = f"_FONT_{c_font_name.upper()}_H_"
emit_license(output)
output.write("\n")
output.write(f"#ifndef {define_name}\n")
output.write(f"#define {define_name}\n")
output.write("\n")
emit_include(output, header_dir)
output.write(f"extern const struct font {c_font_name};\n")
output.write("\n")
output.write("#endif")
def main():
parser = argparse.ArgumentParser(description="Fixed-width TrueType C code generator")
parser.add_argument(dest="filetype", help="The filetype to produce", action="store", type=str, choices=["c","h"])
parser.add_argument(dest="ttf", help="TrueType font file", action="store", type=str)
parser.add_argument(dest="output", help="Output file", action="store", type=argparse.FileType('w'))
parser.add_argument("--chars", "-c", help="Character set. Defaults to all printable ASCII", action="store", type=str,
default="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 -=_+{}[]:\";'<>,.?/~!@#$%^&*()|\\")
parser.add_argument("--header-dir", help="Directory of the font.h header", action="store", type=str)
parser.add_argument("--name", help="Font name to use in the generated code", action="store", type=str)
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument("--size", "-s", help="Font pitch", action="store", type=int)
group.add_argument("--width", "-w", help="Font width", action="store", type=int)
args = parser.parse_args()
args.chars = list(set(args.chars))
args.chars.sort()
if args.filetype == "c":
gen_c_font_file(args.ttf, args.output, args.chars, width=args.width,
size=args.size, header_dir=args.header_dir, font_name=args.name)
elif args.filetype == "h":
gen_h_font_file(args.ttf, args.output, header_dir=args.header_dir, font_name=args.name)
if __name__ == "__main__":
main()

234
firmware/Gen/font.py Executable file
View File

@@ -0,0 +1,234 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Needs freetype-py>=1.0
# For more info see:
# http://dbader.org/blog/monochrome-font-rendering-with-freetype-and-python
# The MIT License (MIT)
#
# Copyright (c) 2013 Daniel Bader (http://dbader.org)
# Copyright (c) 2019 Max Regan (http://git.maxregan.me)
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
import freetype
class Bitmap(object):
"""
A 2D bitmap image represented as a list of byte values. Each byte indicates the state
of a single pixel in the bitmap. A value of 0 indicates that the pixel is `off`
and any other value indicates that it is `on`.
"""
def __init__(self, width, height, pixels=None):
self.width = width
self.height = height
self.pixels = pixels or bytearray(width * height)
def __repr__(self):
"""Return a string representation of the bitmap's pixels."""
rows = ''
for y in range(self.height):
for x in range(self.width):
rows += '#' if self.pixels[y * self.width + x] else ' '
rows += '\n'
return rows
def bitblt(self, src, x, y):
"""Copy all pixels from `src` into this bitmap"""
srcpixel = 0
dstpixel = y * self.width + x
row_offset = self.width - src.width
for sy in range(src.height):
for sx in range(src.width):
# Perform an OR operation on the destination pixel and the source pixel
# because glyph bitmaps may overlap if character kerning is applied, e.g.
# in the string "AVA", the "A" and "V" glyphs must be rendered with
# overlapping bounding boxes.
self.pixels[dstpixel] = self.pixels[dstpixel] or src.pixels[srcpixel]
srcpixel += 1
dstpixel += 1
dstpixel += row_offset
class Glyph(object):
def __init__(self, pixels, width, height, top, left, advance_width):
self.bitmap = Bitmap(width, height, pixels)
# The glyph bitmap's top-side bearing, i.e. the vertical distance from the
# baseline to the bitmap's top-most scanline.
self.top = top
self.left = left
# Ascent and descent determine how many pixels the glyph extends
# above or below the baseline.
self.descent = max(0, self.height - self.top)
self.ascent = max(0, max(self.top, self.height) - self.descent)
# The advance width determines where to place the next character horizontally,
# that is, how many pixels we move to the right to draw the next glyph.
self.advance_width = advance_width
@property
def width(self):
return self.bitmap.width
@property
def height(self):
return self.bitmap.height
@staticmethod
def from_glyphslot(slot):
"""Construct and return a Glyph object from a FreeType GlyphSlot."""
pixels = Glyph.unpack_mono_bitmap(slot.bitmap)
width, height = slot.bitmap.width, slot.bitmap.rows
top = slot.bitmap_top
left = slot.bitmap_left
# The advance width is given in FreeType's 26.6 fixed point format,
# which means that the pixel values are multiples of 64.
assert slot.advance.x % 64 == 0
advance_width = slot.advance.x // 64
return Glyph(pixels, width, height, top, left, advance_width)
@staticmethod
def unpack_mono_bitmap(bitmap):
"""
Unpack a freetype FT_LOAD_TARGET_MONO glyph bitmap into a bytearray where each
pixel is represented by a single byte.
"""
# Allocate a bytearray of sufficient size to hold the glyph bitmap.
data = bytearray(bitmap.rows * bitmap.width)
# Iterate over every byte in the glyph bitmap. Note that we're not
# iterating over every pixel in the resulting unpacked bitmap --
# we're iterating over the packed bytes in the input bitmap.
for y in range(bitmap.rows):
for byte_index in range(bitmap.pitch):
# Read the byte that contains the packed pixel data.
byte_value = bitmap.buffer[y * bitmap.pitch + byte_index]
# We've processed this many bits (=pixels) so far. This determines
# where we'll read the next batch of pixels from.
num_bits_done = byte_index * 8
# Pre-compute where to write the pixels that we're going
# to unpack from the current byte in the glyph bitmap.
rowstart = y * bitmap.width + byte_index * 8
# Iterate over every bit (=pixel) that's still a part of the
# output bitmap. Sometimes we're only unpacking a fraction of a byte
# because glyphs may not always fit on a byte boundary. So we make sure
# to stop if we unpack past the current row of pixels.
for bit_index in range(min(8, bitmap.width - num_bits_done)):
# Unpack the next pixel from the current glyph byte.
bit = byte_value & (1 << (7 - bit_index))
# Write the pixel to the output bytearray. We ensure that `off`
# pixels have a value of 0 and `on` pixels have a value of 1.
data[rowstart + bit_index] = 1 if bit else 0
return data
class FixedFont(object):
def __init__(self, filename, width=0, height=0):
self.face = freetype.Face(filename)
if not width and not height:
raise ValueError("Width or height must be set non-zero")
self.face.set_pixel_sizes(width, height)
# if not self.face.is_fixed_width:
# raise ValueError("Font is not fixed width")
self.face.load_char('A', freetype.FT_LOAD_RENDER | freetype.FT_LOAD_TARGET_MONO)
self.advance = self.face.glyph.advance.x // 64
def glyph_for_character(self, char):
# Let FreeType load the glyph for the given character and tell it to render
# a monochromatic bitmap representation.
self.face.load_char(char, freetype.FT_LOAD_RENDER | freetype.FT_LOAD_TARGET_MONO)
return Glyph.from_glyphslot(self.face.glyph)
def render_character(self, char):
glyph = self.glyph_for_character(char)
return glyph.bitmap
def text_dimensions(self, text):
"""Return (width, height, baseline) of `text` rendered in the current font."""
width = 0
max_ascent = 0
max_descent = 0
previous_char = None
# For each character in the text string we get the glyph
# and update the overall dimensions of the resulting bitmap.
for char in text:
glyph = self.glyph_for_character(char)
max_ascent = max(max_ascent, glyph.ascent)
max_descent = max(max_descent, glyph.descent)
# With kerning, the advance width may be less than the width of the glyph's bitmap.
# Make sure we compute the total width so that all of the glyph's pixels
# fit into the returned dimensions.
width += self.advance
previous_char = char
height = max_ascent + max_descent
return (width, height, max_descent)
def render_text(self, text, width=None, height=None, baseline=None):
"""
Render the given `text` into a Bitmap and return it.
If `width`, `height`, and `baseline` are not specified they are computed using
the `text_dimensions' method.
"""
if None in (width, height, baseline):
width, height, baseline = self.text_dimensions(text)
x = 0
previous_char = None
outbuffer = Bitmap(width, height)
for char in text:
glyph = self.glyph_for_character(char)
# The vertical drawing position should place the glyph
# on the baseline as intended.
y = height - glyph.ascent - baseline
outbuffer.bitblt(glyph.bitmap, x, y)
x += glyph.advance_width
previous_char = char
return outbuffer
if __name__ == '__main__':
# Be sure to place 'helvetica.ttf' (or any other ttf / otf font file) in the working directory.
fnt = FixedFont('/usr/share/fonts/truetype/ubuntu/UbuntuMono-R.ttf', 24)
print(repr(fnt.render_text('AV Wa')))