fontisan 0.2.3 → 0.2.5

data/lib/fontisan/tables/colr.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../binary/base_record"
+
+module Fontisan
+  module Tables
+    # COLR (Color) table parser
+    #
+    # The COLR table defines layered color glyphs where each layer references
+    # a glyph ID and a palette index from the CPAL table. This enables fonts
+    # to display multi-colored glyphs such as emoji or brand logos.
+    #
+    # COLR Table Structure:
+    # ```
+    # COLR Table = Header (14 bytes)
+    #            + Base Glyph Records (6 bytes each)
+    #            + Layer Records (4 bytes each)
+    # ```
+    #
+    # Version 0 Structure:
+    # - version (uint16): Table version (0)
+    # - numBaseGlyphRecords (uint16): Number of base glyphs
+    # - baseGlyphRecordsOffset (uint32): Offset to base glyph records array
+    # - layerRecordsOffset (uint32): Offset to layer records array
+    # - numLayerRecords (uint16): Number of layer records
+    #
+    # The COLR table must be used together with the CPAL (Color Palette) table
+    # which defines the actual RGB color values referenced by palette indices.
+    #
+    # Reference: OpenType COLR specification
+    # https://docs.microsoft.com/en-us/typography/opentype/spec/colr
+    #
+    # @example Reading a COLR table
+    #   data = font.table_data['COLR']
+    #   colr = Fontisan::Tables::Colr.read(data)
+    #   layers = colr.layers_for_glyph(42)
+    #   puts "Glyph 42 has #{layers.length} color layers"
+    class Colr < Binary::BaseRecord
+      # OpenType table tag for COLR
+      TAG = "COLR"
+
+      # Base Glyph Record structure for COLR table
+      #
+      # Each base glyph record associates a glyph ID with its color layers.
+      # Structure (6 bytes): glyph_id, first_layer_index, num_layers
+      class BaseGlyphRecord < Binary::BaseRecord
+        endian :big
+        uint16 :glyph_id
+        uint16 :first_layer_index
+        uint16 :num_layers
+
+        def has_layers?
+          num_layers.positive?
+        end
+      end
+
+      # Layer Record structure for COLR table
+      #
+      # Each layer record specifies a glyph and palette index.
+      # Structure (4 bytes): glyph_id, palette_index
+      class LayerRecord < Binary::BaseRecord
+        endian :big
+        FOREGROUND_COLOR = 0xFFFF
+
+        uint16 :glyph_id
+        uint16 :palette_index
+
+        def uses_foreground_color?
+          palette_index == FOREGROUND_COLOR
+        end
+
+        def uses_palette_color?
+          !uses_foreground_color?
+        end
+      end
+
+      # @return [Integer] COLR version (0 for version 0)
+      attr_reader :version
+
+      # @return [Integer] Number of base glyph records
+      attr_reader :num_base_glyph_records
+
+      # @return [Integer] Offset to base glyph records array
+      attr_reader :base_glyph_records_offset
+
+      # @return [Integer] Offset to layer records array
+      attr_reader :layer_records_offset
+
+      # @return [Integer] Number of layer records
+      attr_reader :num_layer_records
+
+      # @return [String] Raw binary data for the entire COLR table
+      attr_reader :raw_data
+
+      # @return [Array<BaseGlyphRecord>] Parsed base glyph records
+      attr_reader :base_glyph_records
+
+      # @return [Array<LayerRecord>] Parsed layer records
+      attr_reader :layer_records
+
+      # Override read to parse COLR structure
+      #
+      # @param io [IO, String] Binary data to read
+      # @return [Colr] Parsed COLR table
+      def self.read(io)
+        colr = new
+        return colr if io.nil?
+
+        data = io.is_a?(String) ? io : io.read
+        colr.parse!(data)
+        colr
+      end
+
+      # Parse the COLR table structure
+      #
+      # @param data [String] Binary data for the COLR table
+      # @raise [CorruptedTableError] If COLR structure is invalid
+      def parse!(data)
+        @raw_data = data
+        io = StringIO.new(data)
+
+        # Parse COLR header (14 bytes)
+        parse_header(io)
+        validate_header!
+
+        # Parse base glyph records
+        parse_base_glyph_records(io)
+
+        # Parse layer records
+        parse_layer_records(io)
+      rescue StandardError => e
+        raise CorruptedTableError, "Failed to parse COLR table: #{e.message}"
+      end
+
+      # Get color layers for a specific glyph ID
+      #
+      # Returns an array of LayerRecord objects for the specified glyph.
+      # Returns empty array if glyph has no color layers.
+      #
+      # @param glyph_id [Integer] Glyph ID to look up
+      # @return [Array<LayerRecord>] Array of layer records for this glyph
+      def layers_for_glyph(glyph_id)
+        # Find base glyph record for this glyph ID
+        base_record = find_base_glyph_record(glyph_id)
+        return [] unless base_record
+
+        # Extract layers for this glyph
+        first_index = base_record.first_layer_index
+        num_layers = base_record.num_layers
+
+        return [] if num_layers.zero?
+
+        # Return slice of layer records
+        layer_records[first_index, num_layers] || []
+      end
+
+      # Check if COLR table has color data for a specific glyph
+      #
+      # @param glyph_id [Integer] Glyph ID to check
+      # @return [Boolean] True if glyph has color layers
+      def has_color_glyph?(glyph_id)
+        !layers_for_glyph(glyph_id).empty?
+      end
+
+      # Get all glyph IDs that have color data
+      #
+      # @return [Array<Integer>] Array of glyph IDs with color layers
+      def color_glyph_ids
+        base_glyph_records.map(&:glyph_id)
+      end
+
+      # Get the number of color glyphs in this table
+      #
+      # @return [Integer] Number of base glyphs
+      def num_color_glyphs
+        num_base_glyph_records
+      end
+
+      # Validate the COLR table structure
+      #
+      # @return [Boolean] True if valid
+      def valid?
+        return false if version.nil?
+        return false if version != 0 # Only version 0 supported currently
+        return false if num_base_glyph_records.nil? || num_base_glyph_records.negative?
+        return false if num_layer_records.nil? || num_layer_records.negative?
+        return false unless base_glyph_records
+        return false unless layer_records
+
+        true
+      end
+
+      private
+
+      # Parse COLR header (14 bytes)
+      #
+      # @param io [StringIO] Input stream
+      def parse_header(io)
+        @version = io.read(2).unpack1("n")
+        @num_base_glyph_records = io.read(2).unpack1("n")
+        @base_glyph_records_offset = io.read(4).unpack1("N")
+        @layer_records_offset = io.read(4).unpack1("N")
+        @num_layer_records = io.read(2).unpack1("n")
+      end
+
+      # Validate header values
+      #
+      # @raise [CorruptedTableError] If validation fails
+      def validate_header!
+        unless version.zero?
+          raise CorruptedTableError,
+                "Unsupported COLR version: #{version} (only version 0 supported)"
+        end
+
+        if num_base_glyph_records.negative?
+          raise CorruptedTableError,
+                "Invalid numBaseGlyphRecords: #{num_base_glyph_records}"
+        end
+
+        if num_layer_records.negative?
+          raise CorruptedTableError,
+                "Invalid numLayerRecords: #{num_layer_records}"
+        end
+      end
+
+      # Parse base glyph records array
+      #
+      # @param io [StringIO] Input stream
+      def parse_base_glyph_records(io)
+        @base_glyph_records = []
+        return if num_base_glyph_records.zero?
+
+        # Seek to base glyph records
+        io.seek(base_glyph_records_offset)
+
+        # Parse each base glyph record (6 bytes each)
+        num_base_glyph_records.times do
+          record_data = io.read(6)
+          record = BaseGlyphRecord.read(record_data)
+          @base_glyph_records << record
+        end
+      end
+
+      # Parse layer records array
+      #
+      # @param io [StringIO] Input stream
+      def parse_layer_records(io)
+        @layer_records = []
+        return if num_layer_records.zero?
+
+        # Seek to layer records
+        io.seek(layer_records_offset)
+
+        # Parse each layer record (4 bytes each)
+        num_layer_records.times do
+          record_data = io.read(4)
+          record = LayerRecord.read(record_data)
+          @layer_records << record
+        end
+      end
+
+      # Find base glyph record for a specific glyph ID
+      #
+      # Uses binary search since base glyph records are sorted by glyph ID
+      #
+      # @param glyph_id [Integer] Glyph ID to find
+      # @return [BaseGlyphRecord, nil] Base glyph record or nil if not found
+      def find_base_glyph_record(glyph_id)
+        # Binary search through base glyph records
+        left = 0
+        right = base_glyph_records.length - 1
+
+        while left <= right
+          mid = (left + right) / 2
+          record = base_glyph_records[mid]
+
+          if record.glyph_id == glyph_id
+            return record
+          elsif record.glyph_id < glyph_id
+            left = mid + 1
+          else
+            right = mid - 1
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/fontisan/tables/cpal.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../binary/base_record"
+
+module Fontisan
+  module Tables
+    # CPAL (Color Palette) table parser
+    #
+    # The CPAL table defines color palettes used by COLR layers. Each palette
+    # contains an array of RGBA color values that can be referenced by the
+    # COLR table's palette indices.
+    #
+    # CPAL Table Structure:
+    # ```
+    # CPAL Table = Header
+    #            + Palette Indices Array
+    #            + Color Records Array
+    #            + [Palette Types Array] (version 1)
+    #            + [Palette Labels Array] (version 1)
+    #            + [Palette Entry Labels Array] (version 1)
+    # ```
+    #
+    # Version 0 Header (12 bytes):
+    # - version (uint16): Table version (0 or 1)
+    # - numPaletteEntries (uint16): Number of colors per palette
+    # - numPalettes (uint16): Number of palettes
+    # - numColorRecords (uint16): Total number of color records
+    # - colorRecordsArrayOffset (uint32): Offset to color records array
+    #
+    # Version 1 adds optional metadata for palette types and labels.
+    #
+    # Color Record Structure (4 bytes, BGRA format):
+    # - blue (uint8)
+    # - green (uint8)
+    # - red (uint8)
+    # - alpha (uint8)
+    #
+    # Reference: OpenType CPAL specification
+    # https://docs.microsoft.com/en-us/typography/opentype/spec/cpal
+    #
+    # @example Reading a CPAL table
+    #   data = font.table_data['CPAL']
+    #   cpal = Fontisan::Tables::Cpal.read(data)
+    #   palette = cpal.palette(0)  # Get first palette
+    #   puts palette.colors.first  # => "#RRGGBBAA"
+    class Cpal < Binary::BaseRecord
+      # OpenType table tag for CPAL
+      TAG = "CPAL"
+
+      # @return [Integer] CPAL version (0 or 1)
+      attr_reader :version
+
+      # @return [Integer] Number of color entries per palette
+      attr_reader :num_palette_entries
+
+      # @return [Integer] Number of palettes in this table
+      attr_reader :num_palettes
+
+      # @return [Integer] Total number of color records
+      attr_reader :num_color_records
+
+      # @return [Integer] Offset to color records array
+      attr_reader :color_records_array_offset
+
+      # @return [String] Raw binary data for the entire CPAL table
+      attr_reader :raw_data
+
+      # @return [Array<Integer>] Palette indices (start index for each palette)
+      attr_reader :palette_indices
+
+      # @return [Array<Hash>] Parsed color records (RGBA hashes)
+      attr_reader :color_records
+
+      # Override read to parse CPAL structure
+      #
+      # @param io [IO, String] Binary data to read
+      # @return [Cpal] Parsed CPAL table
+      def self.read(io)
+        cpal = new
+        return cpal if io.nil?
+
+        data = io.is_a?(String) ? io : io.read
+        cpal.parse!(data)
+        cpal
+      end
+
+      # Parse the CPAL table structure
+      #
+      # @param data [String] Binary data for the CPAL table
+      # @raise [CorruptedTableError] If CPAL structure is invalid
+      def parse!(data)
+        @raw_data = data
+        io = StringIO.new(data)
+
+        # Parse CPAL header
+        parse_header(io)
+        validate_header!
+
+        # Parse palette indices array
+        parse_palette_indices(io)
+
+        # Parse color records
+        parse_color_records(io)
+
+        # Version 1 features (palette types, labels) not implemented yet
+        # TODO: Add version 1 features in follow-up task
+      rescue StandardError => e
+        raise CorruptedTableError, "Failed to parse CPAL table: #{e.message}"
+      end
+
+      # Get a specific palette by index
+      #
+      # Returns an array of color strings in hex format (#RRGGBBAA).
+      # Each palette contains num_palette_entries colors.
+      #
+      # @param index [Integer] Palette index (0-based)
+      # @return [Array<String>, nil] Array of hex color strings, or nil if invalid
+      def palette(index)
+        return nil if index.negative? || index >= num_palettes
+
+        # Get starting index for this palette
+        start_index = palette_indices[index]
+
+        # Extract colors for this palette
+        colors = []
+        num_palette_entries.times do |i|
+          color_record = color_records[start_index + i]
+          colors << color_to_hex(color_record) if color_record
+        end
+
+        colors
+      end
+
+      # Get all palettes
+      #
+      # @return [Array<Array<String>>] Array of palettes, each an array of hex colors
+      def all_palettes
+        (0...num_palettes).map { |i| palette(i) }
+      end
+
+      # Get color at specific palette and entry index
+      #
+      # @param palette_index [Integer] Palette index
+      # @param entry_index [Integer] Entry index within palette
+      # @return [String, nil] Hex color string or nil
+      def color_at(palette_index, entry_index)
+        return nil if palette_index.negative? || palette_index >= num_palettes
+        return nil if entry_index.negative? || entry_index >= num_palette_entries
+
+        start_index = palette_indices[palette_index]
+        color_record = color_records[start_index + entry_index]
+        color_record ? color_to_hex(color_record) : nil
+      end
+
+      # Validate the CPAL table structure
+      #
+      # @return [Boolean] True if valid
+      def valid?
+        return false if version.nil?
+        return false unless [0, 1].include?(version)
+        return false if num_palette_entries.nil? || num_palette_entries.negative?
+        return false if num_palettes.nil? || num_palettes.negative?
+        return false if num_color_records.nil? || num_color_records.negative?
+        return false unless palette_indices
+        return false unless color_records
+
+        true
+      end
+
+      private
+
+      # Parse CPAL header (12 bytes for version 0, 16 bytes for version 1)
+      #
+      # @param io [StringIO] Input stream
+      def parse_header(io)
+        @version = io.read(2).unpack1("n")
+        @num_palette_entries = io.read(2).unpack1("n")
+        @num_palettes = io.read(2).unpack1("n")
+        @num_color_records = io.read(2).unpack1("n")
+        @color_records_array_offset = io.read(4).unpack1("N")
+
+        # Version 1 has additional header fields
+        if version == 1
+          # TODO: Parse version 1 header fields
+          # - paletteTypesArrayOffset (uint32)
+          # - paletteLabelsArrayOffset (uint32)
+          # - paletteEntryLabelsArrayOffset (uint32)
+        end
+      end
+
+      # Validate header values
+      #
+      # @raise [CorruptedTableError] If validation fails
+      def validate_header!
+        unless [0, 1].include?(version)
+          raise CorruptedTableError,
+                "Unsupported CPAL version: #{version} (only versions 0 and 1 supported)"
+        end
+
+        if num_palette_entries.negative?
+          raise CorruptedTableError,
+                "Invalid numPaletteEntries: #{num_palette_entries}"
+        end
+
+        if num_palettes.negative?
+          raise CorruptedTableError,
+                "Invalid numPalettes: #{num_palettes}"
+        end
+
+        if num_color_records.negative?
+          raise CorruptedTableError,
+                "Invalid numColorRecords: #{num_color_records}"
+        end
+
+        # Validate that total color records match expected count
+        expected_records = num_palettes * num_palette_entries
+        unless num_color_records >= expected_records
+          raise CorruptedTableError,
+                "Insufficient color records: expected at least #{expected_records}, " \
+                "got #{num_color_records}"
+        end
+      end
+
+      # Parse palette indices array
+      #
+      # @param io [StringIO] Input stream
+      def parse_palette_indices(io)
+        @palette_indices = []
+        return if num_palettes.zero?
+
+        # Palette indices immediately follow header (at offset 12 for v0, 16 for v1)
+        # Each index is uint16 (2 bytes)
+        num_palettes.times do
+          index = io.read(2).unpack1("n")
+          @palette_indices << index
+        end
+      end
+
+      # Parse color records array
+      #
+      # @param io [StringIO] Input stream
+      def parse_color_records(io)
+        @color_records = []
+        return if num_color_records.zero?
+
+        # Seek to color records array
+        io.seek(color_records_array_offset)
+
+        # Parse each color record (4 bytes, BGRA format)
+        num_color_records.times do
+          blue = io.read(1).unpack1("C")
+          green = io.read(1).unpack1("C")
+          red = io.read(1).unpack1("C")
+          alpha = io.read(1).unpack1("C")
+
+          @color_records << {
+            red: red,
+            green: green,
+            blue: blue,
+            alpha: alpha,
+          }
+        end
+      end
+
+      # Convert color record to hex string
+      #
+      # @param color [Hash] Color hash with :red, :green, :blue, :alpha keys
+      # @return [String] Hex color string (#RRGGBBAA)
+      def color_to_hex(color)
+        format(
+          "#%<red>02X%<green>02X%<blue>02X%<alpha>02X",
+          red: color[:red],
+          green: color[:green],
+          blue: color[:blue],
+          alpha: color[:alpha],
+        )
+      end
+    end
+  end
+end

data/lib/fontisan/tables/glyf/glyph_builder.rb

@@ -76,7 +76,7 @@ module Fontisan
         contours = outline.to_truetype_contours
         raise ArgumentError, "no contours in outline" if contours.empty?
 
-        # Calculate bounding box from contours
+        # Calculate bounding box from contours (on-curve points only)
         bbox = calculate_bounding_box(contours)
 
         # Build binary data
@@ -389,6 +389,10 @@ axis)
 
         contours.each do |contour|
           contour.each do |point|
+            # Only consider on-curve points for bounding box
+            # Off-curve points are control points and may lie outside the actual outline
+            next unless point[:on_curve]
+
             x = point[:x]
             y = point[:y]