emfsvg 0.1.3 → 0.1.4

data/lib/emfsvg/translation/handlers/elliptical_arc.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Translation
+    module Handlers
+      # Converts SVG endpoint-form elliptical arcs into cubic Beziers.
+      class EllipticalArc
+        def self.to_cubics(start, args, absolute:)
+          finish = endpoint(start, args, absolute)
+          return [] if start == finish
+
+          rx, ry, rotation, large_arc, sweep = args
+          return [[:line, [finish]]] if rx.zero? || ry.zero?
+
+          geometry = ellipse_geometry(start, finish, rx.abs, ry.abs, rotation, large_arc, sweep)
+          cubic_segments(geometry, finish)
+        end
+
+        def self.endpoint(start, args, absolute)
+          x, y = args.last(2)
+          absolute ? [x, y] : [start[0] + x, start[1] + y]
+        end
+        private_class_method :endpoint
+
+        def self.ellipse_geometry(start, finish, rx, ry, rotation, large_arc, sweep)
+          phi = rotation * Math::PI / 180.0
+          cos_phi = Math.cos(phi)
+          sin_phi = Math.sin(phi)
+          dx = (start[0] - finish[0]) / 2.0
+          dy = (start[1] - finish[1]) / 2.0
+          x1 = (cos_phi * dx) + (sin_phi * dy)
+          y1 = (-sin_phi * dx) + (cos_phi * dy)
+          lambda = ((x1**2) / (rx**2)) + ((y1**2) / (ry**2))
+          if lambda > 1
+            factor = Math.sqrt(lambda)
+            rx *= factor
+            ry *= factor
+          end
+
+          cx1, cy1 = center_offset(rx, ry, x1, y1, large_arc, sweep)
+          center = center_point(start, finish, cx1, cy1, cos_phi, sin_phi)
+          theta, delta = arc_angles(rx, ry, x1, y1, cx1, cy1, large_arc, sweep)
+          { center: center, rx: rx, ry: ry, cos_phi: cos_phi, sin_phi: sin_phi, theta: theta, delta: delta }
+        end
+        private_class_method :ellipse_geometry
+
+        def self.center_offset(rx, ry, x1, y1, large_arc, sweep)
+          numerator = [((rx**2) * (ry**2)) - ((rx**2) * (y1**2)) - ((ry**2) * (x1**2)), 0].max
+          denominator = ((rx**2) * (y1**2)) + ((ry**2) * (x1**2))
+          factor = denominator.zero? ? 0.0 : Math.sqrt(numerator / denominator)
+          factor *= -1 if large_arc == sweep
+          [factor * rx * y1 / ry, -factor * ry * x1 / rx]
+        end
+        private_class_method :center_offset
+
+        def self.center_point(start, finish, cx1, cy1, cos_phi, sin_phi)
+          [
+            (cos_phi * cx1) - (sin_phi * cy1) + ((start[0] + finish[0]) / 2.0),
+            (sin_phi * cx1) + (cos_phi * cy1) + ((start[1] + finish[1]) / 2.0)
+          ]
+        end
+        private_class_method :center_point
+
+        def self.arc_angles(rx, ry, x1, y1, cx1, cy1, large_arc, sweep)
+          ux = (x1 - cx1) / rx
+          uy = (y1 - cy1) / ry
+          vx = (-x1 - cx1) / rx
+          vy = (-y1 - cy1) / ry
+          theta = Math.atan2(uy, ux)
+          delta = Math.atan2((ux * vy) - (uy * vx), (ux * vx) + (uy * vy))
+          delta -= 2 * Math::PI if sweep.zero? && delta.positive?
+          delta += 2 * Math::PI if sweep != 0 && delta.negative?
+          delta += (sweep.zero? ? -2 : 2) * Math::PI if large_arc != 0 && delta.abs < Math::PI
+          delta += (sweep.zero? ? 2 : -2) * Math::PI if large_arc.zero? && delta.abs > Math::PI
+          [theta, delta]
+        end
+        private_class_method :arc_angles
+
+        def self.cubic_segments(geometry, finish)
+          center = geometry.fetch(:center)
+          rx = geometry.fetch(:rx)
+          ry = geometry.fetch(:ry)
+          cos_phi = geometry.fetch(:cos_phi)
+          sin_phi = geometry.fetch(:sin_phi)
+          theta = geometry.fetch(:theta)
+          delta = geometry.fetch(:delta)
+          count = (delta.abs / (Math::PI / 2)).ceil
+          step = delta / count
+          Array.new(count) do |index|
+            a = theta + (index * step)
+            b = a + step
+            alpha = (4.0 / 3.0) * Math.tan((b - a) / 4.0)
+            point_a, derivative_a = point_and_derivative(center, rx, ry, cos_phi, sin_phi, a)
+            point_b, derivative_b = point_and_derivative(center, rx, ry, cos_phi, sin_phi, b)
+            point_b = finish if index == count - 1
+            [
+              :cubic,
+              [
+                [point_a[0] + (alpha * derivative_a[0]), point_a[1] + (alpha * derivative_a[1])],
+                [point_b[0] - (alpha * derivative_b[0]), point_b[1] - (alpha * derivative_b[1])],
+                point_b
+              ]
+            ]
+          end
+        end
+        private_class_method :cubic_segments
+
+        def self.point_and_derivative(center, rx, ry, cos_phi, sin_phi, angle)
+          cos_angle = Math.cos(angle)
+          sin_angle = Math.sin(angle)
+          point = [
+            center[0] + (rx * cos_phi * cos_angle) - (ry * sin_phi * sin_angle),
+            center[1] + (rx * sin_phi * cos_angle) + (ry * cos_phi * sin_angle)
+          ]
+          derivative = [
+            (-rx * cos_phi * sin_angle) - (ry * sin_phi * cos_angle),
+            (-rx * sin_phi * sin_angle) + (ry * cos_phi * cos_angle)
+          ]
+          [point, derivative]
+        end
+        private_class_method :point_and_derivative
+      end
+    end
+  end
+end

data/lib/emfsvg/translation/handlers/group_handler.rb

@@ -22,9 +22,16 @@ module Emfsvg
           # record, regardless of whether the matrix is identity. Skipping
           # it would drop the group wrapper from the round-tripped SVG.
           emit_world_transform(element.transform_matrix, context)
+          context.begin_selected_clip(element)
           element.children.each { |child| context.dispatch(child) }
           context.emit(Emf::Emr::Binary::Records::RestoreDc,
                        i_type: RESTOREDC, saved_dc: -1)
+          context.finish_selected_clip(element)
+          context.finish_carried_clip(element)
+          # RestoreDC changes native state; the next SetWorldTransform closes
+          # the SVG group. Emit here to retain the source definition's group
+          # while letting the following sibling inherit its native clip.
+          context.carry_clip_from(element)
         end
 
         private

data/lib/emfsvg/translation/handlers/image_handler.rb

@@ -7,10 +7,10 @@ module Emfsvg
   module Translation
     module Handlers
       # Translate <image href="data:image/png;base64,..."/> into
-      # EMR_STRETCHDIBITS with an embedded BI_RGB DIB.
+      # EMR_STRETCHDIBITS with an embedded DIB.
       #
       # v1 limitations:
-      #   * PNG data URIs only. JPEG and other formats fall through silently.
+      #   * PNG and JPEG data URIs only. Other formats fall through silently.
       #   * No aspect-ratio handling (uses width/height verbatim).
       class ImageHandler
         include SharedGdi
@@ -20,6 +20,8 @@ module Emfsvg
         # 6*4 (int32 src/dest dims) + 6*4 (off/cb/i_usage/dw_rop/cx/cy)
         # = 80 bytes.
         STRETCHDIBITS_FIXED_SIZE = 80
+        JPEG_TERMINAL_MARKERS = [0xDA, 0xD9].freeze
+        JPEG_NON_FRAME_MARKERS = [0xC4, 0xC8, 0xCC].freeze
 
         def self.call(element, context)
           new.translate(element, context)
@@ -27,24 +29,67 @@ module Emfsvg
 
         def translate(element, context)
           return unless element.data_uri?
-          return unless element.mime_type == "image/png"
+          return unless %w[image/png image/jpeg image/jpg].include?(element.mime_type)
 
           dib = build_dib(element)
           return unless dib
 
-          emit_stretch_dibits(element, dib, context)
+          with_gdi_state(element, context) do
+            emit_stretch_dibits(element, dib, context)
+          end
         end
 
         private
 
         def build_dib(element)
+          return build_jpeg_dib(element.decoded_bytes) if %w[image/jpeg image/jpg].include?(element.mime_type)
+
           png = element.decoded_bytes
           return nil unless png
 
           decoded = PngDecoder.decode(png)
           return nil unless decoded
 
-          DibEncoder.encode(decoded.width, decoded.height, decoded.pixels)
+          # BI_PNG keeps the original compression and color format. Expanding
+          # to BGRA and re-encoding would change otherwise untouched payloads.
+          [40, decoded.width, decoded.height, 1, 0, 5, png.bytesize, 0, 0, 0, 0].pack("Vl<l<vvVVVVVV") + png
+        end
+
+        # JPEG frame dimensions describe the embedded bitmap, independently of
+        # the SVG destination size. Preserve its compressed bytes with BI_JPEG.
+        def build_jpeg_dib(bytes)
+          dimensions = jpeg_dimensions(bytes)
+          return unless dimensions
+
+          width, height = dimensions
+          [40, width, height, 1, 0, 4, bytes.bytesize, 0, 0, 0, 0].pack("Vl<l<vvVVVVVV") + bytes
+        end
+
+        def jpeg_dimensions(bytes)
+          return unless bytes&.start_with?("\xFF\xD8".b)
+
+          offset = 2
+          while offset + 4 <= bytes.bytesize
+            return unless bytes.getbyte(offset) == 0xFF
+
+            offset += 1 while bytes.getbyte(offset) == 0xFF
+            marker = bytes.getbyte(offset)
+            return if JPEG_TERMINAL_MARKERS.include?(marker)
+
+            length = bytes.byteslice(offset + 1, 2)&.unpack1("n")
+            return unless length && length >= 2 && offset + 1 + length <= bytes.bytesize
+
+            if (0xC0..0xCF).cover?(marker) && !JPEG_NON_FRAME_MARKERS.include?(marker)
+              return unless length >= 8
+
+              height, width = bytes.byteslice(offset + 4, 4).unpack("nn")
+              return [width, height] if width.positive? && height.positive?
+
+              return
+            end
+            offset += 1 + length
+          end
+          nil
         end
 
         def emit_stretch_dibits(element, dib, context)
@@ -53,9 +98,9 @@ module Emfsvg
           off_bmi = STRETCHDIBITS_FIXED_SIZE
           off_bits = off_bmi + bmi_size
 
-          bounds = context.rect_l(element.x, element.y,
-                                  element.x + element.width,
-                                  element.y + element.height)
+          bounds = context.rect_attrs(element.x, element.y,
+                                      element.x + element.width,
+                                      element.y + element.height)
           x_dest = context.scaler.to_int(element.x)
           y_dest = context.scaler.to_int(element.y)
           cx_dest = context.scaler.to_int(element.width)

data/lib/emfsvg/translation/handlers/line_handler.rb

@@ -18,10 +18,10 @@ module Emfsvg
           with_gdi_state(element, context) do
             context.emit(Emf::Emr::Binary::Records::MoveToEx,
                          i_type: MOVETOEX,
-                         origin: context.point_l(element.x1, element.y1))
+                         origin: context.point_attrs(element.x1, element.y1))
             context.emit(Emf::Emr::Binary::Records::LineTo,
                          i_type: LINETO,
-                         origin: context.point_l(element.x2, element.y2))
+                         origin: context.point_attrs(element.x2, element.y2))
           end
         end
       end

data/lib/emfsvg/translation/handlers/mapped_arc.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Translation
+    module Handlers
+      # Recover mapped near-semicircles only when integer centers reproduce both endpoints.
+      class MappedArc < MappedCircularArc
+        def self.from_commands(commands, scaler:)
+          return unless scaler.scaled? && commands.map(&:letter) == %w[M M A]
+
+          prefix, start, args = commands.map(&:args)
+          rx, ry, rotation, large, sweep, x, y = args
+          return unless rotation.zero? && large == sweep && [0, 1].include?(sweep)
+
+          finish = [x, y]
+          midpoint = start.zip(finish).map { |a, b| ((a + b) / 2).round }
+          [-1, 0, 1].repeated_permutation(2) do |offsets|
+            center = midpoint.zip(offsets).map { |value, offset| value + offset }
+            radius = Math.hypot(start[0] - center[0], start[1] - center[1]).round
+            next unless radius.positive?
+
+            origin = mapping_origin(rx, ry, radius)
+            next unless origin
+
+            radials = [start, finish].map { |point| recover_radial(point, center, radius, origin, scaler.factor) }
+            next if radials.any?(&:nil?)
+
+            return new(prefix, finish, center, radius, radials, sweep, :arc, origin: origin)
+          end
+          nil
+        end
+
+        def self.mapping_origin(rx, ry, radius)
+          origin = [rx - radius, ry - radius]
+          origin if origin.all? { |value| value == value.round && Scaler::Fixed::INT32_RANGE.cover?(value) }
+        end
+        private_class_method :mapping_origin
+      end
+    end
+  end
+end

data/lib/emfsvg/translation/handlers/mapped_circular_arc.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Translation
+    module Handlers
+      # Invert C circle mapping while preserving endpoint rounding and local state.
+      class MappedCircularArc < CircularArc
+        def self.recover_radial(point, center, radius, origin, factor)
+          logical_center = center.zip(origin).map { |value, offset| ((value - offset) * factor).round }
+          logical_radius = (radius * factor).round
+          # Four-decimal endpoints describe rounding intervals, not exact radial directions.
+          # Try bounded directions inside those intervals while retaining int32 safety.
+          [1, 10, 100].product([-0.000049, 0, 0.000049].repeated_permutation(2).to_a) do |multiple, offsets|
+            radial = point.zip(center, offsets).map do |value, base, offset|
+              ((value - base + offset) * factor * multiple).round
+            end
+            unless radial.zip(logical_center).all? { |delta, base| Scaler::Fixed::INT32_RANGE.cover?(delta + base) }
+              next
+            end
+
+            length = Math.hypot(*radial)
+            next if length.zero?
+
+            projected = logical_center.zip(radial, origin).map do |base, delta, offset|
+              ((base + ((logical_radius * delta) / length)) / factor) + offset
+            end
+            return radial.map { |value| value.to_f / factor } if point.zip(projected).all? do |expected, actual|
+              format("%.4f", expected) == format("%.4f", actual)
+            end
+          end
+          nil
+        end
+        private_class_method :recover_radial
+
+        def initialize(*args, origin:)
+          super(*args)
+          @origin = origin
+        end
+
+        def safe_for?(context)
+          points = [@prefix, @finish, *@radials.map { |radial| radial.zip(@center).map { |delta, base| delta + base } },
+                    [@center[0] - @radius, @center[1] - @radius],
+                    [@center[0] + @radius, @center[1] + @radius]]
+          points.all? do |point|
+            point.zip(@origin).all? { |value, offset| !context.scaler.unsafe?(value - offset) }
+          end
+        end
+
+        def emit(context)
+          context.with_local_origin(@origin) { super }
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/translation/handlers/mapped_pie.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Translation
+    module Handlers
+      # C's Pie formatter maps radii as points, adding the viewport origin.
+      # Recover that origin only when an integer circle reproduces every byte.
+      class MappedPie < MappedCircularArc
+        def self.from_commands(commands, scaler:)
+          return unless scaler.scaled? && commands.map(&:letter) == %w[M M A L Z]
+
+          prefix, start, args, center = commands.first(4).map(&:args)
+          rx, ry, rotation, large, sweep, x, y = args
+          return unless rotation.zero? && large == sweep && [0, 1].include?(sweep)
+
+          distance = Math.hypot(start[0] - center[0], start[1] - center[1])
+          origin = [rx - distance, ry - distance].map(&:round)
+          radius = rx - origin[0]
+          return unless radius.positive? && (radius - (ry - origin[1])).abs < 0.00001
+          return unless origin.all? { |value| Scaler::Fixed::INT32_RANGE.cover?(value) }
+
+          radials = [start, [x, y]].map { |point| recover_radial(point, center, radius, origin, scaler.factor) }
+          return if radials.any?(&:nil?)
+
+          new(prefix, start, center, radius, radials, sweep, :pie, origin: origin)
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/translation/handlers/path_flattener.rb

@@ -3,62 +3,74 @@
 module Emfsvg
   module Translation
     module Handlers
-      # Flatten a list of Svg::PathData::Command into a single shape
-      # (Polyline/Polygon/PolyBezier) suitable for one EMF record.
-      #
-      # v1 limitations:
-      #   * All commands converted to absolute (relative resolved).
-      #   * Arc/quadratic commands approximated as lines (TODO).
-      #   * Multiple subpaths merged into one (TODO: PolyPolygon).
+      # Resolve supported commands to absolute points without joining figures.
       class PathFlattener
-        Result = Struct.new(:shape_kind, :points, :bounds, keyword_init: true)
+        Result = Struct.new(:shape_kind, :points, :bounds, :segments, keyword_init: true)
 
-        def self.flatten(commands)
-          new.flatten(commands)
+        def self.flatten(commands, preserve_initial_line: false)
+          new.flatten(commands, preserve_initial_line: preserve_initial_line)
         end
 
-        def flatten(commands)
+        def flatten(commands, preserve_initial_line: false)
           pen = PenState.new
-          closed = false
-          has_curve = false
-          points = []
-
+          subpaths = []
+          segments = []
           commands.each do |command|
-            case command.letter.upcase
-            when "M"
-              pen.move_to(command, absolute: command.absolute?)
-              points << pen.current.dup
-            when "L"
-              pen.line_to(command, absolute: command.absolute?)
-              points << pen.current.dup
-            when "H"
-              pen.h_line_to(command, absolute: command.absolute?)
-              points << pen.current.dup
-            when "V"
-              pen.v_line_to(command, absolute: command.absolute?)
-              points << pen.current.dup
-            when "C"
-              has_curve = true
-              pen.cubic_to(command, absolute: command.absolute?)
-              points.concat(pen.flush_curve_points)
-            when "Z"
-              closed = true
+            letter = command.letter.upcase
+            if letter == "M" && segments.any?
+              subpaths << build_result(segments)
+              segments = []
             end
-          end
+            if segments.empty? && letter != "M" && !(preserve_initial_line && subpaths.empty? && letter == "L")
+              segments << ["M", [pen.current.dup]]
+            end
+            if letter == "A"
+              segments.concat(resolve_arc(pen, command))
+              next
+            end
+            points = resolve_command(pen, command)
+            segments << [letter, points] if points
+            next unless letter == "Z"
 
-          Result.new(
-            shape_kind: shape_kind(closed, has_curve),
-            points: points,
-            bounds: bounds_for(points)
-          )
+            pen.close_to(segments.first.last.first)
+            subpaths << build_result(segments)
+            segments = []
+          end
+          subpaths << build_result(segments) unless segments.empty?
+          subpaths
         end
 
         private
 
-        def shape_kind(closed, has_curve)
-          return :polybezier if has_curve
+        def resolve_arc(pen, command)
+          arc_segments = EllipticalArc.to_cubics(pen.current, command.args, absolute: command.absolute?)
+          pen.set_current(command.args.last(2), absolute: command.absolute?)
+          arc_segments.map { |kind, points| [kind == :line ? "L" : "C", points] }
+        end
+
+        def resolve_command(pen, command)
+          case command.letter.upcase
+          when "M", "L" then pen.line_to(command, absolute: command.absolute?)
+          when "H" then pen.h_line_to(command, absolute: command.absolute?)
+          when "V" then pen.v_line_to(command, absolute: command.absolute?)
+          when "C"
+            pen.cubic_to(command, absolute: command.absolute?)
+            return pen.flush_curve_points
+          when "Z" then return []
+          else return nil
+          end
+          [pen.current.dup]
+        end
 
-          closed ? :polygon : :polyline
+        def build_result(segments)
+          points = segments.flat_map(&:last)
+          letters = segments.map(&:first)
+          kind = if letters.include?("C")
+                   (letters - %w[M C]).empty? ? :polybezier : :path
+                 else
+                   letters.last == "Z" ? :polygon : :polyline
+                 end
+          Result.new(shape_kind: kind, points: points, bounds: bounds_for(points), segments: segments)
         end
 
         # Bounds holds raw decimal values (NOT pre-scaled to int). The
@@ -69,9 +81,15 @@ module Emfsvg
         def bounds_for(points)
           return Bounds.new(left: 0, top: 0, right: 0, bottom: 0) if points.empty?
 
-          xs = points.map { |x, _| x }
-          ys = points.map { |_, y| y }
-          Bounds.new(left: xs.min, top: ys.min, right: xs.max, bottom: ys.max)
+          left = right = points[0][0]
+          top = bottom = points[0][1]
+          points.each do |x, y|
+            left = x if x < left
+            right = x if x > right
+            top = y if y < top
+            bottom = y if y > bottom
+          end
+          Bounds.new(left: left, top: top, right: right, bottom: bottom)
         end
       end
 
@@ -85,9 +103,12 @@ module Emfsvg
           @pending_curve_points = []
         end
 
-        def move_to(command, absolute:)
-          x, y = command.args
-          @current = absolute ? [x, y] : [@current[0] + x, @current[1] + y]
+        def close_to(point)
+          @current = point.dup
+        end
+
+        def set_current(point, absolute:)
+          @current = absolute ? point.dup : @current.zip(point).map { |origin, delta| origin + delta }
         end
 
         def line_to(command, absolute:)