fontisan 0.1.0 → 0.2.0

data/lib/fontisan/variation/converter.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+require_relative "interpolator"
+require_relative "table_accessor"
+
+module Fontisan
+  module Variation
+    # Converts variation data between TrueType (gvar) and CFF2 (blend) formats
+    #
+    # This class enables format conversion while preserving variation data:
+    # - gvar tuples → CFF2 blend operators
+    # - CFF2 blend operators → gvar tuples
+    #
+    # Process for gvar → blend:
+    # 1. Extract tuple variations from gvar
+    # 2. Map tuple regions to blend regions
+    # 3. Embed blend operators in CharStrings at control points
+    # 4. Encode delta values in blend format
+    #
+    # Process for blend → gvar:
+    # 1. Parse CharStrings with blend operators
+    # 2. Extract blend deltas and regions
+    # 3. Map to gvar tuple format
+    # 4. Build gvar table structure
+    #
+    # @example Converting gvar to CFF2 blend
+    #   converter = VariationConverter.new(font, axes)
+    #   blend_data = converter.gvar_to_blend(glyph_id)
+    #
+    # @example Converting CFF2 blend to gvar
+    #   converter = VariationConverter.new(font, axes)
+    #   tuple_data = converter.blend_to_gvar(glyph_id)
+    class VariationConverter
+      include TableAccessor
+
+      # @return [TrueTypeFont, OpenTypeFont] Font instance
+      attr_reader :font
+
+      # @return [Array<VariationAxisRecord>] Variation axes
+      attr_reader :axes
+
+      # Initialize converter
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] Font instance
+      # @param axes [Array<VariationAxisRecord>] Variation axes from fvar
+      def initialize(font, axes)
+        @font = font
+        @axes = axes || []
+        @variation_tables = {}
+      end
+
+      # Convert gvar tuples to CFF2 blend format for a glyph
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @return [Hash, nil] Blend data or nil
+      def gvar_to_blend(glyph_id)
+        return nil unless has_variation_table?("gvar")
+        return nil unless has_variation_table?("glyf")
+
+        gvar = variation_table("gvar")
+        return nil unless gvar
+
+        # Get tuple variations for this glyph
+        tuple_data = gvar.glyph_tuple_variations(glyph_id)
+        return nil unless tuple_data
+
+        # Convert tuples to blend format
+        convert_tuples_to_blend(tuple_data)
+      end
+
+      # Convert CFF2 blend operators to gvar tuple format for a glyph
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @return [Hash, nil] Tuple data or nil
+      def blend_to_gvar(_glyph_id)
+        return nil unless has_variation_table?("CFF2")
+
+        cff2 = variation_table("CFF2")
+        return nil unless cff2
+
+        # Get CharString with blend operators
+        # This is a placeholder - full implementation would parse CharString
+        # and extract blend operator data
+
+        # Convert blend data to tuples
+        # Placeholder for full implementation
+        nil
+      end
+
+      # Check if variation data can be converted
+      #
+      # @return [Boolean] True if conversion possible
+      def can_convert?
+        !@axes.empty? && (
+          has_variation_table?("gvar") ||
+          has_variation_table?("CFF2")
+        )
+      end
+
+      private
+
+      # Convert tuple variations to blend format
+      #
+      # @param tuple_data [Hash] Tuple variation data from gvar
+      # @return [Hash] Blend format data
+      def convert_tuples_to_blend(tuple_data)
+        tuples = tuple_data[:tuples] || []
+        point_count = tuple_data[:point_count] || 0
+
+        # Build blend regions from tuples
+        regions = tuples.map { |tuple| build_region_from_tuple(tuple) }
+
+        # Extract deltas for each point
+        point_deltas = extract_point_deltas(tuples, point_count)
+
+        {
+          regions: regions,
+          point_deltas: point_deltas,
+          num_regions: regions.length,
+          num_axes: @axes.length,
+        }
+      end
+
+      # Build region from tuple peak/start/end coordinates
+      #
+      # @param tuple [Hash] Tuple data with :peak, :start, :end
+      # @return [Hash] Region definition
+      def build_region_from_tuple(tuple)
+        region = {}
+
+        @axes.each_with_index do |axis, axis_index|
+          # Extract coordinates for this axis
+          peak = tuple[:peak] ? tuple[:peak][axis_index] : 0.0
+          start_val = tuple[:start] ? tuple[:start][axis_index] : -1.0
+          end_val = tuple[:end] ? tuple[:end][axis_index] : 1.0
+
+          region[axis.axis_tag] = {
+            start: start_val,
+            peak: peak,
+            end: end_val,
+          }
+        end
+
+        region
+      end
+
+      # Extract point deltas from all tuples
+      #
+      # @param tuples [Array<Hash>] Tuple variations
+      # @param point_count [Integer] Number of points
+      # @return [Array<Array<Hash>>] Deltas per point per tuple
+      def extract_point_deltas(tuples, point_count)
+        return [] if point_count.zero?
+
+        # Initialize deltas array
+        point_deltas = Array.new(point_count) { [] }
+
+        # For each tuple, extract deltas for all points
+        tuples.each do |tuple|
+          deltas = parse_tuple_deltas(tuple, point_count)
+
+          deltas.each_with_index do |delta, point_index|
+            point_deltas[point_index] << delta
+          end
+        end
+
+        point_deltas
+      end
+
+      # Parse deltas from a tuple
+      #
+      # @param tuple [Hash] Tuple data
+      # @param point_count [Integer] Number of points
+      # @return [Array<Hash>] Deltas with :x and :y
+      def parse_tuple_deltas(_tuple, point_count)
+        # This is a placeholder - full implementation would:
+        # 1. Parse delta data from tuple
+        # 2. Decompress if needed
+        # 3. Return array of { x: dx, y: dy } for each point
+
+        Array.new(point_count) { { x: 0, y: 0 } }
+      end
+
+      # Convert blend data to tuple format
+      #
+      # @param blend_data [Hash] Blend format data
+      # @return [Hash] Tuple variation data
+      def convert_blend_to_tuples(blend_data)
+        regions = blend_data[:regions] || []
+        point_deltas = blend_data[:point_deltas] || []
+
+        # Build tuples from regions
+        tuples = regions.map.with_index do |region, region_index|
+          build_tuple_from_region(region, point_deltas, region_index)
+        end
+
+        {
+          tuples: tuples,
+          point_count: point_deltas.length,
+        }
+      end
+
+      # Build tuple from region and deltas
+      #
+      # @param region [Hash] Region definition
+      # @param point_deltas [Array<Array<Hash>>] Deltas per point
+      # @param region_index [Integer] Region index
+      # @return [Hash] Tuple data
+      def build_tuple_from_region(region, point_deltas, region_index)
+        # Extract peak, start, end for all axes
+        peak = Array.new(@axes.length, 0.0)
+        start_vals = Array.new(@axes.length, -1.0)
+        end_vals = Array.new(@axes.length, 1.0)
+
+        @axes.each_with_index do |axis, axis_index|
+          axis_region = region[axis.axis_tag]
+          next unless axis_region
+
+          peak[axis_index] = axis_region[:peak]
+          start_vals[axis_index] = axis_region[:start]
+          end_vals[axis_index] = axis_region[:end]
+        end
+
+        # Extract deltas for this region
+        deltas = point_deltas.map do |point_delta_set|
+          point_delta_set[region_index] || { x: 0, y: 0 }
+        end
+
+        {
+          peak: peak,
+          start: start_vals,
+          end: end_vals,
+          deltas: deltas,
+        }
+      end
+
+      # Encode deltas in CharString blend format
+      #
+      # @param base_value [Numeric] Base value
+      # @param deltas [Array<Numeric>] Delta values
+      # @return [Array<Numeric>] Blend operator arguments
+      def encode_blend_operator(base_value, deltas)
+        # CFF2 blend format: base_value delta1 delta2 ... K N blend
+        # Where K = number of deltas, N = number of blend operations
+        [base_value] + deltas + [deltas.length, 1]
+      end
+
+      # Decode blend operator arguments to base and deltas
+      #
+      # @param args [Array<Numeric>] Blend operator arguments
+      # @return [Hash] Base value and deltas
+      def decode_blend_operator(args)
+        return { base: 0, deltas: [] } if args.length < 3
+
+        # Last two values are K and N
+        k = args[-2]
+        _n = args[-1]
+
+        # Before K and N: base + deltas
+        values = args[0...-2]
+        base = values[0] || 0
+        deltas = values[1, k] || []
+
+        { base: base, deltas: deltas }
+      end
+    end
+  end
+end

data/lib/fontisan/variation/data_extractor.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative "variation_context"
+
+module Fontisan
+  module Variation
+    # Extracts variation data from OpenType variable fonts
+    #
+    # This class provides a unified interface to extract variation information
+    # from variable fonts, including:
+    # - Variation axes (from fvar table)
+    # - Named instances (from fvar table)
+    # - Variation type (TrueType gvar or PostScript CFF2)
+    #
+    # @example Extracting variation data
+    #   extractor = Fontisan::Variation::DataExtractor.new(font)
+    #   data = extractor.extract
+    #   if data
+    #     puts "Axes: #{data[:axes].map(&:axis_tag).join(', ')}"
+    #     puts "Instances: #{data[:instances].length}"
+    #   end
+    class DataExtractor
+      # Initialize extractor with a font
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] Font to extract from
+      def initialize(font)
+        @font = font
+        @context = VariationContext.new(font)
+      end
+
+      # Extract variation data from the font
+      #
+      # @return [Hash, nil] Variation data or nil if not a variable font
+      def extract
+        return nil unless @context.variable_font?
+
+        {
+          axes: extract_axes,
+          instances: extract_instances,
+          has_gvar: @font.has_table?("gvar"),
+          has_cff2: @font.has_table?("CFF2"),
+          variation_type: @context.variation_type,
+        }
+      end
+
+      # Check if font is a variable font
+      #
+      # @return [Boolean] True if font has fvar table
+      def variable_font?
+        @context.variable_font?
+      end
+
+      private
+
+      # Extract variation axes from fvar table
+      #
+      # @return [Array<VariationAxisRecord>] Array of axis records
+      # @raise [VariationDataCorruptedError] If axes cannot be extracted
+      def extract_axes
+        return [] unless @context.fvar
+
+        @context.axes
+      rescue StandardError => e
+        raise VariationDataCorruptedError.new(
+          message: "Failed to extract variation axes: #{e.message}",
+          details: { error_class: e.class.name },
+        )
+      end
+
+      # Extract named instances from fvar table
+      #
+      # @return [Array<Hash>] Array of instance information
+      # @raise [VariationDataCorruptedError] If instances cannot be extracted
+      def extract_instances
+        return [] unless @context.fvar
+
+        @context.fvar.instances || []
+      rescue StandardError => e
+        raise VariationDataCorruptedError.new(
+          message: "Failed to extract instances: #{e.message}",
+          details: { error_class: e.class.name },
+        )
+      end
+    end
+  end
+end

data/lib/fontisan/variation/delta_applier.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+require_relative "delta_parser"
+require_relative "interpolator"
+require_relative "region_matcher"
+require_relative "table_accessor"
+
+module Fontisan
+  module Variation
+    # Applies variation deltas to glyph outlines
+    #
+    # This class handles the complete delta application process for TrueType
+    # variable fonts using gvar table data:
+    # 1. Parse base glyph outline points
+    # 2. Match active tuple variations to coordinates
+    # 3. Parse and decompress deltas
+    # 4. Apply deltas: new_point = base + Σ(delta × scalar)
+    # 5. Expand IUP (Inferred Untouched Points)
+    #
+    # Reference: OpenType specification, gvar table
+    #
+    # @example Applying deltas to a glyph
+    #   applier = Fontisan::Variation::DeltaApplier.new(font, interpolator, region_matcher)
+    #   adjusted_points = applier.apply_deltas(glyph_id, coordinates)
+    class DeltaApplier
+      include TableAccessor
+
+      # @return [Font] Font object
+      attr_reader :font
+
+      # @return [Interpolator] Coordinate interpolator
+      attr_reader :interpolator
+
+      # @return [RegionMatcher] Region matcher
+      attr_reader :region_matcher
+
+      # @return [DeltaParser] Delta parser
+      attr_reader :delta_parser
+
+      # Initialize delta applier
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] Font with gvar table
+      # @param interpolator [Interpolator] Coordinate interpolator
+      # @param region_matcher [RegionMatcher] Region matcher
+      def initialize(font, interpolator, region_matcher)
+        @font = font
+        @interpolator = interpolator
+        @region_matcher = region_matcher
+        @delta_parser = DeltaParser.new
+        @variation_tables = {}
+      end
+
+      # Apply deltas to a glyph at given coordinates
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @param coordinates [Hash<String, Float>] Design space coordinates
+      # @return [Array<Hash>, nil] Adjusted points or nil if not applicable
+      def apply_deltas(glyph_id, coordinates)
+        gvar = variation_table("gvar")
+        glyf = variation_table("glyf")
+        return nil unless gvar && glyf
+
+        # Get base glyph outline points
+        base_points = extract_glyph_points(glyph_id, glyf)
+        return nil if base_points.nil? || base_points.empty?
+
+        # Get tuple variations for this glyph
+        tuple_data = gvar.glyph_tuple_variations(glyph_id)
+        return base_points if tuple_data.nil? || tuple_data[:tuples].empty?
+
+        # Match active tuples to coordinates
+        matches = @region_matcher.match_tuples(
+          coordinates: coordinates,
+          tuples: tuple_data[:tuples],
+        )
+
+        return base_points if matches.empty?
+
+        # Apply each active tuple's deltas
+        adjusted_points = base_points.dup
+        matches.each do |match|
+          apply_tuple_deltas(adjusted_points, match, tuple_data, base_points.length)
+        end
+
+        adjusted_points
+      end
+
+      # Extract outline points from glyph
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @param glyf [Glyf] Glyf table
+      # @return [Array<Hash>, nil] Array of points with :x, :y, :on_curve
+      def extract_glyph_points(glyph_id, glyf)
+        # This is a simplified version - full implementation would parse
+        # complete glyf table data including composite glyphs
+        glyph_data = glyf.glyph_data(glyph_id)
+        return nil if glyph_data.nil?
+
+        # Parse glyph outline (simplified)
+        # Real implementation would fully parse SimpleGlyph or CompositeGlyph
+        []
+      end
+
+      private
+
+      # Apply a single tuple's deltas to points
+      #
+      # @param points [Array<Hash>] Points to adjust (modified in place)
+      # @param match [Hash] Matched tuple with :tuple and :scalar
+      # @param tuple_data [Hash] Complete tuple data from gvar
+      # @param point_count [Integer] Number of points
+      def apply_tuple_deltas(points, match, tuple_data, point_count)
+        tuple = match[:tuple]
+        scalar = match[:scalar]
+
+        return if scalar.zero?
+
+        # Parse deltas for this tuple
+        # Note: In real implementation, we'd need to extract the actual
+        # delta data from the gvar table at the correct offset
+        deltas = parse_tuple_deltas(tuple, point_count, tuple_data)
+        return if deltas.nil?
+
+        # Check if points need IUP expansion
+        if tuple[:private_points]
+          # Expand IUP for untouched points
+          deltas = expand_iup(deltas, point_count)
+        end
+
+        # Apply deltas with scalar
+        points.each_with_index do |point, i|
+          next if i >= deltas.length
+
+          delta = deltas[i]
+          point[:x] += delta[:x] * scalar
+          point[:y] += delta[:y] * scalar
+        end
+      end
+
+      # Parse deltas for a tuple variation
+      #
+      # @param tuple [Hash] Tuple variation info
+      # @param point_count [Integer] Number of points
+      # @param tuple_data [Hash] Complete tuple data
+      # @return [Array<Hash>, nil] Array of point deltas
+      def parse_tuple_deltas(tuple, point_count, tuple_data)
+        # In real implementation, this would:
+        # 1. Calculate offset to delta data
+        # 2. Extract raw delta bytes
+        # 3. Call delta_parser.parse with appropriate flags
+
+        # Placeholder - full implementation needs access to raw delta data
+        @delta_parser.parse(
+          "",
+          point_count,
+          private_points: tuple[:private_points],
+          shared_points: tuple_data[:has_shared_points] ? [] : nil,
+        )
+      end
+
+      # Expand IUP (Inferred Untouched Points)
+      #
+      # Points without explicit deltas have their deltas inferred through
+      # linear interpolation between surrounding touched points.
+      #
+      # @param deltas [Array<Hash>] Delta array (sparse)
+      # @param point_count [Integer] Total number of points
+      # @return [Array<Hash>] Expanded delta array
+      def expand_iup(deltas, point_count)
+        return deltas if deltas.length == point_count
+
+        expanded = Array.new(point_count) { { x: 0, y: 0 } }
+
+        # Copy explicit deltas
+        deltas.each_with_index do |delta, i|
+          next if i >= point_count
+
+          expanded[i] = delta if delta[:x] != 0 || delta[:y] != 0
+        end
+
+        # Find touched points
+        touched = []
+        deltas.each_with_index do |delta, i|
+          touched << i if delta[:x] != 0 || delta[:y] != 0
+        end
+
+        return expanded if touched.empty?
+
+        # Infer untouched points
+        point_count.times do |i|
+          next if touched.include?(i)
+
+          # Find previous and next touched points
+          prev_idx = find_previous_touched(touched, i)
+          next_idx = find_next_touched(touched, i, point_count)
+
+          # Interpolate delta
+          if prev_idx && next_idx
+            expanded[i] = interpolate_delta(
+              deltas[prev_idx],
+              deltas[next_idx],
+              i, prev_idx, next_idx
+            )
+          elsif prev_idx
+            # Use previous delta
+            expanded[i] = deltas[prev_idx].dup
+          elsif next_idx
+            # Use next delta
+            expanded[i] = deltas[next_idx].dup
+          end
+        end
+
+        expanded
+      end
+
+      # Find previous touched point
+      #
+      # @param touched [Array<Integer>] Touched point indices
+      # @param index [Integer] Current point index
+      # @return [Integer, nil] Previous touched index or nil
+      def find_previous_touched(touched, index)
+        touched.reverse_each do |t|
+          return t if t < index
+        end
+        nil
+      end
+
+      # Find next touched point
+      #
+      # @param touched [Array<Integer>] Touched point indices
+      # @param index [Integer] Current point index
+      # @param point_count [Integer] Total points (for wrapping)
+      # @return [Integer, nil] Next touched index or nil
+      def find_next_touched(touched, index, _point_count)
+        # Check forward
+        touched.each do |t|
+          return t if t > index
+        end
+
+        # Wrap around (contour is closed)
+        touched.first
+      end
+
+      # Interpolate delta between two touched points
+      #
+      # @param delta1 [Hash] First delta
+      # @param delta2 [Hash] Second delta
+      # @param current [Integer] Current point index
+      # @param idx1 [Integer] First point index
+      # @param idx2 [Integer] Second point index
+      # @return [Hash] Interpolated delta
+      def interpolate_delta(delta1, delta2, current, idx1, idx2)
+        # Linear interpolation
+        range = idx2 - idx1
+        return delta1.dup if range.zero?
+
+        ratio = (current - idx1).to_f / range
+
+        {
+          x: delta1[:x] + (delta2[:x] - delta1[:x]) * ratio,
+          y: delta1[:y] + (delta2[:y] - delta1[:y]) * ratio,
+        }
+      end
+    end
+  end
+end