fontisan 0.2.0 → 0.2.1

data/lib/fontisan/tables/cff/table_builder.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require_relative "private_dict_writer"
+require_relative "offset_recalculator"
+require_relative "index_builder"
+require_relative "dict_builder"
+require_relative "charstring_rebuilder"
+require_relative "hint_operation_injector"
+require "stringio"
+
+module Fontisan
+  module Tables
+    class Cff
+      # Rebuilds CFF table with modifications
+      #
+      # This builder extracts sections from a source CFF table, applies
+      # modifications (e.g., hint parameters to Private DICT), recalculates
+      # offsets, and assembles a new CFF table.
+      #
+      # Process:
+      # 1. Extract all CFF sections (header, indexes, dicts)
+      # 2. Apply modifications to Private DICT
+      # 3. Recalculate offsets (charstrings, private)
+      # 4. Rebuild Top DICT INDEX with new offsets
+      # 5. Reassemble all sections into new CFF table
+      #
+      # @example Rebuild with hints
+      #   new_cff = TableBuilder.rebuild(source_cff, {
+      #     private_dict_hints: { blue_values: [-15, 0], std_hw: 70 }
+      #   })
+      class TableBuilder
+        # Rebuild CFF table with modifications
+        #
+        # @param source_cff [Cff] Source CFF table
+        # @param modifications [Hash] Modifications to apply
+        # @return [String] Binary CFF table data
+        def self.rebuild(source_cff, modifications = {})
+          new(source_cff).tap do |builder|
+            builder.apply_modifications(modifications)
+          end.serialize
+        end
+
+        # Initialize with source CFF
+        #
+        # @param source_cff [Cff] Source CFF table
+        def initialize(source_cff)
+          @source = source_cff
+          @sections = extract_sections
+        end
+
+        # Apply modifications to CFF structure
+        #
+        # @param mods [Hash] Modifications hash
+        def apply_modifications(mods)
+          update_private_dict(mods[:private_dict_hints]) if mods[:private_dict_hints]
+          update_charstrings(mods[:per_glyph_hints]) if mods[:per_glyph_hints]
+        end
+
+        # Serialize to binary CFF table
+        #
+        # @return [String] Binary CFF data
+        def serialize
+          # Calculate initial offsets
+          offsets = OffsetRecalculator.calculate_offsets(@sections)
+          top_dict = extract_top_dict_data
+          updated = OffsetRecalculator.update_top_dict(top_dict, offsets)
+          rebuild_top_dict_index(updated)
+
+          # Recalculate after Top DICT rebuild (size may change)
+          offsets = OffsetRecalculator.calculate_offsets(@sections)
+          updated = OffsetRecalculator.update_top_dict(top_dict, offsets)
+          rebuild_top_dict_index(updated)
+
+          assemble
+        end
+
+        private
+
+        # Extract all CFF sections from source
+        #
+        # @return [Hash] Hash of section_name => binary_data
+        def extract_sections
+          {
+            header: extract_header,
+            name_index: extract_index(@source.name_index),
+            top_dict_index: extract_index(@source.top_dict_index),
+            string_index: extract_index(@source.string_index),
+            global_subr_index: extract_index(@source.global_subr_index),
+            charstrings_index: extract_index(@source.charstrings_index(0)),
+            private_dict: extract_private_dict,
+          }
+        end
+
+        # Extract header bytes
+        #
+        # @return [String] Binary header data
+        def extract_header
+          @source.raw_data[0, @source.header.hdr_size]
+        end
+
+        # Extract INDEX as binary data
+        #
+        # @param index [Index] INDEX object
+        # @return [String] Binary INDEX data
+        def extract_index(index)
+          return [0].pack("n") if index.nil? || index.count.zero?
+
+          start = index.instance_variable_get(:@start_offset)
+          io = StringIO.new(@source.raw_data)
+          io.seek(start)
+
+          count = io.read(2).unpack1("n")
+          return [0].pack("n") if count.zero?
+
+          off_size = io.read(1).unpack1("C")
+          offset_array_size = (count + 1) * off_size
+
+          # Read last offset to determine data size
+          io.seek(start + 3 + count * off_size)
+          last_offset = read_offset(io, off_size)
+          data_size = last_offset - 1
+
+          # Read entire INDEX
+          io.seek(start)
+          io.read(3 + offset_array_size + data_size)
+        end
+
+        # Extract Private DICT bytes
+        #
+        # @return [String] Binary Private DICT data
+        def extract_private_dict
+          priv_info = @source.top_dict(0).private
+          return "".b unless priv_info
+
+          size, offset = priv_info
+          @source.raw_data[offset, size]
+        end
+
+        # Update Private DICT with hints
+        #
+        # @param hints [Hash] Hint parameters
+        def update_private_dict(hints)
+          source_priv = @source.private_dict(0)
+          writer = PrivateDictWriter.new(source_priv)
+          writer.update_hints(hints)
+          @sections[:private_dict] = writer.serialize
+        end
+
+        # Update CharStrings with per-glyph hints
+        #
+        # @param per_glyph_hints [Hash] Hash of glyph_id => Array<Hint>
+        def update_charstrings(per_glyph_hints)
+          return if per_glyph_hints.nil? || per_glyph_hints.empty?
+
+          # Create CharStringRebuilder
+          charstrings_index = @source.charstrings_index(0)
+          rebuilder = CharStringRebuilder.new(charstrings_index)
+
+          # Inject hints for each glyph
+          per_glyph_hints.each do |glyph_id, hints|
+            injector = HintOperationInjector.new
+
+            rebuilder.modify_charstring(glyph_id) do |operations|
+              # Inject hint operations
+              injector.inject(hints, operations)
+            end
+          end
+
+          # Rebuild CharStrings INDEX
+          @sections[:charstrings_index] = rebuilder.rebuild
+        end
+
+        # Extract Top DICT data as hash
+        #
+        # @return [Hash] Top DICT parameters
+        def extract_top_dict_data
+          @source.top_dict(0).to_h
+        end
+
+        # Rebuild Top DICT INDEX with updated data
+        #
+        # @param data [Hash] Top DICT parameters
+        def rebuild_top_dict_index(data)
+          dict_bytes = DictBuilder.build(data)
+          @sections[:top_dict_index] = IndexBuilder.build([dict_bytes])
+        end
+
+        # Assemble all sections into CFF table
+        #
+        # @return [String] Binary CFF table
+        def assemble
+          output = StringIO.new("".b)
+          output.write(@sections[:header])
+          output.write(@sections[:name_index])
+          output.write(@sections[:top_dict_index])
+          output.write(@sections[:string_index])
+          output.write(@sections[:global_subr_index])
+          output.write(@sections[:charstrings_index])
+          output.write(@sections[:private_dict])
+          output.string
+        end
+
+        # Read offset of specified size
+        #
+        # @param io [IO] IO object
+        # @param size [Integer] Offset size (1-4 bytes)
+        # @return [Integer] Offset value
+        def read_offset(io, size)
+          case size
+          when 1 then io.read(1).unpack1("C")
+          when 2 then io.read(2).unpack1("n")
+          when 3
+            bytes = io.read(3).unpack("C*")
+            (bytes[0] << 16) | (bytes[1] << 8) | bytes[2]
+          when 4 then io.read(4).unpack1("N")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/tables/cff.rb

@@ -479,6 +479,8 @@ module Fontisan
     require_relative "cff/top_dict"
     require_relative "cff/private_dict"
     require_relative "cff/charstring"
+    require_relative "cff/charstring_parser"
+    require_relative "cff/charstring_rebuilder"
     require_relative "cff/charstrings_index"
     require_relative "cff/charset"
     require_relative "cff/encoding"

data/lib/fontisan/tables/cff2/private_dict_blend_handler.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Tables
+    class Cff2
+      # Private DICT blend handler for CFF2
+      #
+      # Handles blend operators in Private DICT which allow hint parameters
+      # to vary across the design space in variable fonts.
+      #
+      # Blend in Private DICT format:
+      #   base_value delta1 delta2 ... deltaN num_axes blend
+      #
+      # Example for BlueValues with 2 axes:
+      #   -10 2 1   0 1 0   500 10 5   510 12 6   2 blend
+      #   This creates BlueValues that vary across the design space.
+      #
+      # Reference: Adobe Technical Note #5177 (CFF2)
+      #
+      # @example Parsing blend in Private DICT
+      #   handler = PrivateDictBlendHandler.new(private_dict)
+      #   blue_values = handler.parse_blend_array(:blue_values, num_axes: 2)
+      class PrivateDictBlendHandler
+        # @return [Hash] Private DICT data
+        attr_reader :private_dict
+
+        # Initialize handler with Private DICT data
+        #
+        # @param private_dict [Hash] Parsed Private DICT
+        def initialize(private_dict)
+          @private_dict = private_dict
+        end
+
+        # Check if Private DICT contains blend data
+        #
+        # @return [Boolean] True if blend operators are present
+        def has_blend?
+          # In a DICT with blend, values are arrays with blend data
+          @private_dict.values.any? { |v| blend_value?(v) }
+        end
+
+        # Parse blended array (like BlueValues)
+        #
+        # @param key [Symbol, Integer] DICT operator key
+        # @param num_axes [Integer] Number of variation axes
+        # @return [Hash, nil] Parsed blend data or nil if not present
+        def parse_blend_array(key, num_axes:)
+          value = @private_dict[key]
+          return nil unless value.is_a?(Array)
+
+          # Check if this is blend data
+          # Format: base1 delta1_1 ... delta1_N base2 delta2_1 ... delta2_N ...
+          # The array must be divisible by (num_axes + 1)
+          return nil unless value.size % (num_axes + 1) == 0
+
+          num_values = value.size / (num_axes + 1)
+          blends = []
+
+          num_values.times do |i|
+            offset = i * (num_axes + 1)
+            base = value[offset]
+            deltas = value[offset + 1, num_axes] || []
+
+            blends << {
+              base: base,
+              deltas: deltas
+            }
+          end
+
+          {
+            num_values: num_values,
+            num_axes: num_axes,
+            blends: blends
+          }
+        end
+
+        # Parse single blended value
+        #
+        # @param key [Symbol, Integer] DICT operator key
+        # @param num_axes [Integer] Number of variation axes
+        # @return [Hash, nil] Parsed blend data or nil if not present
+        def parse_blend_value(key, num_axes:)
+          value = @private_dict[key]
+          return nil unless value.is_a?(Array)
+
+          # Single value format: base delta1 delta2 ... deltaN
+          expected_size = num_axes + 1
+          return nil unless value.size == expected_size
+
+          {
+            base: value[0],
+            deltas: value[1..num_axes],
+            num_axes: num_axes
+          }
+        end
+
+        # Apply blend at specific coordinates
+        #
+        # @param blend_data [Hash] Parsed blend data
+        # @param scalars [Array<Float>] Region scalars for each axis
+        # @return [Array<Float>, Float] Blended values
+        def apply_blend(blend_data, scalars)
+          return nil unless blend_data
+
+          if blend_data.key?(:blends)
+            # Array of blended values
+            blend_data[:blends].map do |blend|
+              apply_single_blend(blend, scalars)
+            end
+          else
+            # Single blended value
+            apply_single_blend(blend_data, scalars)
+          end
+        end
+
+        # Apply blend to a single value
+        #
+        # @param blend [Hash] Single blend with :base and :deltas
+        # @param scalars [Array<Float>] Region scalars
+        # @return [Float] Blended value
+        def apply_single_blend(blend, scalars)
+          base = blend[:base].to_f
+          deltas = blend[:deltas]
+
+          # Apply formula: result = base + Σ(delta[i] * scalar[i])
+          result = base
+          deltas.each_with_index do |delta, i|
+            scalar = scalars[i] || 0.0
+            result += delta.to_f * scalar
+          end
+
+          result
+        end
+
+        # Get blended Private DICT values at coordinates
+        #
+        # @param num_axes [Integer] Number of variation axes
+        # @param scalars [Array<Float>] Region scalars
+        # @return [Hash] Private DICT with blended values
+        def blended_dict(num_axes:, scalars:)
+          result = {}
+
+          @private_dict.each do |key, value|
+            if value.is_a?(Array) && blend_value?(value)
+              # Try parsing as blend array
+              blend_data = parse_blend_array(key, num_axes: num_axes)
+              if blend_data
+                result[key] = apply_blend(blend_data, scalars)
+              else
+                # Try as single blend value
+                blend_data = parse_blend_value(key, num_axes: num_axes)
+                result[key] = blend_data ? apply_blend(blend_data, scalars) : value
+              end
+            else
+              # Non-blend value, copy as-is
+              result[key] = value
+            end
+          end
+
+          result
+        end
+
+        # Check if value looks like blend data
+        #
+        # @param value [Object] Value to check
+        # @return [Boolean] True if value could be blend data
+        def blend_value?(value)
+          # Blend values are arrays with multiple elements
+          value.is_a?(Array) && value.size > 1
+        end
+
+        # Rebuild Private DICT with hints injected
+        #
+        # This method prepares Private DICT for rebuilding, preserving
+        # blend operators while incorporating new hint values.
+        #
+        # @param hints [Hash] Hint values to inject
+        # @param num_axes [Integer] Number of variation axes
+        # @return [Hash] Modified Private DICT
+        def rebuild_with_hints(hints, num_axes:)
+          result = @private_dict.dup
+
+          # Inject hint values
+          hints.each do |key, value|
+            if value.is_a?(Hash) && (value.key?(:base) || value.key?("base")) && (value.key?(:deltas) || value.key?("deltas"))
+              # Hint with blend data - normalize and flatten for DICT storage
+              normalized_value = {
+                base: value[:base] || value["base"],
+                deltas: value[:deltas] || value["deltas"]
+              }
+              result[key] = flatten_blend(normalized_value, num_axes: num_axes)
+            else
+              # Simple hint value
+              result[key] = value
+            end
+          end
+
+          result
+        end
+
+        # Flatten blend data to array format
+        #
+        # @param blend_data [Hash] Blend data with :base and :deltas
+        # @param num_axes [Integer] Number of variation axes
+        # @return [Array] Flattened array
+        def flatten_blend(blend_data, num_axes:)
+          if blend_data.key?(:blends)
+            # Array of blends
+            blend_data[:blends].flat_map do |blend|
+              [blend[:base]] + blend[:deltas]
+            end
+          else
+            # Single blend
+            [blend_data[:base]] + blend_data[:deltas]
+          end
+        end
+
+        # Validate blend data structure
+        #
+        # @param num_axes [Integer] Expected number of axes
+        # @return [Array<String>] Validation errors (empty if valid)
+        def validate(num_axes:)
+          errors = []
+
+          @private_dict.each do |key, value|
+            next unless value.is_a?(Array)
+            next unless blend_value?(value)
+
+            # Try parsing as blend array
+            blend_data = parse_blend_array(key, num_axes: num_axes)
+            unless blend_data
+              # Try as single blend value
+              blend_data = parse_blend_value(key, num_axes: num_axes)
+              unless blend_data
+                errors << "Key #{key} has array value that doesn't match " \
+                          "blend format for #{num_axes} axes"
+              end
+            end
+          end
+
+          errors
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/tables/cff2/region_matcher.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Tables
+    class Cff2
+      # Region matcher for calculating variation scalars
+      #
+      # Maps design space coordinates to region scalars based on
+      # the Variable Store region definitions. Each region defines
+      # a range (start, peak, end) for each variation axis.
+      #
+      # Scalar Calculation:
+      # - If coordinate is at peak: scalar = 1.0
+      # - If coordinate is between start and peak: linear interpolation
+      # - If coordinate is between peak and end: linear interpolation
+      # - If coordinate is outside [start, end]: scalar = 0.0
+      #
+      # Reference: OpenType Font Variations Overview
+      # Reference: Adobe Technical Note #5177 (CFF2)
+      #
+      # @example Calculating scalars
+      #   matcher = RegionMatcher.new(regions)
+      #   scalars = matcher.calculate_scalars({ "wght" => 0.5, "wdth" => 0.3 })
+      class RegionMatcher
+        # @return [Array<Hash>] Regions from Variable Store
+        attr_reader :regions
+
+        # Initialize matcher with regions
+        #
+        # @param regions [Array<Hash>] Region definitions from Variable Store
+        def initialize(regions)
+          @regions = regions
+        end
+
+        # Calculate scalars for all regions at given coordinates
+        #
+        # Coordinates are normalized values in the range [-1.0, 1.0]
+        # where 0.0 represents the default/regular style.
+        #
+        # @param coordinates [Array<Float>] Normalized coordinates per axis
+        # @return [Array<Float>] Scalars for each region
+        def calculate_scalars(coordinates)
+          @regions.map do |region|
+            calculate_region_scalar(region, coordinates)
+          end
+        end
+
+        # Calculate scalar for a single region
+        #
+        # The scalar is the product of scalars for all axes in the region.
+        # If any axis has scalar 0.0, the entire region scalar is 0.0.
+        #
+        # @param region [Hash] Region definition
+        # @param coordinates [Array<Float>] Normalized coordinates per axis
+        # @return [Float] Scalar for the region (0.0 to 1.0)
+        def calculate_region_scalar(region, coordinates)
+          axes = region[:axes]
+
+          # Multiply scalars for all axes
+          scalar = 1.0
+          axes.each_with_index do |axis, i|
+            coord = coordinates[i] || 0.0
+            axis_scalar = calculate_axis_scalar(axis, coord)
+            scalar *= axis_scalar
+
+            # Early exit if any axis is out of range
+            return 0.0 if axis_scalar.zero?
+          end
+
+          scalar
+        end
+
+        # Calculate scalar for a single axis
+        #
+        # @param axis [Hash] Axis definition with :start_coord, :peak_coord, :end_coord
+        # @param coordinate [Float] Normalized coordinate for this axis
+        # @return [Float] Scalar for this axis (0.0 to 1.0)
+        def calculate_axis_scalar(axis, coordinate)
+          start_coord = axis[:start_coord]
+          peak_coord = axis[:peak_coord]
+          end_coord = axis[:end_coord]
+
+          # Outside the region
+          return 0.0 if coordinate < start_coord || coordinate > end_coord
+
+          # At or beyond peak
+          return 1.0 if coordinate == peak_coord
+
+          # Between start and peak
+          if coordinate < peak_coord
+            # Linear interpolation: (coord - start) / (peak - start)
+            range = peak_coord - start_coord
+            return 1.0 if range.zero? # Avoid division by zero
+
+            (coordinate - start_coord) / range
+          else
+            # Between peak and end
+            # Linear interpolation: (end - coord) / (end - peak)
+            range = end_coord - peak_coord
+            return 1.0 if range.zero? # Avoid division by zero
+
+            (end_coord - coordinate) / range
+          end
+        end
+
+        # Check if coordinates are within any region
+        #
+        # @param coordinates [Array<Float>] Normalized coordinates
+        # @return [Boolean] True if coordinates activate any region
+        def coordinates_active?(coordinates)
+          scalars = calculate_scalars(coordinates)
+          scalars.any?(&:positive?)
+        end
+
+        # Get active regions for coordinates
+        #
+        # Returns indices of regions that have non-zero scalars
+        #
+        # @param coordinates [Array<Float>] Normalized coordinates
+        # @return [Array<Integer>] Indices of active regions
+        def active_regions(coordinates)
+          scalars = calculate_scalars(coordinates)
+          scalars.each_with_index.select { |scalar, _| scalar.positive? }
+                 .map(&:last)
+        end
+
+        # Get scalar for specific region index
+        #
+        # @param region_index [Integer] Region index
+        # @param coordinates [Array<Float>] Normalized coordinates
+        # @return [Float, nil] Scalar for the region, or nil if index invalid
+        def scalar_for_region(region_index, coordinates)
+          return nil if region_index >= @regions.size
+
+          region = @regions[region_index]
+          calculate_region_scalar(region, coordinates)
+        end
+
+        # Validate region structure
+        #
+        # @return [Array<String>] Array of validation errors (empty if valid)
+        def validate
+          errors = []
+
+          @regions.each_with_index do |region, i|
+            axes = region[:axes]
+            unless axes.is_a?(Array)
+              errors << "Region #{i} has invalid axes (not an array)"
+              next
+            end
+
+            axes.each_with_index do |axis, j|
+              unless axis.is_a?(Hash)
+                errors << "Region #{i}, axis #{j} is not a hash"
+                next
+              end
+
+              # Check required keys
+              %i[start_coord peak_coord end_coord].each do |key|
+                unless axis.key?(key)
+                  errors << "Region #{i}, axis #{j} missing #{key}"
+                end
+              end
+
+              # Validate coordinate ordering
+              if axis[:start_coord] && axis[:peak_coord] && axis[:end_coord]
+                start = axis[:start_coord]
+                peak = axis[:peak_coord]
+                ending = axis[:end_coord]
+
+                unless start <= peak && peak <= ending
+                  errors << "Region #{i}, axis #{j} has invalid ordering: " \
+                            "#{start} > #{peak} > #{ending}"
+                end
+              end
+            end
+          end
+
+          errors
+        end
+
+        # Get number of axes from first region
+        #
+        # @return [Integer] Number of axes
+        def axis_count
+          return 0 if @regions.empty?
+
+          @regions.first[:axis_count] || @regions.first[:axes]&.size || 0
+        end
+
+        # Check if matcher has regions
+        #
+        # @return [Boolean] True if regions are present
+        def has_regions?
+          !@regions.empty?
+        end
+      end
+    end
+  end
+end