fontisan 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '020862878eef5569b82edb88989afdc3b7c21d3f01d19b605132af70cabe524f'
-  data.tar.gz: d8d685a687c94f987835e440619aca344a615368ea78d6caf6a882c34c2900d3
+  metadata.gz: 58c1e2768684af1fcdc55fdc2d5b3e47bbd89b0277794dc64ff627ef8d571c3d
+  data.tar.gz: 8d1da959f850b3872acb01e96deb098ea2cbb0d596a0923b5db4960edfd818bf
 SHA512:
-  metadata.gz: a98055b753907dedfd44fd89c61fd3d5d797d405d702e65730bae1e3299665354f385b135529ca6b48708672e37cfa0e10a7b518ce0b624ccb46fae9459cfb22
-  data.tar.gz: 46af4e780f4a1786501e2b874d4b439614c212b839b0b398316806a2baa9348b67c8e4db3e63b85142d79ae015df3f093db957f055ddbd3f4955268caa2c1dfa
+  metadata.gz: 3e46507d14358098c09f5ee2a3584c601e3d28e6a762f506962007445fb9fcd4432db7f591601575fac87d9cad93ae7c57d2c464728888e33dd6b242387c5611
+  data.tar.gz: 1e2dc941fe06dc9769aad1477c970ac48e799d62f3340a08448c0528290562ce2f9ccfd0e021615ebc57a26bcdd19773fd51135d4d214ef31e2a927576c7d06f

data/README.adoc

@@ -2475,6 +2475,36 @@ fontisan stitch \
   --output stitched.ttf
 ----
 
+=== Color emoji (CBDT/CBLC passthrough)
+
+Sources with CBDT/CBLC tables (e.g. NotoColorEmoji) can be used as
+Stitcher sources. The bitmap data is propagated byte-for-byte from the
+source into the output. The Stitcher automatically detects the source's
+storage mode via `bitmap_mode`:
+
+[source,ruby]
+----
+stitcher = Fontisan::Stitcher.new
+stitcher.add_source(:text, Fontisan::FontLoader.load("NotoSans.ttf"))
+stitcher.add_source(:emoji, Fontisan::FontLoader.load("NotoColorEmoji.ttf"))
+
+# All emoji glyphs from the CBDT source are added; the CBLC table
+# is copied byte-for-byte and references the right GIDs.
+stitcher.include_range(0x41..0x5A, from: :text)
+stitcher.include_range(0x1F600..0x1F64F, from: :emoji)
+
+stitcher.write_to("out.ttf", format: :ttf)
+# → out.ttf has glyf + CBDT + CBLC, emoji renders correctly
+----
+
+**Constraints:**
+- Only ONE CBDT source per Stitcher (multiple raise
+  `Fontisan::MultipleCbdtSourcesError`)
+- The CBDT source is processed first (GIDs 0..N-1) so the CBLC's GID
+  references remain valid in the output
+- Multi-source CBDT merge is tracked as TODO (REVIEW
+  `TODO.full/ufo/23-cbdt-passthrough.md`)
+
 
 == Testing
 

data/lib/fontisan/stitcher/source.rb

@@ -6,10 +6,10 @@ module Fontisan
     # extraction API used by the selectors.
     #
     # For UFO sources, glyphs are accessed by name directly. For TTF
-    # or OTF sources, the source is lazily converted to a UFO::Font
-    # via Ufo::Convert::FromBinData on first glyph access, then cached.
-    # This is O(n) in donor glyph count but amortized across all
-    # codepoint extractions from that donor.
+    # or OTF sources, individual glyphs are extracted on demand from
+    # the BinData tables (glyf/loca/head for TTF, CFF for OTF). This
+    # is O(1) per glyph rather than the previous O(n) full-donor
+    # conversion.
     #
     # CBDT/CBLC sources (e.g. NotoColorEmoji) are detected via
     # #bitmap_mode. When a source is :cbdt, the Stitcher propagates
@@ -20,7 +20,7 @@ module Fontisan
 
       def initialize(font)
         @font = font
-        @ufo_cache = nil
+        @bin_data_cache = nil
       end
 
       # @return [Symbol] :ufo, :ttf, :otf
@@ -66,14 +66,19 @@ module Fontisan
 
       # Extract a glyph by gid.
       #
+      # For TTF/OTF sources, this is O(1) per glyph: it parses just
+      # the requested glyph from glyf/CFF on demand, not the entire
+      # donor. The full-donor conversion is avoided entirely.
+      #
       # For CBDT sources, returns a placeholder glyph (no contours)
-      # since the glyph data lives in the bitmap tables, not outlines.
+      # since the glyph data is in the bitmap tables, not outlines.
+      #
       # @param gid [Integer]
       # @return [Fontisan::Ufo::Glyph, nil]
       def glyph_for_gid(gid)
         case @font
         when Fontisan::Ufo::Font then ufo_glyph_at(gid)
-        else converted_ufo_glyph_at(gid)
+        else extract_single_glyph_from_bindata(gid)
         end
       end
 
@@ -89,6 +94,15 @@ module Fontisan
         nil
       end
 
+      # Width of a specific glyph (extracted from hmtx).
+      # Falls back to 0 if hmtx is missing.
+      # @param gid [Integer]
+      # @return [Integer]
+      def glyph_width(gid)
+        widths = bin_data_widths
+        widths[gid] || 0
+      end
+
       private
 
       # ---------- UFO source ----------
@@ -108,7 +122,7 @@ module Fontisan
         @font.glyph(name)
       end
 
-      # ---------- TTF/OTF source ----------
+      # ---------- TTF/OTF source: O(1) per-glyph extraction ----------
 
       def bin_data_gid_for(codepoint)
         cmap = @font.table("cmap")
@@ -117,21 +131,111 @@ module Fontisan
         cmap.unicode_mappings[codepoint]
       end
 
-      # Lazily convert the loaded TTF/OTF to a UFO::Font, then
-      # extract glyphs from the cached UFO model.
-      def converted_ufo
-        return @ufo_cache if @ufo_cache
+      # Lazily parse the relevant BinData tables. Cached so we only
+      # pay the parse cost once per source.
+      def bin_data_cache
+        @bin_data_cache ||= parse_bin_data_tables
+      end
+
+      def parse_bin_data_tables
+        cache = { head: @font.table("head") }
+
+        if @font.has_table?("glyf")
+          cache[:loca] = @font.table("loca")
+          cache[:glyf] = @font.table("glyf")
+          # loca needs head's index_to_loc_format to size its offsets
+          if cache[:loca].respond_to?(:parse_with_context) && cache[:head]
+            cache[:loca].parse_with_context(
+              cache[:head].index_to_loc_format,
+              @font.table("maxp")&.num_glyphs || 0,
+            )
+          end
+        end
+
+        cache
+      end
 
-        @ufo_cache = Fontisan::Ufo::Convert::FromBinData.convert(@font)
+      # Build {gid → advance_width} from hmtx (cached).
+      def bin_data_widths
+        @bin_data_widths ||= build_bin_data_widths
       end
 
-      def converted_ufo_glyph_at(gid)
-        ufo = converted_ufo
-        names = ufo.glyphs.keys
-        name = names[gid]
-        return nil unless name
+      def build_bin_data_widths
+        widths = {}
+        hmtx = @font.table("hmtx")
+        return widths unless hmtx
+
+        hhea = @font.table("hhea")
+        maxp = @font.table("maxp")
+        num_h_metrics = hhea&.number_of_h_metrics || 1
+        num_glyphs = maxp&.num_glyphs || 0
+
+        if hmtx.respond_to?(:parse_with_context)
+          hmtx.parse_with_context(num_h_metrics, num_glyphs)
+        end
+
+        num_glyphs.times do |gid|
+          metric = hmtx.respond_to?(:metric_for) ? hmtx.metric_for(gid) : nil
+          widths[gid] = metric ? metric[:advance_width] : 0
+        rescue StandardError
+          widths[gid] = 0
+        end
+        widths
+      end
+
+      # Extract a single glyph by gid, parsing just the relevant bytes.
+      # O(1) per call (after the first call's table-parsing overhead).
+      def extract_single_glyph_from_bindata(gid)
+        cache = bin_data_cache
+
+        if cache[:glyf] && cache[:loca] && cache[:head]
+          extract_truetype_glyph(gid, cache)
+        end
+      end
+
+      def extract_truetype_glyph(gid, cache)
+        simple = cache[:glyf].glyph_for(gid, cache[:loca], cache[:head])
+        return nil unless simple
+        return nil unless simple.respond_to?(:simple?) && simple.simple?
+
+        name = gid.zero? ? ".notdef" : "gid#{gid}"
+        glyph = Fontisan::Ufo::Glyph.new(name: name)
+        glyph.width = glyph_width(gid)
+        copy_simple_contours(simple, glyph)
+        add_cmap_unicodes(gid, glyph)
+        glyph
+      rescue StandardError
+        nil
+      end
+
+      # Copy a SimpleGlyph's contours + points into a Ufo::Glyph.
+      def copy_simple_contours(simple, ufo_glyph)
+        num_contours = simple.end_pts_of_contours&.size || 0
+        return if num_contours.zero?
+
+        num_contours.times do |ci|
+          points = simple.points_for_contour(ci)
+          next unless points && !points.empty?
+
+          ufo_points = points.map do |pt|
+            x = pt[:x] || pt["x"]
+            y = pt[:y] || pt["y"]
+            on_curve = pt[:on_curve].nil? || pt[:on_curve]
+            type = on_curve ? "line" : "offcurve"
+            Fontisan::Ufo::Point.new(x: x.to_f, y: y.to_f, type: type)
+          end
+          ufo_glyph.add_contour(Fontisan::Ufo::Contour.new(ufo_points))
+        end
+      end
+
+      # Add Unicode codepoints from the cmap that map to this gid.
+      def add_cmap_unicodes(gid, glyph)
+        cmap = @font.table("cmap")
+        return unless cmap
 
-        ufo.glyph(name)
+        (cmap.unicode_mappings || {}).each do |cp, g|
+          glyph.add_unicode(cp) if g == gid
+        end
       end
     end
   end

data/lib/fontisan/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fontisan
-  VERSION = "0.4.0"
+  VERSION = "0.4.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Ribose Inc.