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

Add a C file generator for TrueType fonts

Browse Source 
In order to be able to optimize the output better, add my own TTF
generator. Fortunately, freetype-py handles all of the hard work.

The generator is not yet integrated.
This commit is contained in:
Max Regan
2019-06-26 09:02:34 -07:00
parent 125ddfb687
commit 5cfa22c650
5 changed files with 2838 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

@@ -2,4 +2,5 @@
*.o
*.bin
*.elf
build
build
*.pyc

18
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.

150
gen/fixedfont-to-c.py Executable file
View File

@@ -0,0 +1,150 @@
#!/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, bmp):
width_bytes = ceildiv(bmp.width, 8)
height_bytes = ceildiv(bmp.height, 8)
output.write(f"// Bitmap for '{char}'\n")
name = to_c_name(f"{font_name}_{ord(char)}")
output.write(f"static 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 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" .height_bytes = {height_bytes},\n")
output.write(f" .bitmap = {name}_bitmap,\n")
output.write("};\n\n")
def emit_font(output, ff, font_name, chars):
c_font_name = to_c_name(font_name)
output.write(f"static struct font {c_font_name} {{\n")
output.write(f" .name = \"{font_name}\",\n")
output.write(f" .glypyhs = [\n")
for i in range(127):
if i in
output.write("};\n\n")
def gen_c_font_file(ttf, output, charset, width=None, size=None, header_dir=None):
ff = font.FixedFont(ttf, size)
font_name = ff.face.postscript_name.decode('ASCII')
emit_license(output)
emit_include(output, header_dir)
width = None
for char in charset:
bmp = ff.render_character(char)
emit_bmp(output, font_name, char, bmp)
if width is None:
width = ceildiv(bmp.width, 8)
emit_font(output, ff, font_name)
def gen_h_font_file(ttf, output, charset, width=None, size=None):
emit_license(output)
def main():
parser = argparse.ArgumentParser(description="Fixed-width TrueType C code generator")
parser.add_argument(dest="ttf", help="TrueType font file", action="store", type=str)
parser.add_argument(dest="output", help="Output C 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)
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()
gen_c_font_file(args.ttf, args.output, args.chars, width=args.width, size=args.size, header_dir=args.header_dir)
if __name__ == "__main__":
main()

230
gen/font.py Executable file
View File

@@ -0,0 +1,230 @@
#!/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, 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
# 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
# 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, 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, size):
self.face = freetype.Face(filename)
self.face.set_pixel_sizes(0, size)
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')))

2438
gen/output.c Normal file
View File

File diff suppressed because it is too large Load Diff