fontisan 0.2.10 → 0.2.12

data/lib/fontisan/converters/outline_extraction.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "../outline_extractor"
+require_relative "../tables/cff/charstring_builder"
+require_relative "../tables/glyf/glyph_builder"
+require_relative "../tables/glyf/compound_glyph_resolver"
+
+module Fontisan
+  module Converters
+    # Extracts all glyph outlines from a font for conversion purposes
+    #
+    # Unlike [`OutlineExtractor`](../outline_extractor.rb) which extracts
+    # single glyphs, this module extracts ALL glyphs from a font for
+    # bulk conversion operations.
+    #
+    # @see OutlineExtractor for single glyph extraction
+    module OutlineExtraction
+      # Extract all outlines from TrueType font
+      #
+      # @param font [TrueTypeFont] Source font
+      # @return [Array<Outline>] Array of outline objects
+      def extract_ttf_outlines(font)
+        # Get required tables
+        head = font.table("head")
+        maxp = font.table("maxp")
+        loca = font.table("loca")
+        glyf = font.table("glyf")
+
+        # Parse loca with context
+        loca.parse_with_context(head.index_to_loc_format, maxp.num_glyphs)
+
+        # Create resolver for compound glyphs
+        resolver = Tables::CompoundGlyphResolver.new(glyf, loca, head)
+
+        # Extract all glyphs
+        outlines = []
+        maxp.num_glyphs.times do |glyph_id|
+          glyph = glyf.glyph_for(glyph_id, loca, head)
+
+          outlines << if glyph.nil? || glyph.empty?
+                        # Empty glyph - create empty outline
+                        Models::Outline.new(
+                          glyph_id: glyph_id,
+                          commands: [],
+                          bbox: { x_min: 0, y_min: 0, x_max: 0, y_max: 0 },
+                        )
+                      elsif glyph.simple?
+                        # Convert simple glyph to outline
+                        Models::Outline.from_truetype(glyph, glyph_id)
+                      else
+                        # Compound glyph - resolve to simple outline
+                        resolver.resolve(glyph)
+                      end
+        end
+
+        outlines
+      end
+
+      # Extract all outlines from CFF font
+      #
+      # @param font [OpenTypeFont] Source font
+      # @return [Array<Outline>] Array of outline objects
+      def extract_cff_outlines(font)
+        # Get CFF table
+        cff = font.table("CFF ")
+        raise Fontisan::Error, "CFF table not found" unless cff
+
+        # Get number of glyphs
+        num_glyphs = cff.glyph_count
+
+        # Extract all glyphs
+        outlines = []
+        num_glyphs.times do |glyph_id|
+          charstring = cff.charstring_for_glyph(glyph_id)
+
+          outlines << if charstring.nil? || charstring.path.empty?
+                        # Empty glyph
+                        Models::Outline.new(
+                          glyph_id: glyph_id,
+                          commands: [],
+                          bbox: { x_min: 0, y_min: 0, x_max: 0, y_max: 0 },
+                        )
+                      else
+                        # Convert CharString to outline
+                        Models::Outline.from_cff(charstring, glyph_id)
+                      end
+        end
+
+        outlines
+      end
+    end
+  end
+end

data/lib/fontisan/converters/outline_optimizer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative "../optimizers/pattern_analyzer"
+require_relative "../optimizers/subroutine_optimizer"
+require_relative "../optimizers/subroutine_builder"
+require_relative "../optimizers/charstring_rewriter"
+
+module Fontisan
+  module Converters
+    # Optimizes CFF CharStrings using subroutine extraction
+    #
+    # This module analyzes CharStrings for repeated patterns, extracts
+    # them as subroutines, and rewrites the CharStrings to call the
+    # subroutines instead of repeating the code.
+    #
+    # The optimization process:
+    # 1. Analyze patterns across all CharStrings
+    # 2. Select optimal set of patterns for subroutines
+    # 3. Optimize subroutine ordering
+    # 4. Build subroutines from selected patterns
+    # 5. Rewrite CharStrings to call subroutines
+    module OutlineOptimizer
+      # Optimize CharStrings using subroutine extraction
+      #
+      # @param charstrings [Array<String>] Original CharString bytes
+      # @return [Array<Array<String>, Array<String>>] [optimized_charstrings, local_subrs]
+      def optimize_charstrings(charstrings)
+        # Convert to hash format expected by PatternAnalyzer
+        charstrings_hash = {}
+        charstrings.each_with_index do |cs, index|
+          charstrings_hash[index] = cs
+        end
+
+        # Analyze patterns
+        analyzer = Optimizers::PatternAnalyzer.new(
+          min_length: 10,
+          stack_aware: true,
+        )
+        patterns = analyzer.analyze(charstrings_hash)
+
+        # Return original if no patterns found
+        return [charstrings, []] if patterns.empty?
+
+        # Optimize selection
+        optimizer = Optimizers::SubroutineOptimizer.new(patterns,
+                                                        max_subrs: 65_535)
+        selected_patterns = optimizer.optimize_selection
+
+        # Optimize ordering
+        selected_patterns = optimizer.optimize_ordering(selected_patterns)
+
+        # Return original if no patterns selected
+        return [charstrings, []] if selected_patterns.empty?
+
+        # Build subroutines
+        builder = Optimizers::SubroutineBuilder.new(selected_patterns,
+                                                    type: :local)
+        local_subrs = builder.build
+
+        # Build subroutine map
+        subroutine_map = {}
+        selected_patterns.each_with_index do |pattern, index|
+          subroutine_map[pattern.bytes] = index
+        end
+
+        # Rewrite CharStrings
+        rewriter = Optimizers::CharstringRewriter.new(subroutine_map, builder)
+        optimized_charstrings = charstrings.map.with_index do |charstring, glyph_id|
+          # Find patterns for this glyph
+          glyph_patterns = selected_patterns.select do |p|
+            p.glyphs.include?(glyph_id)
+          end
+
+          if glyph_patterns.empty?
+            charstring
+          else
+            rewriter.rewrite(charstring, glyph_patterns, glyph_id)
+          end
+        end
+
+        [optimized_charstrings, local_subrs]
+      rescue StandardError => e
+        # If optimization fails for any reason, return original CharStrings
+        warn "Optimization warning: #{e.message}"
+        [charstrings, []]
+      end
+    end
+  end
+end