emf 0.1.2 → 0.2.0

data/lib/emf/emf_plus/parser.rb

@@ -2,11 +2,73 @@
 
 module Emf
   module EmfPlus
+    # Frames EMF+ records without decoding their bodies. Unknown record types
+    # are framed like any other, so nothing is dropped.
+    #
+    # Malformed framing raises Emf::ParseError. Pass `errors:` (an Array) to
+    # instead collect the ParseError and stop framing the stream at that point,
+    # the way Emr::Parser treats a corrupt EMR record.
     module Parser
       module_function
 
-      def call(_bytes)
-        raise Error, "EMF+ parser not yet implemented — see TODO.impl/14-emfplus-parser.md"
+      def call(bytes, errors: nil, comment_index: nil)
+        bytes = bytes.b
+        frames = []
+        offset = 0
+        while offset < bytes.bytesize
+          frame = read_frame(bytes, offset, comment_index)
+          frames << frame
+          offset += frame.size
+        end
+        frames
+      rescue ParseError => e
+        raise unless errors
+
+        errors << e
+        frames
+      end
+
+      # Frames each EMF+ comment of a parsed Metafile separately, tagging every
+      # frame with the index (into metafile.records) of the comment it came
+      # from. Concatenating the comment payloads gives Metafile#emf_plus.
+      def from_metafile(metafile, errors: nil)
+        metafile.records.each_with_index.flat_map do |record, index|
+          next [] unless record.wire.is_a?(Emf::Emr::Binary::Records::Comment)
+
+          call(Emf::Emr::Parser.extract_emf_plus(record.wire), errors: errors, comment_index: index)
+        end
+      end
+
+      def read_frame(bytes, offset, comment_index)
+        remaining = bytes.bytesize - offset
+        fail_at(offset, nil, "truncated EMF+ record header (#{remaining} bytes left)") if remaining < Frame::HEADER_BYTES
+
+        type, flags, size, data_size = bytes.byteslice(offset, Frame::HEADER_BYTES).unpack("vvVV")
+        validate_sizes(offset, type, size, data_size, remaining, comment_index)
+        Frame.new(type: type, flags: flags, size: size, data_size: data_size,
+                  data: bytes.byteslice(offset + Frame::HEADER_BYTES, size - Frame::HEADER_BYTES),
+                  offset: offset, comment_index: comment_index)
+      end
+
+      def validate_sizes(offset, type, size, data_size, remaining, comment_index = nil)
+        fail_at(offset, type, "EMF+ record Size #{size} < #{Frame::HEADER_BYTES}") if size < Frame::HEADER_BYTES
+        fail_at(offset, type, "EMF+ record Size #{size} is not a multiple of 4") unless (size % 4).zero?
+        fail_at(offset, type, "EMF+ record DataSize #{data_size} exceeds Size #{size} - 12") if data_size > size - Frame::HEADER_BYTES
+        fail_at(offset, type, truncated_message(size, remaining, comment_index, offset)) if size > remaining
+      end
+
+      # MS-EMFPLUS 1.3 and MS-EMF 2.3.3.2: an EMR_COMMENT_EMFPLUS holds whole
+      # EMF+ records; only an EmfPlusObject (C flag) continues in a later record.
+      # A record that runs past its comment is therefore malformed, not split.
+      def truncated_message(size, remaining, comment_index, offset)
+        return "truncated EMF+ record (Size #{size}, #{remaining} bytes left)" unless comment_index
+
+        "EMF+ record (Size #{size}) overruns EMR_COMMENT_EMFPLUS record #{comment_index} by " \
+          "#{size - remaining} bytes; a record cannot span comments (comment payload offset #{offset})"
+      end
+
+      def fail_at(offset, type, message)
+        raise ParseError.new(offset: offset, record_code: type, message: "#{message} at offset #{offset}")
       end
     end
   end

data/lib/emf/emf_plus/records/base.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Emf
+  module EmfPlus
+    module Records
+      # A framed record whose body is read through a BinData class (BODY in the
+      # subclass). Bytes after the body (padding, unknown trailing data) are
+      # kept in `trailing`, so an unedited record re-encodes to its frame bytes.
+      class Base
+        attr_reader :type, :flags, :size, :data_size, :offset, :comment_index, :body, :trailing
+
+        def initialize(frame)
+          @type = frame.type
+          @flags = frame.flags
+          @size = frame.size
+          @data_size = frame.data_size
+          @offset = frame.offset
+          @comment_index = frame.comment_index
+          @body = read_body(frame)
+          @trailing = frame.data.byteslice(@body.num_bytes..).freeze
+        end
+
+        def to_binary
+          [type, flags, size, data_size].pack("vvVV") + body.to_binary_s + trailing
+        end
+
+        # Returns a new record with the given edits applied; the receiver is
+        # unchanged. Keys are:
+        #   flags:        the raw Record Flags value;
+        #   flag fields:  the names in #flag_fields (compressed:, emf_object_id:,
+        #                 combine_mode: ...). Booleans set or clear a bit, integers
+        #                 fill a bit range; every other flag bit is kept;
+        #   body fields:  any BinData field of the body. Length fields and
+        #                 their arrays are independent, so a variable-length
+        #                 edit sets both (item_count: 3, rect_data: {...}).
+        # Size and DataSize are recomputed. Trailing bytes beyond the original
+        # DataSize are alignment padding and are dropped (the new Size re-pads);
+        # trailing bytes inside it are unknown data, kept after the body and
+        # counted in DataSize.
+        # Changing a flag that selects the body layout (compressed, relative)
+        # keeps the other fields; array elements of the newly selected layout
+        # start zeroed unless the same call supplies them.
+        def with(**edits)
+          new_flags = edited_flags(edits)
+          new_body = edited_body(new_flags, edits)
+          self.class.new(edited_frame(new_flags, new_body))
+        end
+
+        # Flag-backed attributes editable through #with, as { name => mask }.
+        # Record families and mixins extend it with `super.merge(...)`.
+        def flag_fields = {}
+
+        private
+
+        def edited_flags(edits)
+          flag_edits = edits.slice(*flag_fields.keys)
+          flag_edits.reduce(edits.fetch(:flags, flags)) do |bits, (name, value)|
+            encode_flag(bits, name, flag_fields.fetch(name), value)
+          end
+        end
+
+        def encode_flag(bits, name, mask, value)
+          shift = (mask & -mask).bit_length - 1
+          number = { true => 1, false => 0 }.fetch(value, value)
+          unless number.is_a?(Integer) && number.between?(0, mask >> shift)
+            raise ArgumentError, "#{name} must fit #{(mask >> shift).bit_length} bit(s), got #{value.inspect}"
+          end
+
+          (bits & ~mask) | (number << shift)
+        end
+
+        def edited_body(new_flags, edits)
+          fields = edits.except(:flags, *flag_fields.keys)
+          unknown = fields.keys - body.field_names
+          raise ArgumentError, "unknown field(s) #{unknown.join(', ')} for #{self.class.name}" unless unknown.empty?
+
+          self.class::BODY.new(data_size: data_size, flags: new_flags).tap do |fresh|
+            fresh.assign(deep_merge(body.snapshot, fields))
+          end
+        end
+
+        # BinData#assign(hash) clears every field it is not given, so edits
+        # are folded into the body's own snapshot and assigned once.
+        def deep_merge(base, edit)
+          return edit unless base.is_a?(Hash) && edit.is_a?(Hash)
+
+          base.merge(edit) { |_name, old, new| deep_merge(old, new) }
+        end
+
+        def edited_frame(new_flags, new_body)
+          kept = trailing.byteslice(0, data_size - body.num_bytes)
+          Frame.new(type: type, flags: new_flags, size: Frame::HEADER_BYTES, data_size: 0, data: "",
+                    offset: offset, comment_index: comment_index).with_data(new_body.to_binary_s + kept)
+        end
+
+        def read_body(frame)
+          self.class::BODY.new(data_size: data_size, flags: flags).read(frame.data.byteslice(0, data_size))
+        rescue IOError, BinData::ValidityError => e
+          raise ParseError.new(offset: offset, record_code: type,
+                               message: "malformed #{self.class.name.split('::').last} body at offset #{offset}: #{e.message}")
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/begin_container.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "emf/emf_plus/records/primitives/rect_f"
+
+module Emf
+  module EmfPlus
+    module Records
+      # EmfPlusBeginContainer (2.3.7.1). Flags low byte is the PageUnit
+      # (UnitType); DestRect and SrcRect define the container transform.
+      class BeginContainer < Base
+        TYPE = 0x4027
+        PAGE_UNIT_MASK = 0x00FF
+
+        class BeginContainerBody < Body
+          endian :little
+          rect_f :dest_rect
+          rect_f :src_rect
+          uint32 :stack_index
+        end
+        BODY = BeginContainerBody
+
+        def flag_fields = { page_unit: PAGE_UNIT_MASK }
+
+        def page_unit = flags & PAGE_UNIT_MASK
+        def dest_rect = body.dest_rect
+        def src_rect = body.src_rect
+        def stack_index = body.stack_index.to_i
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/begin_container_no_params.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    module Records
+      # EmfPlusBeginContainerNoParams (2.3.7.2): opens a container identified by StackIndex.
+      class BeginContainerNoParams < Base
+        TYPE = 0x4028
+
+        class BeginContainerNoParamsBody < Body
+          endian :little
+          uint32 :stack_index
+        end
+        BODY = BeginContainerNoParamsBody
+
+        def stack_index = body.stack_index.to_i
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/body.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "bindata"
+require "emf/binary/class_field_accessors"
+
+module Emf
+  module EmfPlus
+    module Records
+      # Base of every BinData structure declared under Records. Its fields are
+      # always class-level, so the accessors are defined once per class.
+      class Body < BinData::Record
+        prepend Emf::Binary::ClassFieldAccessors
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/clear.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "emf/emf_plus/records/primitives/argb"
+
+module Emf
+  module EmfPlus
+    module Records
+      # EmfPlusClear (2.3.4.1). Flags are unused.
+      class Clear < Base
+        TYPE = 0x4009
+
+        class ClearBody < Body
+          endian :little
+          argb :color
+        end
+        BODY = ClearBody
+
+        def color = body.color
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/clip_transform_flags.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    module Records
+      # Record Flags readers shared by the clipping and transform records.
+      module CombineModeFlags
+        COMBINE_MODE_MASK = 0x0F00
+        OBJECT_ID_MASK = 0x00FF
+
+        def flag_fields = super.merge(combine_mode: COMBINE_MODE_MASK, emf_object_id: OBJECT_ID_MASK)
+
+        def combine_mode = (flags & COMBINE_MODE_MASK) >> 8
+        def emf_object_id = flags & OBJECT_ID_MASK
+      end
+
+      module PostMultiplyFlag
+        POST_MULTIPLY_FLAG = 0x2000
+
+        def flag_fields = super.merge(post_multiply: POST_MULTIPLY_FLAG)
+
+        def post_multiply? = flags.anybits?(POST_MULTIPLY_FLAG)
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/comment.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    module Records
+      # EmfPlusComment (2.3.3.4): opaque private data.
+      class Comment < Base
+        TYPE = 0x4003
+
+        class CommentBody < Body
+          endian :little
+          mandatory_parameter :data_size
+          string :private_data, read_length: :data_size
+        end
+        BODY = CommentBody
+
+        def private_data = body.private_data.to_s
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/draw_arc.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "emf/binary/float32_le"
+require "emf/emf_plus/records/primitives/rect_array"
+
+module Emf
+  module EmfPlus
+    module Records
+      # EmfPlusDrawArc (2.3.4.2). C selects Rect over RectF; ObjectID is the pen.
+      class DrawArc < Base
+        include ShapeFlags
+
+        TYPE = 0x4012
+
+        class DrawArcBody < Body
+          endian :little
+          mandatory_parameter :flags
+          float32_le :start_angle
+          float32_le :sweep_angle
+          rect_array :rect_data,
+                     rect_count: 1,
+                     compressed: -> { flags.anybits?(ShapeFlags::COMPRESSED_FLAG) }
+        end
+        BODY = DrawArcBody
+
+        def pen_id = emf_object_id
+        def start_angle = body.start_angle
+        def sweep_angle = body.sweep_angle
+        def rect = body.rect_data.rects.first
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/draw_beziers.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "emf/emf_plus/records/primitives/point_array"
+
+module Emf
+  module EmfPlus
+    module Records
+      # EmfPlusDrawBeziers (2.3.4.3). C compressed, P relative points; ObjectID is the pen.
+      class DrawBeziers < Base
+        include ShapeFlags
+
+        TYPE = 0x4019
+
+        class DrawBeziersBody < Body
+          endian :little
+          mandatory_parameter :flags
+          uint32 :item_count
+          point_array :point_data,
+                      point_count: :item_count,
+                      relative: -> { flags.anybits?(ShapeFlags::RELATIVE_FLAG) },
+                      compressed: -> { flags.anybits?(ShapeFlags::COMPRESSED_FLAG) }
+        end
+        BODY = DrawBeziersBody
+
+        def pen_id = emf_object_id
+        def count = body.item_count
+        def points = body.point_data.points
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/draw_closed_curve.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "emf/binary/float32_le"
+require "emf/emf_plus/records/primitives/point_array"
+
+module Emf
+  module EmfPlus
+    module Records
+      # EmfPlusDrawClosedCurve (2.3.4.4). C compressed, P relative points; ObjectID is the pen.
+      class DrawClosedCurve < Base
+        include ShapeFlags
+
+        TYPE = 0x4017
+
+        class DrawClosedCurveBody < Body
+          endian :little
+          mandatory_parameter :flags
+          float32_le :tension
+          uint32 :item_count
+          point_array :point_data,
+                      point_count: :item_count,
+                      relative: -> { flags.anybits?(ShapeFlags::RELATIVE_FLAG) },
+                      compressed: -> { flags.anybits?(ShapeFlags::COMPRESSED_FLAG) }
+        end
+        BODY = DrawClosedCurveBody
+
+        def pen_id = emf_object_id
+        def tension = body.tension
+        def count = body.item_count
+        def points = body.point_data.points
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/draw_curve.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "emf/binary/float32_le"
+require "emf/emf_plus/records/primitives/point_array"
+
+module Emf
+  module EmfPlus
+    module Records
+      # EmfPlusDrawCurve (2.3.4.5). C selects Point over PointF; ObjectID is the pen.
+      class DrawCurve < Base
+        include ShapeFlags
+
+        TYPE = 0x4018
+
+        class DrawCurveBody < Body
+          endian :little
+          mandatory_parameter :flags
+          float32_le :tension
+          uint32 :offset
+          uint32 :num_segments
+          uint32 :item_count
+          point_array :point_data,
+                      point_count: :item_count,
+                      relative: -> { false },
+                      compressed: -> { flags.anybits?(ShapeFlags::COMPRESSED_FLAG) }
+        end
+        BODY = DrawCurveBody
+
+        def pen_id = emf_object_id
+        def tension = body.tension
+        def start_point_index = body.offset
+        def num_segments = body.num_segments
+        def count = body.item_count
+        def points = body.point_data.points
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/draw_driver_string.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "emf/binary/float32_le"
+require "emf/emf_plus/records/primitives/bounded_array"
+require "emf/emf_plus/records/primitives/point_f"
+
+module Emf
+  module EmfPlus
+    module Records
+      # EmfPlusDrawDriverString (2.3.4.6). The glyph position array always holds
+      # GlyphCount elements, as the Size and DataSize formulas require.
+      class DrawDriverString < Base
+        TYPE = 0x4036
+        SOLID_COLOR_FLAG = 0x8000
+        OBJECT_ID_MASK = 0x00FF
+        CMAP_LOOKUP = 0x00000001
+        VERTICAL = 0x00000002
+        REALIZED_ADVANCE = 0x00000004
+        LIMIT_SUBPIXEL = 0x00000008
+
+        class DrawDriverStringBody < Body
+          endian :little
+          uint32 :brush_id
+          uint32 :options_flags
+          uint32 :matrix_present
+          uint32 :glyph_count
+          bounded_array :glyphs, type: :uint16, element_size: 2, initial_length: :glyph_count
+          bounded_array :glyph_positions, type: :point_f, element_size: 8, initial_length: :glyph_count
+          array :transform_matrix, type: :float32_le, initial_length: 6, onlyif: -> { matrix_present == 1 }
+        end
+        BODY = DrawDriverStringBody
+
+        def flag_fields = { solid_color: SOLID_COLOR_FLAG, font_object_id: OBJECT_ID_MASK }
+
+        def solid_color? = flags.anybits?(SOLID_COLOR_FLAG)
+        def font_object_id = flags & OBJECT_ID_MASK
+        def brush_id = body.brush_id
+        def options_flags = body.options_flags
+        def cmap_lookup? = options_flags.anybits?(CMAP_LOOKUP)
+        def vertical? = options_flags.anybits?(VERTICAL)
+        def realized_advance? = options_flags.anybits?(REALIZED_ADVANCE)
+        def limit_subpixel? = options_flags.anybits?(LIMIT_SUBPIXEL)
+        def matrix_present? = body.matrix_present == 1
+        def glyph_count = body.glyph_count
+        def glyphs = body.glyphs.to_a
+
+        # Glyphs are UTF-16 code units only under CmapLookup; otherwise they are
+        # font glyph indices and carry no text.
+        def text
+          return unless cmap_lookup?
+
+          glyphs.pack("v*").force_encoding(Encoding::UTF_16LE)
+                .encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+        end
+
+        def glyph_positions = body.glyph_positions.map { |p| [p.x, p.y] }
+        def transform_matrix = matrix_present? ? body.transform_matrix.to_a : nil
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/draw_ellipse.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "emf/emf_plus/records/primitives/rect_array"
+
+module Emf
+  module EmfPlus
+    module Records
+      # EmfPlusDrawEllipse (2.3.4.7). C selects Rect over RectF; ObjectID is the pen.
+      class DrawEllipse < Base
+        include ShapeFlags
+
+        TYPE = 0x400F
+
+        class DrawEllipseBody < Body
+          endian :little
+          mandatory_parameter :flags
+          rect_array :rect_data,
+                     rect_count: 1,
+                     compressed: -> { flags.anybits?(ShapeFlags::COMPRESSED_FLAG) }
+        end
+        BODY = DrawEllipseBody
+
+        def pen_id = emf_object_id
+        def rect = body.rect_data.rects.first
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/draw_image.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "emf/emf_plus/records/primitives/rect_f"
+require "emf/emf_plus/records/primitives/rect"
+
+module Emf
+  module EmfPlus
+    module Records
+      # EmfPlusDrawImage (2.3.4.8). The C flag selects EmfPlusRect over
+      # EmfPlusRectF for RectData.
+      class DrawImage < Base
+        TYPE = 0x401A
+        COMPRESSED_FLAG = 0x4000
+        OBJECT_ID_MASK = 0x00FF
+
+        class DrawImageBody < Body
+          endian :little
+          mandatory_parameter :flags
+          uint32 :image_attributes_id
+          int32 :src_unit
+          rect_f :src_rect
+          rect :compressed_rect, onlyif: -> { flags.anybits?(COMPRESSED_FLAG) }
+          rect_f :rect_data, onlyif: -> { !flags.anybits?(COMPRESSED_FLAG) }
+        end
+        BODY = DrawImageBody
+
+        def flag_fields = { compressed: COMPRESSED_FLAG, image_object_id: OBJECT_ID_MASK }
+
+        def compressed? = flags.anybits?(COMPRESSED_FLAG)
+        def image_object_id = flags & OBJECT_ID_MASK
+        def image_attributes_id = body.image_attributes_id
+        def src_unit = body.src_unit
+        def src_rect = rect_values(body.src_rect)
+        def dest_rect = rect_values(compressed? ? body.compressed_rect : body.rect_data)
+
+        private
+
+        def rect_values(rect) = [rect.x, rect.y, rect.width, rect.height]
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/draw_image_points.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "emf/emf_plus/records/primitives/bounded_array"
+require "emf/emf_plus/records/primitives/rect_f"
+require "emf/emf_plus/records/primitives/point_f"
+require "emf/emf_plus/records/primitives/point"
+require "emf/emf_plus/records/primitives/point_r"
+
+module Emf
+  module EmfPlus
+    module Records
+      # EmfPlusDrawImagePoints (2.3.4.9). P selects relative EmfPlusPointR
+      # elements and makes C undefined; otherwise C selects EmfPlusPoint over
+      # EmfPlusPointF. E means an earlier EmfPlusSerializableObject supplies
+      # the effect.
+      class DrawImagePoints < Base
+        TYPE = 0x401B
+        COMPRESSED_FLAG = 0x4000
+        EFFECT_FLAG = 0x2000
+        RELATIVE_FLAG = 0x0800
+        OBJECT_ID_MASK = 0x00FF
+
+        class DrawImagePointsBody < Body
+          endian :little
+          mandatory_parameter :flags
+          uint32 :image_attributes_id
+          int32 :src_unit
+          rect_f :src_rect
+          uint32 :point_count
+          bounded_array :relative_points, type: :point_r, element_size: 2, initial_length: :point_count, onlyif: lambda {
+            flags.anybits?(RELATIVE_FLAG)
+          }
+          bounded_array :compressed_points, type: :point, element_size: 4, initial_length: :point_count,
+                                            onlyif: -> { !flags.anybits?(RELATIVE_FLAG) && flags.anybits?(COMPRESSED_FLAG) }
+          bounded_array :float_points, type: :point_f, element_size: 8, initial_length: :point_count,
+                                       onlyif: -> { !flags.anybits?(RELATIVE_FLAG) && !flags.anybits?(COMPRESSED_FLAG) }
+        end
+        BODY = DrawImagePointsBody
+
+        def flag_fields
+          { compressed: COMPRESSED_FLAG, relative: RELATIVE_FLAG, effect: EFFECT_FLAG, image_object_id: OBJECT_ID_MASK }
+        end
+
+        def relative? = flags.anybits?(RELATIVE_FLAG)
+        def compressed? = !relative? && flags.anybits?(COMPRESSED_FLAG)
+        def effect? = flags.anybits?(EFFECT_FLAG)
+        def image_object_id = flags & OBJECT_ID_MASK
+        def image_attributes_id = body.image_attributes_id
+        def src_unit = body.src_unit
+        def src_rect = body.src_rect.then { |r| [r.x, r.y, r.width, r.height] }
+        def count = body.point_count
+        def points = relative? ? body.relative_points.map { |p| [p.x.to_i, p.y.to_i] } : point_array.map { |p| [p.x, p.y] }
+
+        private
+
+        def point_array
+          compressed? ? body.compressed_points : body.float_points
+        end
+      end
+    end
+  end
+end