emfsvg 0.1.2 → 0.1.4

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Translation
+    module Handlers
+      # Recover only circles whose integer radial points reproduce the source.
+      # Native Arc/Chord/Pie do not update the current point; SVG closure does.
+      class CircularArc
+        include Emf::Emr::Binary::TypeCodes
+
+        def self.from_commands(commands, kind: :arc)
+          return unless supported_commands?(commands, kind)
+
+          prefix, start, args = commands.first(3).map(&:args)
+          radius, ry, rotation, large, sweep, x, y = args
+          return unless radius.positive? && radius == ry && radius == radius.round
+          return unless rotation.zero? && large == sweep && [0, 1].include?(sweep)
+
+          finish = [x, y]
+          center = circle_center(start, finish, radius)
+          return unless valid_center?(center, commands, kind)
+
+          radials = [start, finish].map { |point| point.zip(center).map { |value, origin| (value - origin).round } }
+          return unless [start, finish].zip(radials).all? do |point, radial|
+            projects_to?(point, radial, center, radius)
+          end
+
+          new(prefix, kind == :arc ? finish : start, center, radius, radials, sweep, kind)
+        end
+
+        def self.valid_center?(center, commands, kind)
+          center && (kind != :pie || commands[3].args == center)
+        end
+        private_class_method :valid_center?
+
+        def self.supported_commands?(commands, kind)
+          letters = { arc: %w[M M A], chord: %w[M M A Z], pie: %w[M M A L Z] }
+          letters.key?(kind) && commands.map(&:letter) == letters[kind]
+        end
+        private_class_method :supported_commands?
+
+        def self.circle_center(start, finish, radius)
+          x, y = finish
+          dx, dy = finish.zip(start).map { |a, b| a - b }
+          distance = Math.hypot(dx, dy)
+          return unless distance.positive? && distance <= 2 * radius
+
+          height = Math.sqrt([(radius**2) - ((distance**2) / 4), 0].max)
+          center = [((start[0] + x) / 2) + ((dy * height) / distance),
+                    ((start[1] + y) / 2) - ((dx * height) / distance)]
+          center.map(&:round) if center.all? { |value| (value - value.round).abs < 0.001 }
+        end
+        private_class_method :circle_center
+
+        def self.projects_to?(point, radial, center, radius)
+          length = Math.hypot(*radial)
+          length.positive? && point.zip(center, radial).all? do |value, origin, delta|
+            format("%.4f", value) == format("%.4f", origin + ((radius * delta) / length))
+          end
+        end
+        private_class_method :projects_to?
+
+        def initialize(prefix, finish, center, radius, radials, sweep, kind)
+          @prefix = prefix
+          @finish = finish
+          @center = center
+          @radius = radius
+          @radials = radials
+          @sweep = sweep
+          @kind = kind
+        end
+
+        def safe_for?(context)
+          x, y = @center
+          [x - @radius, y - @radius, x + @radius, y + @radius].all? do |value|
+            (-(2**31)..((2**31) - 1)).cover?((value * context.scaler.factor).round)
+          end
+        end
+
+        def emit(context)
+          records = Emf::Emr::Binary::Records
+          move(context, @prefix)
+          context.emit(records::SetArcDirection, i_type: SETARCDIRECTION, arc_direction: @sweep.zero? ? 1 : 2)
+          x, y = @center
+          points = @radials.map { |radial| radial.zip(@center).map { |delta, origin| delta + origin } }
+          record, type = { arc: [records::Arc, ARC], chord: [records::Chord, CHORD],
+                           pie: [records::Pie, PIE] }.fetch(@kind)
+          context.emit(record, i_type: type,
+                               rcl_box: context.rect_attrs(x - @radius, y - @radius, x + @radius, y + @radius),
+                               ptl_start: context.point_attrs(*points[0]),
+                               ptl_end: context.point_attrs(*points[1]))
+          move(context, @finish)
+        end
+
+        private
+
+        def move(context, point)
+          context.emit(Emf::Emr::Binary::Records::MoveToEx, i_type: MOVETOEX, origin: context.point_attrs(*point))
+        end
+      end
+    end
+  end
+end

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

@@ -5,12 +5,41 @@ module Emfsvg
     module Handlers
       # <defs> contains reusable resources (clipPath, pattern, image)
       # that are referenced by id from elsewhere in the document. The
-      # contents must NOT be emitted as drawing records — they are
-      # rendered only when referenced.
+      # contents are never emitted as drawings. Unused canonical clipping
+      # records can be preserved without applying a clip to later drawings.
       class DefsHandler
-        def self.call(_element, _context)
-          # Intentional no-op: do not descend into <defs> children.
+        def self.call(element, context)
+          pattern = element.selected_pattern || element.unused_pattern
+          emit_pattern(pattern, context) if pattern
+          registry = context.clip_path_registry
+          return unless registry
+
+          element.children.each do |child|
+            next unless child.is_a?(Svg::Elements::ClipPath)
+            next if context.preserve_selected_clip(child)
+            next if context.preserve_unused_selected_clip(child)
+            next if registry.referenced?(child.id)
+            next unless child.unused_rectangle_bounds
+
+            context.emit_unused_clip_rectangle(child.unused_rectangle_bounds)
+          end
+        end
+
+        def self.emit_pattern(pattern, context)
+          image = pattern.image
+          decoded = PngDecoder.decode(image.decoded_bytes)
+          return unless decoded && decoded.width == image.width && decoded.height == image.height
+
+          dib = DibEncoder.encode(decoded.width, decoded.height, decoded.pixels)
+          handle = context.allocate_handle
+          context.emit(Emf::Emr::Binary::Records::CreateDibPatternBrushPt,
+                       i_type: Emf::Emr::Binary::TypeCodes::CREATEDIBPATTERNBRUSHPT,
+                       ih_brush: handle, i_usage: 0,
+                       off_bmi: 32, cb_bmi: 40, off_bits: 72, cb_bits: dib.bytesize - 40,
+                       body: dib)
+          context.pattern_handles[pattern.id] = handle
         end
+        private_class_method :emit_pattern
       end
     end
   end

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

@@ -16,8 +16,8 @@ module Emfsvg
 
         def translate(element, context)
           with_gdi_state(element, context) do
-            box = context.rect_l(element.cx - element.rx, element.cy - element.ry,
-                                 element.cx + element.rx, element.cy + element.ry)
+            box = context.rect_attrs(element.cx - element.rx, element.cy - element.ry,
+                                     element.cx + element.rx, element.cy + element.ry)
             context.emit(Emf::Emr::Binary::Records::Ellipse,
                          i_type: ELLIPSE, rcl_box: box)
           end

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