fontisan 0.2.11 → 0.2.12

data/lib/fontisan/type1/ttf_to_type1_converter.rb

@@ -0,0 +1,327 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Type1
+    # TTF to Type 1 CharString Converter
+    #
+    # [`TTFToType1Converter`](lib/fontisan/type1/ttf_to_type1_converter.rb) converts
+    # TrueType glyphs to Type 1 CharStrings.
+    #
+    # The conversion involves:
+    # - Converting quadratic curves (TrueType) to cubic curves (Type 1)
+    # - Scaling coordinates if needed
+    # - Generating Type 1 CharString commands
+    #
+    # @example Convert TTF font to Type 1 CharStrings
+    #   scaler = Fontisan::Type1::UPMScaler.type1_standard(font)
+    #   converter = Fontisan::Type1::TTFToType1Converter.new(font, scaler, encoding)
+    #   charstrings = converter.convert
+    #
+    # @see https://www.adobe.com/devnet/font/pdfs/5178.Type1.pdf
+    class TTFToType1Converter
+      # Type 1 CharString command codes
+      HSTEM = 1
+      VSTEM = 3
+      VMOVETO = 4
+      RLINETO = 5
+      HLINETO = 6
+      VLINETO = 7
+      RRCURVETO = 8
+      CLOSEPATH = 9
+      CALLSUBR = 10
+      RETURN = 11
+      ESCAPE = 12
+      HSBW = 13
+      ENDCHAR = 14
+      RMOVETO = 21
+      HMOVETO = 22
+      VHCURVETO = 30
+      HVCURVETO = 31
+
+      # Convert TTF font to Type 1 CharStrings
+      #
+      # @param font [Fontisan::Font] Source TTF font
+      # @param scaler [UPMScaler] UPM scaler
+      # @param encoding [Class] Encoding class
+      # @return [Hash<Integer, String>] Glyph ID to CharString mapping
+      def self.convert(font, scaler, encoding)
+        new(font, scaler, encoding).convert
+      end
+
+      def initialize(font, scaler, encoding)
+        @font = font
+        @scaler = scaler
+        @encoding = encoding
+        @charstrings = {}
+      end
+
+      # Convert all glyphs to CharStrings
+      #
+      # @return [Hash<Integer, String>] Glyph ID to CharString mapping
+      def convert
+        glyf_table = @font.table(Constants::GLYF_TAG)
+        return {} unless glyf_table
+
+        loca_table = @font.table(Constants::LOCA_TAG)
+        head_table = @font.table(Constants::HEAD_TAG)
+
+        maxp = @font.table(Constants::MAXP_TAG)
+        num_glyphs = maxp&.num_glyphs || 0
+
+        num_glyphs.times do |gid|
+          @charstrings[gid] =
+            convert_glyph(glyf_table, loca_table, head_table, gid)
+        end
+
+        @charstrings
+      end
+
+      private
+
+      # Convert a single glyph to CharString
+      #
+      # @param glyf_table [Tables::Glyf] TTF glyf table
+      # @param loca_table [Tables::Loca] TTF loca table
+      # @param head_table [Tables::Head] TTF head table
+      # @param gid [Integer] Glyph ID
+      # @return [String] Type 1 CharString data
+      def convert_glyph(glyf_table, loca_table, head_table, gid)
+        glyph = glyf_table.glyph_for(gid, loca_table, head_table)
+
+        # Handle empty glyph
+        return empty_charstring if glyph.nil?
+
+        # Handle compound glyphs
+        if glyph.compound?
+          return convert_composite_glyph(glyph, glyf_table)
+        end
+
+        # Convert simple glyph
+        convert_simple_glyph(glyph)
+      end
+
+      # Convert a simple glyph to CharString
+      #
+      # @param glyph [Object] TTF simple glyph
+      # @return [String] Type 1 CharString data
+      def convert_simple_glyph(glyph)
+        commands = []
+        points = extract_points(glyph)
+
+        return empty_charstring if points.empty?
+
+        # Start with hsbw (horizontal side bearing and width)
+        lsb = @scaler.scale(glyph.left_side_bearing || 0)
+        width = @scaler.scale(glyph.advance_width || 500)
+        commands << [HSBW, lsb, width]
+
+        # Convert contours to Type 1 commands
+        contour_commands = convert_contours(points)
+        commands.concat(contour_commands)
+
+        # End character
+        commands << [ENDCHAR]
+
+        # Encode to CharString format
+        encode_charstring(commands)
+      end
+
+      # Extract points from a simple glyph
+      #
+      # @param glyph [Object] TTF simple glyph
+      # @return [Array<Hash>] Array of points with on_curve flag
+      def extract_points(glyph)
+        return [] unless glyph.respond_to?(:points)
+
+        points = []
+        glyph.points.each do |point|
+          points << {
+            x: @scaler.scale(point.x),
+            y: @scaler.scale(point.y),
+            on_curve: point.on_curve?,
+          }
+        end
+
+        points
+      end
+
+      # Convert contours to Type 1 commands
+      #
+      # @param points [Array<Hash>] Array of points
+      # @return [Array<Array<Integer>>] Array of command arrays
+      def convert_contours(points)
+        commands = []
+        return commands if points.empty?
+
+        # Start at first point
+        start_point = points[0]
+        current_point = { x: start_point[:x], y: start_point[:y] }
+
+        # Process remaining points in runs
+        i = 1
+        while i < points.length
+          point = points[i]
+
+          if point[:on_curve]
+            # On-curve point - draw line or curve from previous
+            if i.positive? && !points[i - 1][:on_curve]
+              # Previous was off-curve, this is end of quadratic curve
+              prev_point = points[i - 1]
+              curve_commands = convert_quadratic_to_cubic(
+                current_point,
+                prev_point,
+                point,
+              )
+              commands.concat(curve_commands)
+            else
+              # Line to this point
+              dx = point[:x] - current_point[:x]
+              dy = point[:y] - current_point[:y]
+              commands << [RLINETO, dx, dy]
+            end
+            current_point = { x: point[:x], y: point[:y] }
+          elsif i + 1 < points.length && !points[i + 1][:on_curve]
+            # Off-curve control point
+            # Check if next point is also off-curve (implicit on-curve midpoint)
+            next_point = points[i + 1]
+            implicit_on = {
+              x: ((point[:x] + next_point[:x]).to_f / 2).round,
+              y: ((point[:y] + next_point[:y]).to_f / 2).round,
+            }
+
+            curve_commands = convert_quadratic_to_cubic(
+              current_point,
+              point,
+              implicit_on,
+            )
+            commands.concat(curve_commands)
+            current_point = implicit_on
+            # Both are off-curve, implicit on-curve at midpoint
+            # If next point is on-curve, we'll handle it in next iteration
+          end
+
+          i += 1
+        end
+
+        # Close contour if needed (implicit close path for Type 1)
+        # Type 1 implicitly closes paths, so we don't need explicit close
+
+        commands
+      end
+
+      # Convert quadratic Bézier curve to cubic Bézier curve
+      #
+      # TrueType uses quadratic curves with one control point:
+      # P0 (on) -> P1 (off) -> P2 (on)
+      #
+      # Type 1 uses cubic curves with two control points:
+      # P0 (on) -> C1 (off) -> C2 (off) -> P2 (on)
+      #
+      # Conversion formula:
+      # C1 = P0 + (2/3)(P1 - P0) = (1/3)P0 + (2/3)P1
+      # C2 = P2 + (2/3)(P1 - P2) = (2/3)P1 + (1/3)P2
+      #
+      # @param p0 [Hash] Start point {x, y}
+      # @param p1 [Hash] Control point {x, y}
+      # @param p2 [Hash] End point {x, y}
+      # @return [Array<Array<Integer>>] Array of command arrays
+      def convert_quadratic_to_cubic(p0, p1, p2)
+        # Calculate cubic control points
+        c1_x = p0[:x] + ((2 * (p1[:x] - p0[:x])).to_f / 3).round
+        c1_y = p0[:y] + ((2 * (p1[:y] - p0[:y])).to_f / 3).round
+
+        c2_x = p2[:x] + ((2 * (p1[:x] - p2[:x])).to_f / 3).round
+        c2_y = p2[:y] + ((2 * (p1[:y] - p2[:y])).to_f / 3).round
+
+        # Calculate deltas
+        dc1x = c1_x - p0[:x]
+        dc1y = c1_y - p0[:y]
+        dc2x = c2_x - c1_x
+        dc2y = c2_y - c1_y
+        dx = p2[:x] - c2_x
+        dy = p2[:y] - c2_y
+
+        [
+          [RRCURVETO, dc1x, dc1y, dc2x, dc2y, dx, dy],
+        ]
+      end
+
+      # Convert a composite glyph to CharString
+      #
+      # @param glyph [Object] TTF composite glyph
+      # @param glyf_table [Object] TTF glyf table
+      # @return [String] Type 1 CharString data
+      def convert_composite_glyph(_glyph, _glyf_table)
+        # For composite glyphs, we need to decompose or use seac
+        # TODO: Implement proper composite handling with seac or decomposition
+
+        # For now, return a simple placeholder
+        # In a full implementation, we would:
+        # 1. Extract component glyphs
+        # 2. Transform and merge their outlines
+        # 3. Generate combined CharString
+
+        empty_charstring
+      end
+
+      # Encode commands to Type 1 CharString binary format
+      #
+      # @param commands [Array<Array<Integer>>] Array of command arrays
+      # @return [String] Binary CharString data
+      def encode_charstring(commands)
+        bytes = []
+
+        commands.each do |cmd|
+          cmd.each do |value|
+            if value.is_a?(Integer)
+              bytes.concat(encode_number(value))
+            end
+          end
+        end
+
+        bytes.pack("C*")
+      end
+
+      # Encode a number for CharString
+      #
+      # Type 1 CharStrings use a variable-length encoding for integers
+      #
+      # @param value [Integer] Number to encode
+      # @return [Array<Integer>] Array of bytes
+      def encode_number(value)
+        if value >= -107 && value <= 107
+          # Single byte encoding: value + 139
+          [value + 139]
+        elsif value >= 108 && value <= 1131
+          # Two byte encoding
+          byte1 = ((value - 108) >> 8) + 247
+          byte2 = (value - 108) & 0xFF
+          [byte1, byte2]
+        elsif value >= -1131 && value <= -108
+          # Two byte encoding for negative
+          byte1 = ((-value - 108) >> 8) + 251
+          byte2 = (-value - 108) & 0xFF
+          [byte1, byte2]
+        elsif value >= -32768 && value <= 32767
+          # Three byte encoding (16-bit signed)
+          [255, value & 0xFF, (value >> 8) & 0xFF]
+        else
+          # Four byte encoding (32-bit)
+          bytes = []
+          4.times do |i|
+            bytes << ((value >> (8 * i)) & 0xFF)
+          end
+          [255] + bytes
+        end
+      end
+
+      # Generate empty CharString
+      #
+      # @return [String] Empty CharString data
+      def empty_charstring
+        # hsbw with width 0, then endchar
+        [0, 500, ENDCHAR].pack("C*")
+      end
+    end
+  end
+end

data/lib/fontisan/type1/upm_scaler.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Type1
+    # UPM (Units Per Em) Scaler
+    #
+    # [`UPMScaler`](lib/fontisan/type1/upm_scaler.rb) handles scaling of font metrics
+    # from the source font's UPM to a target UPM.
+    #
+    # Traditional Type 1 fonts use 1000 UPM, while modern TTF fonts typically use
+    # 2048 or other values. This scaler converts metrics appropriately.
+    #
+    # @example Scale to Type 1 standard
+    #   scaler = Fontisan::Type1::UPMScaler.type1_standard(font)
+    #   scaled_width = scaler.scale(1024)  # => 500 for 2048 UPM font
+    #
+    # @example Keep native UPM
+    #   scaler = Fontisan::Type1::UPMScaler.native(font)
+    #   scaled_width = scaler.scale(1024)  # => 1024 (no scaling)
+    class UPMScaler
+      # @return [Integer] Source font's units per em
+      attr_reader :source_upm
+
+      # @return [Integer] Target units per em
+      attr_reader :target_upm
+
+      # @return [Rational] Scale factor (target / source)
+      attr_reader :scale_factor
+
+      # Initialize a new UPM scaler
+      #
+      # @param font [Fontisan::Font] Source font
+      # @param target_upm [Integer] Target UPM (default: 1000 for Type 1)
+      def initialize(font, target_upm: 1000)
+        @font = font
+        @source_upm = font.units_per_em
+        @target_upm = target_upm
+        @scale_factor = Rational(target_upm, source_upm)
+      end
+
+      # Scale a single value
+      #
+      # @param value [Integer, Float] Value to scale
+      # @return [Integer] Scaled value (rounded)
+      def scale(value)
+        return 0 if value.nil? || value.zero?
+
+        (value * scale_factor).round
+      end
+
+      # Scale an array of values
+      #
+      # @param values [Array<Integer, Float>] Values to scale
+      # @return [Array<Integer>] Scaled values
+      def scale_array(values)
+        values.map { |v| scale(v) }
+      end
+
+      # Scale a coordinate pair [x, y]
+      #
+      # @param value [Array<Integer, Float>] Coordinate pair
+      # @return [Array<Integer>] Scaled coordinates
+      def scale_pair(value)
+        [scale(value[0]), scale(value[1])]
+      end
+
+      # Scale a bounding box [llx, lly, urx, ury]
+      #
+      # @param bbox [Array<Integer, Float>] Bounding box
+      # @return [Array<Integer>] Scaled bounding box
+      def scale_bbox(bbox)
+        return nil if bbox.nil?
+
+        bbox.map { |v| scale(v) }
+      end
+
+      # Scale a character width
+      #
+      # @param width [Integer, Float] Character width
+      # @return [Integer] Scaled width
+      def scale_width(width)
+        scale(width)
+      end
+
+      # Check if scaling is needed
+      #
+      # @return [Boolean] True if source and target UPM differ
+      def scaling_needed?
+        @source_upm != @target_upm
+      end
+
+      # Create scaler with native UPM (no scaling)
+      #
+      # @param font [Fontisan::Font] Source font
+      # @return [UPMScaler] Scaler with native UPM
+      def self.native(font)
+        new(font, target_upm: font.units_per_em)
+      end
+
+      # Create scaler with Type 1 standard UPM (1000)
+      #
+      # @param font [Fontisan::Font] Source font
+      # @return [UPMScaler] Scaler with 1000 UPM
+      def self.type1_standard(font)
+        new(font, target_upm: 1000)
+      end
+
+      # Create scaler with custom UPM
+      #
+      # @param font [Fontisan::Font] Source font
+      # @param upm [Integer] Target UPM
+      # @return [UPMScaler] Scaler with custom UPM
+      def self.custom(font, upm:)
+        new(font, target_upm: upm)
+      end
+    end
+  end
+end

data/lib/fontisan/type1.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Fontisan
+  # Adobe Type 1 Font support
+  #
+  # [`Type1`](lib/fontisan/type1.rb) provides parsing and conversion
+  # capabilities for Adobe Type 1 fonts in PFB (Printer Font Binary)
+  # and PFA (Printer Font ASCII) formats.
+  #
+  # Type 1 fonts were the standard for digital typography in the 1980s-1990s
+  # and are still encountered in legacy systems and design workflows.
+  #
+  # Key features:
+  # - PFB and PFA format parsing
+  # - eexec decryption for encrypted font portions
+  # - CharString decryption with lenIV handling
+  # - Font dictionary parsing (FontInfo, Private dict)
+  # - Conversion from TTF/OTF to Type 1 formats
+  # - UPM scaling for Type 1 compatibility (1000 UPM)
+  # - Multiple encoding support (AdobeStandard, ISOLatin1, Unicode)
+  #
+  # @example Generate Type 1 formats from TTF
+  #   font = Fontisan::FontLoader.load("font.ttf")
+  #   result = Fontisan::Type1::Generator.generate(font)
+  #   result[:afm]   # => AFM file content
+  #   result[:pfm]   # => PFM file content
+  #   result[:pfb]   # => PFB file content
+  #   result[:inf]   # => INF file content
+  #
+  # @example Generate with specific options
+  #   options = Fontisan::Type1::ConversionOptions.windows_type1
+  #   result = Fontisan::Type1::Generator.generate(font, options)
+  #
+  # @see https://www.adobe.com/devnet/font/pdfs/Type1.pdf
+  module Type1
+  end
+end
+
+# Parsers
+require_relative "type1/pfb_parser"
+require_relative "type1/pfa_parser"
+
+# Core components
+require_relative "type1/decryptor"
+require_relative "type1/font_dictionary"
+require_relative "type1/private_dict"
+require_relative "type1/charstrings"
+require_relative "type1/charstring_converter"
+
+# Infrastructure
+require_relative "type1/upm_scaler"
+require_relative "type1/agl"
+require_relative "type1/encodings"
+require_relative "type1/conversion_options"
+
+# TTF to Type 1 conversion
+require_relative "type1/ttf_to_type1_converter"
+
+# Metrics parsers
+require_relative "type1/afm_parser"
+require_relative "type1/pfm_parser"
+
+# Metrics generators
+require_relative "type1/afm_generator"
+require_relative "type1/pfm_generator"
+
+# Type 1 font generators
+require_relative "type1/pfa_generator"
+require_relative "type1/pfb_generator"
+require_relative "type1/inf_generator"
+
+# Unified generator interface
+require_relative "type1/generator"