pixel_font_trie_ocr 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3ef0ba96a8d1f2d871122d57bff74f315c07e75367ee1d823462ae534c7018ee
+  data.tar.gz: a146081f4bc5feb0b930eec43287a2dd7ded02ee62d52c5dac2f7242753a6b08
+SHA512:
+  metadata.gz: 7b76df9489ccf4e0ce2a89e10a574d08fc37e76f8f07f820553439f9467c3086a456298f66ec2cc7b6ab5169ddd7cf746549a57242e54e3eab493ecc68a2ea6d
+  data.tar.gz: 443df30b953382a1cef4af8abf3d4e592b30583bc7b852d9a307c7dcf741c57dfbc98908de9e20541c02b9e067bb156f3675e340db1b2a9b32a67ce167f4cae8

data/AGENTS.md

@@ -0,0 +1,72 @@
+# AGENTS.md – PixelFontTrieOCR
+
+**IMPORTANT: Think and Communicate with the user ONLY in American English. Do NOT use any oriental glyphs or non-English characters.**
+You are pair programming with the user.
+If you make changes, the user will review. 
+If the user makes changes, they will ask you to review. 
+
+## Project Overview
+Deterministic OCR for tiny (5–8px) crystal-clear pixel fonts using a multi-way Trie keyed by 8-bit column bitmasks (black=1, white=0). Replaces noisy general OCR (Tesseract) with perfect accuracy, early pruning, and microsecond performance on exact fonts.
+
+**Gem name:** pixel_font_trie_ocr  
+**Module:** `PixelFontTrieOCR`  
+**Core tech:** RMagick for image handling, RSpec + RuboCop for testing/linting.
+
+## Code Style & Conventions
+- **No inline comments after code** in source files. Comments before methods, classes or modules following rdoc conventions.
+- Heavy memoization: `@var ||= ...` for `img`, `width`, `image`, `draw`, etc.
+- Short, single-responsibility methods with public accessors (`width`, `image`, `extract`).
+- Seperation of concerns, is important. Don't many any one method, module or class do too much.. Break it down. 
+- Mimic existing patterns from neighboring files (see `lib/pixel_font_trie_ocr/*.rb`).
+- Use in-memory `Magick::Image` objects wherever possible (avoid temp files in tests).
+- Follow RubyGem structure; update gemspec on name/module changes.
+- **NEVER** introduce secrets, assume libraries only if already in Gemfile/gemspec.
+- If a gem library would be useful for a task, ask the user about adding the gem. 
+
+## Important Commands
+- Full test + lint: `bundle exec rake` (default task: spec + rubocop)
+- Run specs only: `bundle exec rspec`
+- Console: `bin/console`
+- Build gem: `bundle exec rake build`
+
+**Always run `bundle exec rake` after changes. If there are errors, go into plan mode, and ask the user before making changes.**
+If the specs pass, then have the user review the changes before making a commit. 
+Make rubocop fixes either automatic or manual in a seperate commit. 
+**never make changes on the master branch, Ask the user to create a working branch before making changes**
+use descriptive commit messages to describe the changes made. 
+If there are changes that you don't recognize, they may be from the user, ask if they should be included. 
+Preferentially write specs before writing code, use a red green refactor process. red for code that fails the spec, green for getting the code to pass the spec, refactor for improving the code after it passes. 
+
+## Key Components
+- `ImageColumnExtractor`: Path or `Magick::Image` → array of column masks (8-bit ints). Supports `height_limit`, `threshold`.
+- `ColumnImageBuilder`: Masks + height → test image (`#image`, `#write`).
+- `TextImageBuilder`: Text + TTF font → clean pixel image (`#image`, `#write`, memoized metrics).
+- `PixelFontTrie`: 
+  - `insert(columns, char)`
+  - `recognize(columns)` (handles whitespace columns, variable-width glyphs)
+  - `PixelFontTrie.from_font(font_path, characters: "...", font_size: 8)` (builds from TrueType, trims whitespace).
+
+## Testing Approach
+- RSpec in `spec/`.
+- Use `ColumnImageBuilder` to generate fixtures (e.g. exhaustive 256-pattern column test).
+- Prefer in-memory tests over real image files.
+- spec files should match the source files with the change from /lib to /spec and the addition of _spec for the spec files. 
+
+## Usage
+```ruby
+trie = PixelFontTrieOCR::PixelFontTrie.from_font("font.ttf", characters: "ABC123!?")
+masks = PixelFontTrieOCR::ImageColumnExtractor.new(image).extract
+puts trie.recognize(masks)
+```
+
+## Rake Tasks
+- `bundle exec rake generate_glyphs` – Generate glyph images from font (default: `fonts/hex-synergy_font.ttf` → `tmp/glyphs/`).
+  - Env vars: `FONT_PATH`, `OUTPUT_DIR`, `FONT_SIZE`, `HEIGHT`.
+  - Uses `PixelFontTrieOCR::GlyphImageGenerator`.
+
+## Next Steps (from project recap)
+- Full recognition pipeline on real samples.
+- CLI tool (`bin/pixel-font-trie-ocr`).
+- Polish, release as gem.
+
+Update this file when adding new commands, conventions, or architecture changes.

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+## 0.1.0 (Initial Release)
+- Initial implementation of Trie-based OCR for pixel fonts.
+- Support for font metadata extraction, image rendering, bitmask generation, and text recognition.
+- Basic tests and RuboCop integration.

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,10 @@
+# Code of Conduct
+
+"pixel_font_trie_ocr" follows [The Ruby Community Conduct Guideline](https://www.ruby-lang.org/en/conduct) in all "collaborative space", which is defined as community communications channels (such as mailing lists, submitted patches, commit comments, etc.):
+
+* Participants will be tolerant of opposing views.
+* Participants must ensure that their language and actions are free of personal attacks and disparaging personal remarks.
+* When interpreting the words and actions of others, participants should always assume good intentions.
+* Behaviour which can be reasonably considered harassment will not be tolerated.
+
+If you have any concerns about behaviour within this project, please contact us at ["rob@ferney.org"](mailto:"rob@ferney.org").

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Robert Ferney
+
+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.

data/README.md

@@ -0,0 +1,151 @@
+# PixelFontTrieOCR
+
+**Deterministic OCR for tiny (5–8px) crystal-clear pixel fonts using a multi-way Trie keyed by 8-bit column bitmasks.**
+
+Replaces noisy general OCR (e.g., Tesseract) with perfect accuracy, early pruning, and microsecond performance on exact fonts.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pixel_font_trie_ocr'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install pixel_font_trie_ocr
+```
+
+**Dependencies**: Requires RMagick for image handling and TTFunk for font parsing.
+
+## Quick Start
+
+```ruby
+require 'pixel_font_trie_ocr'
+
+ocr = PixelFontTrieOCR.new
+ocr.font_name = 'hex-synergy_font.ttf'  # Default font
+ocr.font_size = 8  # Default size
+
+# Render text to image
+img = ocr.text_image('Hello World')
+
+# Extract column bitmasks
+masks = ocr.bitmask(img)
+
+# Recognize text
+text = ocr.parse_mask(masks)
+puts text  # => "Hello World"
+
+# Or directly parse an image
+text = ocr.parse_image(img)
+```
+
+## Advanced Usage
+
+### Building and Using the Trie
+
+```ruby
+ocr = PixelFontTrieOCR.new
+
+# Generate character masks from font (memoized)
+char_masks = ocr.char_masks  # { 'A' => [mask1, mask2, ...], ... }
+
+# Build trie
+trie = ocr.trie  # Or PixelFontTrieOCR::Trie.new(char_masks)
+
+# Insert custom character
+trie.insert('!', [0b101, 0b010])
+
+# Parse masks
+masks = [0b101, 0b010, 0]  # Example masks with trailing zero
+text = trie.parse(masks)  # Handles variable-width and whitespace
+```
+
+### Image Manipulation
+
+```ruby
+# Create image from masks
+mask_img = ocr.mask_image(masks)
+
+# Write text image to file
+ocr.write_text_image('Test', 'test.png')
+
+# Bitmask utilities
+bitmask = ocr.array_to_bitmask([1, 0, 1])  # => 5
+bits = ocr.bitmask_to_array(5)  # => [1, 0, 1]
+```
+
+### Custom Font Configuration
+
+```ruby
+ocr.font_dir = '/path/to/fonts'
+ocr.font_name = 'custom_font.ttf'
+ocr.font_size = 6
+
+puts ocr.height  # Calculated pixel height
+puts ocr.characters.to_a  # Supported characters
+```
+
+### Extracting Masks from Existing Image
+
+```ruby
+img = Magick::Image.read('path/to/image.png').first
+extractor = PixelFontTrieOCR::ImageColumnExtractor.new(img, threshold: 50000)
+masks = extractor.extract
+```
+
+## Features
+
+- **Deterministic Recognition**: 100% accuracy for exact pixel matches; no ML heuristics.
+- **Fast**: Microsecond per character; early trie pruning.
+- **Variable-Width Support**: Handles fonts with varying glyph widths.
+- **Memoization**: Heavy use for performance (e.g., font loading, mask generation).
+- **Utilities**: Image rendering, bitmask conversion, font metadata extraction.
+- **Customization**: Adjustable threshold for black/white detection in images.
+
+## Core Components
+
+| Component                  | Purpose |
+|----------------------------|---------|
+| `PixelFontTrieOCR`         | Main class including all modules; entry point for usage. |
+| `Trie`                     | Core trie for inserting masks and parsing text. |
+| `Trie::Node`               | Trie nodes with recursive matching. |
+| `ImageColumnExtractor`     | Converts images to bitmask arrays. |
+| `FontMetadata` (module)    | Font loading and metadata (characters, ascent, etc.). |
+| `ImageUtils` (module)      | Image creation and writing (text_image, mask_image). |
+| `Parsing` (module)         | Builds trie and performs recognition (parse_image). |
+| `Methods` (module)         | Bitmask utilities (array_to_bitmask). |
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rspec` to run the tests.
+
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+### Rake Tasks
+
+- `rake spec`: Run RSpec tests.
+- `rake rubocop`: Run RuboCop linter.
+- `rake font_map`: Generate glyph images and YAML mask map to `/tmp/`.
+- `rake build`: Build the gem.
+- `rake install`: Install locally.
+- `rake release`: Tag and publish to RubyGems.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[YOUR_USERNAME]/pixel_font_trie_ocr. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[YOUR_USERNAME]/pixel_font_trie_ocr/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+require "fileutils"
+require_relative "lib/pixel_font_trie_ocr"
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
+Rake.add_rakelib(File.join(__dir__, "lib", "tasks"))
+
+task default: %i[spec rubocop]

data/lib/pixel_font_trie_ocr/font_metadata.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "ttfunk"
+
+class PixelFontTrieOCR
+  module FontMetadata
+    DEFAULT_FONT_NAME = "hex-synergy_font.ttf"
+    attr_writer :font_name, :font_size
+
+    def font_name
+      @font_name ||= DEFAULT_FONT_NAME
+    end
+
+    def font_dir=(value)
+      @font_dir = Pathname.new(value)
+    end
+
+    def font_dir
+      @font_dir ||= Pathname.new(__dir__).join("fonts")
+    end
+
+    def font_path
+      @font_path ||= font_dir.join(font_name).to_s
+    end
+
+    def font_size
+      @font_size ||= 8
+    end
+
+    def font
+      @font ||= TTFunk::File.open(font_path)
+    end
+
+    def font_map
+      @font_map ||= font.cmap.unicode.first
+    end
+
+    def code_map
+      @code_map ||= font_map.respond_to?(:code_map) ? font_map.code_map : {}
+    end
+
+    def characters
+      @characters ||= Set.new(
+        code_map.filter_map do |key, value|
+          value.positive? && key > 31 && [key].pack("U")
+        end
+      )
+    end
+
+    def family
+      @family ||= font.name.font_name
+    end
+
+    def subfamily
+      @subfamily ||= font.name.font_subfamily
+    end
+
+    def postscript_name
+      @postscript_name ||= font.name.postscript_name
+    end
+
+    def character_count
+      @character_count ||= characters.size
+    end
+
+    def ascent
+      @ascent ||= font.os2.ascent
+    end
+
+    def descent
+      @descent ||= font.os2.descent
+    end
+
+    def units_per_em
+      @units_per_em ||= font.header.units_per_em
+    end
+
+    def ascent_ratio
+      @ascent_ratio ||= ascent / units_per_em.to_f
+    end
+
+    def height
+      @height ||= (ascent_ratio * font_size).ceil
+    end
+
+    def uppercase
+      @uppercase ||= Set.new("A".."Z")
+    end
+
+    def lowercase
+      @lowercase ||= Set.new("a".."z")
+    end
+
+    def digits
+      @digits ||= Set.new("0".."9")
+    end
+
+    def alphanumeric
+      @alphanumeric ||= uppercase | lowercase | digits
+    end
+
+    def whitespace
+      Set.new([" ", "\r", "\n", "\t"])
+    end
+
+    def symbols
+      @symbols ||= characters - alphanumeric - whitespace
+    end
+  end
+end

data/lib/pixel_font_trie_ocr/image_column_extractor.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+class PixelFontTrieOCR
+  class ImageColumnExtractor
+    attr_reader :image, :threshold
+
+    def initialize(image, threshold: 38_000)
+      @image = image
+      @threshold = threshold
+    end
+
+    def extract
+      trim_masks(masks)
+    end
+
+    private
+
+    def width
+      @width ||= image.columns
+    end
+
+    def height
+      @height ||= image.rows
+    end
+
+    def get_column(col)
+      pixels = image.get_pixels(col, 0, 1, height).reverse
+      pixels.map.with_index do |p, row|
+        black?(p) ? (1 << row) : 0
+      end.sum
+    end
+
+    def black?(pixel)
+      (pixel.red + pixel.green + pixel.blue) < threshold
+    end
+
+    def masks
+      (0...width).map { |col| get_column(col) }
+    end
+
+    def trim_masks(masks)
+      first_non_zero = masks.find_index(&:positive?)
+      return [0, 0] unless first_non_zero
+
+      last_non_zero = masks.rindex(&:positive?)
+      masks[first_non_zero..last_non_zero] + [0]
+    end
+  end
+end

data/lib/pixel_font_trie_ocr/image_utils.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class PixelFontTrieOCR
+  module ImageUtils
+    def temp_dir=(value)
+      @temp_dir = Pathname.new(value)
+    end
+
+    def temp_dir
+      @temp_dir ||= Pathname.new(__dir__).join("..", "..", "tmp")
+    end
+
+    def temp_file(name)
+      temp_dir.join(name).to_s
+    end
+
+    def new_image(width)
+      Magick::Image.new(width, height) do |img|
+        img.background_color = "white"
+      end
+    end
+
+    def new_draw
+      draw = Magick::Draw.new
+      draw.font = font_path
+      draw.pointsize = font_size
+      draw.fill = "black"
+      draw
+    end
+
+    def text_image(text, pad: 0)
+      draw = new_draw
+      metrics = draw.get_type_metrics(text)
+      width = metrics.width + pad
+      width = 2 if width.zero?
+      puts "drawing #{text.inspect} width: #{width}" if width < 1
+      image = new_image(width.ceil)
+      draw.text(0, metrics.ascent.ceil, text).draw(image)
+      image
+    end
+
+    def write_text_image(text, name, pad: 0)
+      image = text_image(text, pad: pad)
+      image.write(temp_file(name))
+    end
+
+    def bitmask(image)
+      ImageColumnExtractor.new(image).extract
+    end
+
+    def mask_image(mask_columns)
+      draw = new_draw
+      image = new_image(mask_columns.length)
+      mask_columns.each_with_index do |mask, col|
+        bitmask_to_array(mask).each_with_index do |bit, row|
+          draw.point(col, height - row - 1) if bit.positive?
+        end
+      end
+      draw.draw(image)
+      image
+    end
+  end
+end

data/lib/pixel_font_trie_ocr/methods.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class PixelFontTrieOCR
+  module Methods
+    def array_to_bitmask(array)
+      array.inject(0) { |acc, bit| (acc << 1) | bit }
+    end
+
+    def bitmask_to_array(bitmask, length: nil)
+      Array.new(length || bitmask.bit_length) { |i| (bitmask >> i) & 1 }
+    end
+  end
+end

data/lib/pixel_font_trie_ocr/parsing.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "trie"
+
+class PixelFontTrieOCR
+  module Parsing
+    def character_images
+      @char_masks = {}
+      characters.map.with_index do |char, index|
+        image = text_image(char)
+        mask = bitmask(image)
+        yield(char, image, mask, index) if block_given?
+        @char_masks[char] = mask
+      end
+      @char_masks
+    end
+
+    def char_masks
+      @char_masks || character_images
+    end
+
+    def trie
+      @trie ||= Trie.new(char_masks)
+    end
+
+    def parse_mask(columns)
+      trie.parse(columns)
+    end
+
+    def parse_image(img)
+      parse_mask(bitmask(img))
+    end
+  end
+end

data/lib/pixel_font_trie_ocr/trie/node.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class PixelFontTrieOCR
+  class Trie
+    class Node
+      attr_accessor :children, :character
+
+      def initialize
+        @children = {}
+        @character = nil
+      end
+
+      def leaf?
+        children.empty?
+      end
+
+      def match(columns, index)
+        if index < columns.length
+          child_char, child_idx = children[columns[index]]&.match(columns, index + 1)
+          return [child_char, child_idx] if child_char
+        end
+
+        [character, index]
+      end
+    end
+  end
+end

data/lib/pixel_font_trie_ocr/trie.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# lib/pixel_font_trie_ocr/trie.rb
+require_relative "trie/node"
+
+class PixelFontTrieOCR
+  class Trie
+    def initialize(char_masks = {})
+      insert_hash(char_masks)
+    end
+
+    def root
+      @root ||= Node.new
+    end
+
+    def insert_hash(hash)
+      hash.each_pair do |character, columns|
+        insert(character, columns)
+      end
+    end
+
+    def insert(character, columns)
+      node = root
+      columns.each do |mask|
+        node.children[mask] ||= Node.new
+        node = node.children[mask]
+      end
+      node.character ||= character
+    end
+
+    def parse(columns)
+      columns = columns.dup
+      columns << 0 unless columns.last.zero?
+      match(columns)
+    end
+
+    protected
+
+    def match(columns, pos = 0)
+      return "" unless pos < columns.length
+
+      matched, new_pos = root.match(columns, pos)
+      if matched
+        matched + match(columns, new_pos)
+      else
+        match(columns, pos + 1)
+      end
+    end
+  end
+end

data/lib/pixel_font_trie_ocr/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class PixelFontTrieOCR
+  VERSION = "0.1.0"
+end

data/lib/pixel_font_trie_ocr.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "rmagick"
+require "ttfunk"
+require_relative "pixel_font_trie_ocr/version"
+require_relative "pixel_font_trie_ocr/methods"
+require_relative "pixel_font_trie_ocr/font_metadata"
+require_relative "pixel_font_trie_ocr/image_utils"
+require_relative "pixel_font_trie_ocr/parsing"
+require_relative "pixel_font_trie_ocr/image_column_extractor"
+
+class PixelFontTrieOCR
+  class Error < StandardError; end
+  include Methods
+  include FontMetadata
+  include ImageUtils
+  include Parsing
+end

data/lib/tasks/font_map.rake

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+desc "Generate font glyph images and bitmask map to tmp/font/"
+task :font_map do
+  require "yaml"
+  pft = PixelFontTrieOCR.new
+  pft.temp_dir.mkpath
+
+  map_data = pft.character_images
+  File.write("tmp/map.yaml", map_data.to_yaml)
+  puts "Generated #{map_data.size}"
+
+  pft.write_text_image(pft.uppercase.join, "uppercase.png")
+  pft.write_text_image(pft.lowercase.join, "lowercase.png")
+  pft.write_text_image(pft.digits.join, "digits.png")
+  pft.write_text_image(pft.symbols.join, "symbols.png", pad: 10)
+end

data/sig/pixel_font_trie_ocr.rbs

@@ -0,0 +1,4 @@
+class PixelFontTrieOCR
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: pixel_font_trie_ocr
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Robert Ferney
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rmagick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.3'
+- !ruby/object:Gem::Dependency
+  name: ttfunk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+description: Provides perfect accuracy and microsecond performance for crystal-clear,
+  5-8px pixel fonts by building a trie from font glyphs and matching image column
+  bitmasks.
+email:
+- rob@ferney.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- AGENTS.md
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/pixel_font_trie_ocr.rb
+- lib/pixel_font_trie_ocr/font_metadata.rb
+- lib/pixel_font_trie_ocr/fonts/hex-synergy_font.ttf
+- lib/pixel_font_trie_ocr/image_column_extractor.rb
+- lib/pixel_font_trie_ocr/image_utils.rb
+- lib/pixel_font_trie_ocr/methods.rb
+- lib/pixel_font_trie_ocr/parsing.rb
+- lib/pixel_font_trie_ocr/trie.rb
+- lib/pixel_font_trie_ocr/trie/node.rb
+- lib/pixel_font_trie_ocr/version.rb
+- lib/tasks/font_map.rake
+- sig/pixel_font_trie_ocr.rbs
+homepage: https://github.com/Barbary-Horde-Studios/pixel_font_trie_ocr
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/Barbary-Horde-Studios/pixel_font_trie_ocr
+  source_code_uri: https://github.com/Barbary-Horde-Studios/pixel_font_trie_ocr
+  changelog_uri: https://github.com/Barbary-Horde-Studios/pixel_font_trie_ocr/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Deterministic OCR for tiny pixel fonts using a Trie of column bitmasks
+test_files: []