Works!

Author: tannewt

adafruit_bitmap_font/lvfontbin.py

@@ -27,6 +27,7 @@
 try:
     from io import FileIO
     from typing import Iterable, Union
+
     from displayio import Bitmap
 except ImportError:
     pass
@@ -47,7 +48,7 @@ class LVGLFont(GlyphCache):
 
     def __init__(self, f: FileIO, bitmap_class=None):
         """Initialize LVGL font.
-        
+
         Args:
             f: File object containing the LVGL font data
             bitmap_class: Optional bitmap class to use for glyphs. Defaults to displayio.Bitmap.
@@ -76,6 +77,7 @@ def __init__(self, f: FileIO, bitmap_class=None):
             table_marker = f.read(4)
             section_start = f.tell()
             remaining_section = f.read(section_size - 8)
+            print(f"Table marker @ {section_start}: {table_marker} ({section_size} bytes)")
             if table_marker == b"head":
                 self._load_head(remaining_section)
                 # Set bounding box based on font metrics from head section
@@ -84,7 +86,7 @@ def __init__(self, f: FileIO, bitmap_class=None):
                 self._x_offset = 0
                 self._y_offset = self._descent
             elif table_marker == b"cmap":
-                self._load_cmap(remaining_section)
+                self._load_cmap(remaining_section, section_start)
             elif table_marker == b"loca":
                 self._max_cid = struct.unpack("<I", remaining_section[0:4])[0]
                 self._loca_start = section_start + 4
@@ -119,12 +121,10 @@ def _load_head(self, data):
         self._compression_alg = data[33]
         self._subpixel_rendering = data[34]
 
-    def _load_cmap(self, data):
+    def _load_cmap(self, data, section_start):
         data = memoryview(data)
         subtable_count = struct.unpack("<I", data[0:4])[0]
-        self._cmap_tiny = []
-        self._cmap_sparse = []
-        self._cmap_continuous = []
+        self._cmap_subtables = []
         data_offset = 4
 
         for i in range(subtable_count):
@@ -139,35 +139,22 @@ def _load_cmap(self, data):
             # 1 byte - padding
             if len(subtable_header) < 16:
                 raise RuntimeError("Invalid cmap subtable header size")
-            
-            (data_offset_val, range_start, range_length, glyph_offset, entries_count) = struct.unpack(
-                "<IIHHH", subtable_header[:14]
+
+            (data_offset_val, range_start, range_length, glyph_offset, entries_count) = (
+                struct.unpack("<IIHHH", subtable_header[:14])
             )
             format_type = subtable_header[14]
 
-            if format_type == 0:  # Format 0 - continuous
-                if data_offset_val == 0:
-                    raise RuntimeError("Format 0 requires data section")
-                subtable_data = data[data_offset_val:data_offset_val + range_length]
-                if len(subtable_data) < range_length:
-                    raise RuntimeError("Invalid cmap data length")
-                glyph_ids = [gid + glyph_offset for gid in subtable_data]
-                self._cmap_continuous.append((range_start, range_start + range_length, glyph_ids))
-            elif format_type == 2:  # Format 0 tiny
-                self._cmap_tiny.append((range_start, range_start + range_length, glyph_offset))
-            elif format_type == 3:  # Format sparse tiny
-                if data_offset_val == 0:
-                    raise RuntimeError("Format 3 requires data section")
-                subtable_data = data[data_offset_val:data_offset_val + entries_count * 2]
-                if len(subtable_data) < entries_count * 2:
-                    raise RuntimeError("Invalid cmap data length")
-                codepoints = []
-                for j in range(entries_count):
-                    cp_offset = struct.unpack("<H", subtable_data[j * 2:(j + 1) * 2])[0]
-                    codepoints.append(range_start + cp_offset)
-                self._cmap_sparse.append((codepoints, glyph_offset))
-            else:
-                raise RuntimeError(f"Unsupported cmap format {format_type}")
+            # Store subtable header info
+            subtable_info = {
+                "format": format_type,
+                "data_offset": data_offset_val + section_start - 8,
+                "range_start": range_start,
+                "range_length": range_length,
+                "glyph_offset": glyph_offset,
+                "entries_count": entries_count,
+            }
+            self._cmap_subtables.append(subtable_info)
 
     @property
     def ascent(self) -> int:
@@ -218,25 +205,41 @@ def load_glyphs(self, code_points: Union[int, str, Iterable[int]]) -> None:
         for code_point in code_points:
             # Find character ID in the cmap table
             cid = None
-            # Check format 0 (continuous)
-            for start, end, glyph_ids in self._cmap_continuous:
-                if start <= code_point < end:
-                    cid = glyph_ids[code_point - start]
-                    break
-            
-            # Check format 2 (format 0 tiny)
-            if cid is None:
-                for start, end, offset in self._cmap_tiny:
-                    if start <= code_point < end:
-                        cid = offset + (code_point - start)
+
+            # Search through all subtables
+            for subtable in self._cmap_subtables:
+                format_type = subtable["format"]
+                range_start = subtable["range_start"]
+                range_length = subtable["range_length"]
+                glyph_offset = subtable["glyph_offset"]
+                entries_count = subtable["entries_count"]
+                data_offset = subtable["data_offset"]
+
+                if range_start <= code_point < range_start + range_length:
+                    if format_type == 0:  # Continuous
+                        # Read the glyph IDs from the data section (single bytes)
+                        self.file.seek(data_offset)
+                        subtable_data = self.file.read(entries_count)
+                        glyph_id = subtable_data[code_point - range_start]
+                        if glyph_id == 0:
+                            print("  Glyph ID 0: not found")
+                            continue
+                        cid = glyph_id + glyph_offset
                         break
-            
-            # Check format 3 (sparse tiny)
-            if cid is None:
-                for codepoints, offset in self._cmap_sparse:
-                    if code_point in codepoints:
-                        cid = offset + codepoints.index(code_point)
+                    elif format_type == 2:  # Format 0 tiny
+                        cid = glyph_offset + (code_point - range_start)
                         break
+                    elif format_type == 3:  # Sparse tiny
+                        # Read the codepoint offsets from the data section
+                        self.file.seek(data_offset)
+                        subtable_data = self.file.read(entries_count * 2)
+                        for i in range(entries_count):
+                            cp_offset = struct.unpack("<H", subtable_data[i * 2 : (i + 1) * 2])[0]
+                            if cp_offset + range_start == code_point:
+                                cid = glyph_offset + i
+                                break
+                        if cid is not None:
+                            break
 
             if cid is None or cid >= self._max_cid:
                 self._glyphs[code_point] = None

examples/bitmap_font_lvgl_simpletest.py

@@ -9,58 +9,36 @@
 
 from adafruit_bitmap_font import lvfontbin
 
-# Use the unifont bin file that includes ASCII and emoji characters
-font_file = "fonts/unifont-16.0.02-ascii-emoji.bin"
+# Use the Japanese font file
+font_file = "examples/fonts/unifont-16.0.02-ja.bin"
 
-try:
-    with open(font_file, "rb") as f:
-        font = lvfontbin.LVGLFont(f)
-        print("Successfully loaded LVGL font")
-        print("Font metrics:")
-        print(f"  Ascent: {font.ascent}")
-        print(f"  Descent: {font.descent}")
-        bbox = font.get_bounding_box()
-        print(f"  Bounding box: width={bbox[0]}, height={bbox[1]}, x_offset={bbox[2]}, y_offset={bbox[3]}")
-        
-        # Test ASCII characters (likely using format 0 or 2)
-        test_ascii = "Hello, LVGL!"
-        print(f"\nTesting ASCII characters: {test_ascii}")
-        font.load_glyphs(test_ascii)
-        for c in test_ascii:
-            glyph = font.get_glyph(ord(c))
-            if glyph:
-                print(f"  Character '{c}' (U+{ord(c):04X}):")
-                # Print ASCII art representation of the glyph
-                for y in range(glyph.height):
-                    pixels = []
-                    for x in range(glyph.width):
-                        value = glyph.bitmap[x, y]
-                        pixel = "#" if value > 0 else " "
-                        pixels.append(pixel)
-                    print("    " + "".join(pixels))
-            else:
-                print(f"  Character '{c}' (U+{ord(c):04X}) not found in font")
-        
-        # Test emoji characters (likely using format 3 - sparse)
-        test_emoji = "😀🎉🚀"  # Emoji: grinning face, party popper, rocket
-        print(f"\nTesting emoji characters:")
-        font.load_glyphs(test_emoji)
-        for c in test_emoji:
-            glyph = font.get_glyph(ord(c))
-            if glyph:
-                print(f"  Emoji U+{ord(c):04X}:")
-                # Print ASCII art representation of the glyph
-                for y in range(glyph.height):
-                    pixels = []
-                    for x in range(glyph.width):
-                        value = glyph.bitmap[x, y]
-                        pixel = "#" if value > 0 else " "
-                        pixels.append(pixel)
-                    print("    " + "".join(pixels))
-            else:
-                print(f"  Emoji U+{ord(c):04X} not found in font")
+with open(font_file, "rb") as f:
+    font = lvfontbin.LVGLFont(f)
+    print("Successfully loaded LVGL font")
+    print("Font metrics:")
+    print(f"  Ascent: {font.ascent}")
+    print(f"  Descent: {font.descent}")
+    bbox = font.get_bounding_box()
+    print(
+        f"  Bounding box: width={bbox[0]}, height={bbox[1]}, x_offset={bbox[2]}, y_offset={bbox[3]}"
+    )
 
-except FileNotFoundError:
-    print(f"Font file not found: {font_file}")
-except Exception as e:
-    print(f"Error loading font: {e}")
+    # Test Japanese characters
+    test_japanese = "こんにちは世界！"  # Hello World in Japanese (according to Claude)
+    print(f"\nTesting Japanese characters: {test_japanese}")
+    font.load_glyphs(test_japanese)
+    for c in test_japanese:
+        glyph = font.get_glyph(ord(c))
+        if glyph:
+            print(
+                f"  Character '{c}' (U+{ord(c):04X}):"
+            )  # Print ASCII art representation of the glyph
+            for y in range(glyph.height):
+                pixels = []
+                for x in range(glyph.width):
+                    value = glyph.bitmap[x, y]
+                    pixel = "#" if value > 0 else " "
+                    pixels.append(pixel)
+                print("    " + "".join(pixels))
+        else:
+            print(f"  Character '{c}' (U+{ord(c):04X}) not found in font")

examples/fonts/unifont-16.0.02-ascii-emoji.bin

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: 2024 GNU Unifont Contributors
+#
+# SPDX-License-Identifier: OFL-1.1
+
+# Unifont version 16.0.02 is licensed under the SIL Open Font License 1.1 (OFL-1.1).
+
+# Original Unifont converted to LVGL binary format for use with CircuitPython.