fontisan 0.4.45 → 0.4.47

data/lib/fontisan/variation/instance_generator.rb

@@ -54,29 +54,12 @@ module Fontisan
 
       # Generate static font instance
       #
-      # Applies variation deltas and returns static font tables.
+      # Applies gvar/HVAR deltas at the coordinates to the outlines and
+      # metrics and drops the variation tables. TrueType (gvar) fonts only.
       #
       # @return [Hash<String, String>] Map of table tags to binary data
       def generate
-        # Start with base font tables
-        tables = @font.table_data.dup
-
-        # Determine variation type
-        if has_variation_table?("gvar")
-          # TrueType outlines with gvar
-          apply_gvar_deltas(tables)
-        elsif has_variation_table?("CFF2")
-          # PostScript outlines with CFF2 blend
-          apply_cff2_blend(tables)
-        end
-
-        # Apply metrics variations if present
-        apply_metrics_deltas(tables) if @context.has_metrics_variations?
-
-        # Remove variation-specific tables to create static font
-        remove_variation_tables(tables)
-
-        tables
+        Instancing::TrueTypeInstancer.new(@font.table_data, @coordinates).call
       end
 
       # Generate a named instance
@@ -96,135 +79,6 @@ module Fontisan
         generate
       end
 
-      # Apply gvar deltas to TrueType outlines
-      #
-      # @param tables [Hash<String, String>] Font tables
-      def apply_gvar_deltas(_tables)
-        gvar = variation_table("gvar")
-        glyf = @font.table("glyf")
-        return unless gvar && glyf
-
-        # Get glyph count
-        maxp = @font.table("maxp")
-        glyph_count = maxp ? maxp.num_glyphs : gvar.glyph_count
-
-        # Process each glyph
-        glyph_count.times do |glyph_id|
-          apply_glyph_deltas(glyph_id, gvar, glyf)
-        end
-
-        # Rebuild glyf and loca tables with adjusted outlines
-        # This is a placeholder - full implementation would reconstruct tables
-      end
-
-      # Apply deltas to a specific glyph
-      #
-      # @param glyph_id [Integer] Glyph ID
-      # @param gvar [Gvar] Gvar table
-      # @param glyf [Glyf] Glyf table
-      def apply_glyph_deltas(glyph_id, gvar, _glyf)
-        # Get tuple variations for this glyph
-        tuple_data = gvar.glyph_tuple_variations(glyph_id)
-        return unless tuple_data
-
-        # Match tuples to current coordinates
-        matches = @context.region_matcher.match_tuples(
-          coordinates: @coordinates,
-          tuples: tuple_data[:tuples],
-        )
-
-        nil if matches.empty?
-
-        # Get base glyph outline
-        # Apply matched deltas with their scalars
-        # This is a placeholder - full implementation would:
-        # 1. Parse glyph outline points
-        # 2. Parse delta data for each tuple
-        # 3. Apply: new_point = base_point + Σ(delta * scalar)
-        # 4. Update glyph outline
-      end
-
-      # Apply CFF2 blend operators
-      #
-      # @param tables [Hash<String, String>] Font tables
-      def apply_cff2_blend(_tables)
-        cff2 = variation_table("CFF2")
-        return unless cff2
-
-        # Set number of axes for CFF2
-        cff2.num_axes = @context.axis_count
-
-        # Process each glyph's CharString
-        glyph_count = cff2.glyph_count
-        return if glyph_count.zero?
-
-        # Calculate variation scalars once
-        calculate_variation_scalars
-
-        # Apply blend to each glyph
-        # This is a placeholder - full implementation would:
-        # 1. Parse CharString with blend operators
-        # 2. Apply scalars to blend operands
-        # 3. Rebuild CharStrings without blend operators
-        # 4. Update CFF2 table
-      end
-
-      # Calculate variation scalars for current coordinates
-      #
-      # @return [Array<Float>] Scalars for each axis
-      def calculate_variation_scalars
-        @context.axes.map do |axis|
-          coord = @coordinates[axis.axis_tag] || axis.default_value
-          @context.interpolator.normalize_coordinate(coord, axis.axis_tag)
-        end
-      end
-
-      # Apply metrics variations
-      #
-      # @param tables [Hash<String, String>] Font tables
-      def apply_metrics_deltas(tables)
-        # Apply HVAR (horizontal metrics)
-        apply_hvar_deltas(tables) if has_variation_table?("HVAR")
-
-        # Apply VVAR (vertical metrics)
-        apply_vvar_deltas(tables) if has_variation_table?("VVAR")
-
-        # Apply MVAR (font-wide metrics)
-        apply_mvar_deltas(tables) if has_variation_table?("MVAR")
-      end
-
-      # Apply HVAR deltas to horizontal metrics
-      #
-      # @param tables [Hash<String, String>] Font tables
-      def apply_hvar_deltas(_tables)
-        adjuster = MetricsAdjuster.new(@font, @context.interpolator)
-        adjuster.apply_hvar_deltas(@coordinates)
-      end
-
-      # Apply VVAR deltas to vertical metrics
-      #
-      # @param tables [Hash<String, String>] Font tables
-      def apply_vvar_deltas(_tables)
-        adjuster = MetricsAdjuster.new(@font, @context.interpolator)
-        adjuster.apply_vvar_deltas(@coordinates)
-      end
-
-      # Apply MVAR deltas to font-wide metrics
-      #
-      # @param tables [Hash<String, String>] Font tables
-      def apply_mvar_deltas(_tables)
-        adjuster = MetricsAdjuster.new(@font, @context.interpolator)
-        adjuster.apply_mvar_deltas(@coordinates)
-      end
-
-      # Remove variation tables from static font
-      #
-      # @param tables [Hash<String, String>] Font tables
-      def remove_variation_tables(tables)
-        variation_tables = %w[fvar gvar cvar HVAR VVAR MVAR avar STAT]
-        variation_tables.each { |tag| tables.delete(tag) }
-      end
-
       # Interpolate a single value
       #
       # @param base_value [Numeric] Base value

data/lib/fontisan/variation/instancing/axis_space.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Variation
+    module Instancing
+      # The design space of a variable font: fvar axes plus avar mapping.
+      # Validates user coordinates and normalizes them to -1..1.
+      class AxisSpace
+        Axis = Struct.new(:tag, :minimum, :default, :maximum, :name_id)
+
+        attr_reader :axes
+
+        # @param fvar [String] raw fvar table
+        # @param avar [String, nil] raw avar table
+        def initialize(fvar, avar = nil)
+          @axes = parse_fvar(fvar)
+          @segments = avar ? parse_avar(avar) : {}
+        end
+
+        def tags
+          @axes.map(&:tag)
+        end
+
+        # Named instances: [{ name_id:, coordinates: { tag => value } }]
+        def self.named_instances(fvar)
+          offset, axis_count, axis_size, inst_count, inst_size = header(fvar)
+          base = offset + (axis_count * axis_size)
+          Array.new(inst_count) do |i|
+            pos = base + (i * inst_size)
+            name_id = fvar[pos, 2].unpack1("n")
+            coords = Array.new(axis_count) do |a|
+              fixed(fvar, pos + 4 + (a * 4))
+            end
+            { name_id: name_id, values: coords }
+          end
+        end
+
+        def self.header(fvar)
+          offset, _res, axis_count, axis_size, inst_count, inst_size =
+            fvar[4, 12].unpack("nnnnnn")
+          [offset, axis_count, axis_size, inst_count, inst_size]
+        end
+
+        def self.fixed(data, pos)
+          data[pos, 4].unpack1("l>") / 65536.0
+        end
+
+        # @param requested [Hash{String=>Numeric}] user coordinates
+        # @return [Hash{String=>Float}] full user location (defaults filled)
+        # @raise [InvalidCoordinatesError, InvalidAxisError]
+        def validate(requested)
+          known = tags
+          requested.each_key do |tag|
+            next if known.include?(tag.to_s)
+
+            raise InvalidAxisError.new(
+              axis: tag.to_s,
+              reason: "font has axes #{known.join(', ')}",
+            )
+          end
+          @axes.to_h do |axis|
+            value = requested.transform_keys(&:to_s)[axis.tag]
+            value = axis.default if value.nil?
+            value = Float(value)
+            unless value.between?(axis.minimum, axis.maximum)
+              raise InvalidCoordinatesError.new(
+                axis: axis.tag, value: value, range: [axis.minimum, axis.maximum],
+              )
+            end
+            [axis.tag, value]
+          end
+        end
+
+        # @return [Array<Float>] normalized (avar-mapped) coordinates, fvar order
+        def normalize(location)
+          @axes.map do |axis|
+            value = location.fetch(axis.tag)
+            n = if value < axis.default
+                  (value - axis.default) / (axis.default - axis.minimum)
+                elsif value > axis.default
+                  (value - axis.default) / (axis.maximum - axis.default)
+                else
+                  0.0
+                end
+            map_segment(axis.tag, n.clamp(-1.0, 1.0))
+          end
+        end
+
+        private
+
+        def parse_fvar(fvar)
+          offset, axis_count, axis_size, = self.class.header(fvar)
+          Array.new(axis_count) do |i|
+            pos = offset + (i * axis_size)
+            Axis.new(fvar[pos, 4], self.class.fixed(fvar, pos + 4),
+                     self.class.fixed(fvar, pos + 8),
+                     self.class.fixed(fvar, pos + 12),
+                     fvar[pos + 18, 2].unpack1("n"))
+          end
+        end
+
+        # avar v1: per axis, array of [from, to] pairs (F2Dot14)
+        def parse_avar(avar)
+          axis_count = avar[6, 2].unpack1("n")
+          pos = 8
+          segments = {}
+          axis_count.times do |i|
+            count = avar[pos, 2].unpack1("n")
+            pos += 2
+            pairs = Array.new(count) do |j|
+              from, to = avar[pos + (j * 4), 4].unpack("s>s>")
+              [from / 16384.0, to / 16384.0]
+            end
+            pos += count * 4
+            segments[@axes[i].tag] = pairs if @axes[i]
+          end
+          segments
+        end
+
+        def map_segment(tag, value)
+          pairs = @segments[tag]
+          return value if pairs.nil? || pairs.empty?
+
+          exact = pairs.find { |from, _| from == value }
+          return exact[1] if exact
+
+          idx = pairs.index { |from, _| from > value }
+          return value if idx.nil? || idx.zero?
+
+          (f0, t0), (f1, t1) = pairs[idx - 1], pairs[idx]
+          t0 + ((t1 - t0) * (value - f0) / (f1 - f0))
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/variation/instancing/glyph_outline.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Variation
+    module Instancing
+      # A parsed glyf entry that can be moved by deltas and re-serialized.
+      # Points are the simple-glyph points, or for composites one point per
+      # component (its x/y offset), matching gvar's point numbering.
+      class GlyphOutline
+        ON_CURVE = 0x01
+        X_SHORT = 0x02
+        Y_SHORT = 0x04
+        REPEAT = 0x08
+        X_SAME = 0x10
+        Y_SAME = 0x20
+
+        ARGS_ARE_WORDS = 0x0001
+        ARGS_ARE_XY = 0x0002
+        HAVE_SCALE = 0x0008
+        MORE_COMPONENTS = 0x0020
+        HAVE_XY_SCALE = 0x0040
+        HAVE_TWO_BY_TWO = 0x0080
+
+        Component = Struct.new(:flags, :gid, :arg1, :arg2, :transform)
+
+        attr_reader :end_pts, :on_curve, :overlap, :instructions, :components,
+                    :trailer, :header_contours
+
+        def self.parse(bytes)
+          new(bytes)
+        end
+
+        def initialize(bytes)
+          @header_contours = 0
+          @end_pts = []
+          @on_curve = []
+          @components = []
+          @points = []
+          return if bytes.nil? || bytes.empty?
+
+          @header_contours = bytes[0, 2].unpack1("s>")
+          if @header_contours >= 0
+            parse_simple(bytes)
+          else
+            parse_composite(bytes)
+          end
+        end
+
+        def empty?
+          @header_contours.zero? && @points.empty?
+        end
+
+        def composite?
+          @header_contours.negative?
+        end
+
+        # @return [Array<Array<Float>>] [[x, y], ...]
+        def points
+          @points.map(&:dup)
+        end
+
+        def point_count
+          @points.size
+        end
+
+        def bounds_of(points)
+          return nil if points.empty?
+
+          xs = points.map(&:first)
+          ys = points.map(&:last)
+          [xs.min, ys.min, xs.max, ys.max]
+        end
+
+        # Serialize with the given (already rounded) points. +bbox+ is the
+        # [xMin, yMin, xMax, yMax] to record in the header.
+        def serialize(new_points, bbox)
+          return "".b if empty?
+
+          composite? ? serialize_composite(new_points, bbox) : serialize_simple(new_points, bbox)
+        end
+
+        private
+
+        def parse_simple(bytes)
+          n = @header_contours
+          @end_pts = bytes[10, n * 2].unpack("n*")
+          pos = 10 + (n * 2)
+          ilen = bytes[pos, 2].unpack1("n")
+          @instructions = bytes[pos + 2, ilen]
+          pos += 2 + ilen
+          count = n.zero? ? 0 : @end_pts.last + 1
+          flags = []
+          while flags.size < count
+            f = bytes.getbyte(pos)
+            pos += 1
+            flags << f
+            if f.anybits?(REPEAT)
+              bytes.getbyte(pos).times { flags << f }
+              pos += 1
+            end
+          end
+          xs = read_coords(bytes, pos, flags, X_SHORT, X_SAME)
+          pos = xs.pop
+          ys = read_coords(bytes, pos, flags, Y_SHORT, Y_SAME)
+          ys.pop
+          @on_curve = flags.map { |f| f.anybits?(ON_CURVE) }
+          @overlap = flags.first&.anybits?(0x40) || false
+          @points = xs.zip(ys)
+        end
+
+        def read_coords(bytes, pos, flags, short, same)
+          val = 0
+          out = flags.map do |f|
+            if f.anybits?(short)
+              d = bytes.getbyte(pos)
+              pos += 1
+              val += f.anybits?(same) ? d : -d
+            elsif !f.anybits?(same)
+              val += bytes[pos, 2].unpack1("s>")
+              pos += 2
+            end
+            val
+          end
+          out << pos
+        end
+
+        def parse_composite(bytes)
+          pos = 10
+          loop do
+            flags, gid = bytes[pos, 4].unpack("nn")
+            pos += 4
+            if flags.anybits?(ARGS_ARE_WORDS)
+              fmt = flags.anybits?(ARGS_ARE_XY) ? "s>s>" : "nn"
+              a1, a2 = bytes[pos, 4].unpack(fmt)
+              pos += 4
+            else
+              fmt = flags.anybits?(ARGS_ARE_XY) ? "cc" : "CC"
+              a1, a2 = bytes[pos, 2].unpack(fmt)
+              pos += 2
+            end
+            tlen = if flags.anybits?(HAVE_SCALE) then 2
+                   elsif flags.anybits?(HAVE_XY_SCALE) then 4
+                   elsif flags.anybits?(HAVE_TWO_BY_TWO) then 8
+                   else 0
+                   end
+            @components << Component.new(flags, gid, a1, a2, bytes[pos, tlen])
+            pos += tlen
+            break unless flags.anybits?(MORE_COMPONENTS)
+          end
+          @trailer = bytes[pos..] || "".b
+          @points = @components.map do |c|
+            c.flags.anybits?(ARGS_ARE_XY) ? [c.arg1.to_f, c.arg2.to_f] : [0.0, 0.0]
+          end
+        end
+
+        def serialize_simple(pts, bbox)
+          out = [@header_contours, *bbox].pack("s>5")
+          out << @end_pts.pack("n*")
+          out << [@instructions.bytesize].pack("n") << @instructions
+          flags = +"".b
+          xs = +"".b
+          ys = +"".b
+          px = py = 0
+          pts.each_with_index do |(x, y), i|
+            f = @on_curve[i] ? ON_CURVE : 0
+            f |= 0x40 if i.zero? && @overlap
+            dx = x - px
+            dy = y - py
+            if dx.zero? then f |= X_SAME
+            else xs << [dx].pack("s>")
+            end
+            if dy.zero? then f |= Y_SAME
+            else ys << [dy].pack("s>")
+            end
+            flags << f.chr
+            px = x
+            py = y
+          end
+          out << flags << xs << ys
+        end
+
+        def serialize_composite(pts, bbox)
+          out = [@header_contours, *bbox].pack("s>5")
+          @components.each_with_index do |c, i|
+            flags = c.flags
+            a1 = c.arg1
+            a2 = c.arg2
+            if flags.anybits?(ARGS_ARE_XY)
+              a1, a2 = pts[i]
+              flags |= ARGS_ARE_WORDS
+              out << [flags, c.gid, a1, a2].pack("nns>s>")
+            elsif flags.anybits?(ARGS_ARE_WORDS)
+              out << [flags, c.gid, a1, a2].pack("nnnn")
+            else
+              out << [flags, c.gid, a1, a2].pack("nnCC")
+            end
+            out << c.transform
+          end
+          out << @trailer
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/variation/instancing/gvar_reader.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Variation
+    module Instancing
+      # Reads per-glyph tuple variations from a gvar table.
+      class GvarReader
+        SHARED_POINTS = 0x8000
+        EMBEDDED_PEAK = 0x8000
+        INTERMEDIATE = 0x4000
+        PRIVATE_POINTS = 0x2000
+        INDEX_MASK = 0x0FFF
+
+        # points == nil means "every point of the glyph, phantoms included"
+        Tuple = Struct.new(:peak, :start, :end, :points, :dx, :dy) do
+          def intermediate?
+            !start.nil?
+          end
+        end
+
+        def initialize(data)
+          @data = data
+          _major, _minor, @axis_count, shared_count, shared_offset,
+            @glyph_count, flags, @array_offset = data[0, 20].unpack("nnnnNnnN")
+          @long_offsets = flags.anybits?(1)
+          @shared = Array.new(shared_count) do |i|
+            read_tuple(shared_offset + (i * @axis_count * 2))
+          end
+        end
+
+        # @param gid [Integer]
+        # @param point_count [Integer] glyph points including 4 phantoms
+        # @return [Array<Tuple>]
+        def tuples_for(gid, point_count)
+          return [] if gid >= @glyph_count
+
+          first, last = glyph_range(gid)
+          return [] if last <= first
+
+          parse_glyph(@data[@array_offset + first, last - first], point_count)
+        end
+
+        private
+
+        def read_tuple(pos)
+          @data[pos, @axis_count * 2].unpack("s>*").map { |v| v / 16384.0 }
+        end
+
+        def glyph_range(gid)
+          if @long_offsets
+            @data[20 + (gid * 4), 8].unpack("NN")
+          else
+            @data[20 + (gid * 2), 4].unpack("nn").map { |v| v * 2 }
+          end
+        end
+
+        def parse_glyph(glyph_data, point_count)
+          count_field, data_offset = glyph_data[0, 4].unpack("nn")
+          count = count_field & INDEX_MASK
+          headers = []
+          pos = 4
+          count.times do
+            size, index = glyph_data[pos, 4].unpack("nn")
+            pos += 4
+            peak = start = finish = nil
+            if index.anybits?(EMBEDDED_PEAK)
+              peak = glyph_data[pos, @axis_count * 2].unpack("s>*").map { |v| v / 16384.0 }
+              pos += @axis_count * 2
+            else
+              peak = @shared.fetch(index & INDEX_MASK)
+            end
+            if index.anybits?(INTERMEDIATE)
+              start = glyph_data[pos, @axis_count * 2].unpack("s>*").map { |v| v / 16384.0 }
+              finish = glyph_data[pos + (@axis_count * 2), @axis_count * 2]
+                .unpack("s>*").map { |v| v / 16384.0 }
+              pos += @axis_count * 4
+            end
+            headers << [size, index, peak, start, finish]
+          end
+
+          dpos = data_offset
+          shared_points = nil
+          if count_field.anybits?(SHARED_POINTS)
+            shared_points, dpos = read_points(glyph_data, dpos)
+          end
+          headers.map do |size, index, peak, start, finish|
+            tuple_end = dpos + size
+            points = shared_points
+            points, dpos = read_points(glyph_data, dpos) if index.anybits?(PRIVATE_POINTS)
+            n = points ? points.size : point_count
+            dx, dpos = read_deltas(glyph_data, dpos, n)
+            dy, = read_deltas(glyph_data, dpos, n)
+            dpos = tuple_end
+            Tuple.new(peak, start, finish, points, dx, dy)
+          end
+        end
+
+        def read_points(data, pos)
+          count = data.getbyte(pos)
+          pos += 1
+          if count.anybits?(0x80)
+            count = ((count & 0x7F) << 8) | data.getbyte(pos)
+            pos += 1
+          end
+          return [nil, pos] if count.zero?
+
+          points = []
+          last = 0
+          while points.size < count
+            ctl = data.getbyte(pos)
+            pos += 1
+            run = (ctl & 0x7F) + 1
+            if ctl.anybits?(0x80)
+              vals = data[pos, run * 2].unpack("n*")
+              pos += run * 2
+            else
+              vals = data[pos, run].unpack("C*")
+              pos += run
+            end
+            vals.each { |v| points << (last += v) }
+          end
+          [points, pos]
+        end
+
+        def read_deltas(data, pos, count)
+          out = []
+          while out.size < count
+            ctl = data.getbyte(pos)
+            pos += 1
+            run = (ctl & 0x3F) + 1
+            if ctl.anybits?(0x80)
+              out.concat(Array.new(run, 0))
+            elsif ctl.anybits?(0x40)
+              out.concat(data[pos, run * 2].unpack("s>*"))
+              pos += run * 2
+            else
+              out.concat(data[pos, run].unpack("c*"))
+              pos += run
+            end
+          end
+          [out.first(count), pos]
+        end
+      end
+    end
+  end
+end