rmagick 2.15.3 → 2.15.4

data/lib/rvg/deep_equal.rb

@@ -1,54 +1,52 @@
 module Magick
-    class RVG
-        [PathData, Styles, Transforms].each do |c|
-            c.class_eval do
-                def deep_equal(other)
-                    if self != other
-                        puts "#{c.inspect} not equal.\nself:#{self} != other:#{other}"
-                        return false
-                    end
-                    true
-                end
-            end
+  class RVG
+    [PathData, Styles, Transforms].each do |c|
+      c.class_eval do
+        def deep_equal(other)
+          if self != other
+            puts "#{c.inspect} not equal.\nself:#{self} != other:#{other}"
+            return false
+          end
+          true
         end
+      end
+    end
 
-        [Shape, TextBase, Image, Group, Content, Use, ClipPath, Pattern, self].each do |c|
-            c.class_eval do
-                def deep_equal(other)
-                    ivs = instance_variables
-
-                    ivs.each do |iv|
-                        itv = instance_variable_get(iv)
-                        otv = other.instance_variable_get(iv)
-                        if itv.respond_to?(:deep_equal)
-                            if itv.equal?(otv)
-                                puts "#{iv} has deep_equal but self.#{iv} and other.#{iv} are the same object."
-                                return false
-                            end
-                            unless itv.deep_equal(otv)
-                                puts "Not equal.\nself.#{iv}=#{itv.inspect}\nother.#{iv}=#{otv.inspect}"
-                                return false
-                            end
-                        else
-                            case itv
-                                when Float, Symbol, TrueClass, FalseClass, Fixnum, NilClass
-                                    return false if itv != otv
-                                else
-                                    if itv.equal?(otv)
-                                        puts "#{iv} is dup-able but self.#{iv} and other.#{iv} are the same object."
-                                        return false
-                                    end
-                                    if itv != otv
-                                        puts "Not equal.\nself.#{iv}=#{itv.inspect}\nother.#{iv}=#{otv.inspect}"
-                                        return false
-                                    end
-                            end
-                        end
-                    end
-
-                    true
-                end
+    [Shape, TextBase, Image, Group, Content, Use, ClipPath, Pattern, self].each do |c|
+      c.class_eval do
+        def deep_equal(other)
+          ivs = instance_variables
+          ivs.each do |iv|
+            itv = instance_variable_get(iv)
+            otv = other.instance_variable_get(iv)
+            if itv.respond_to?(:deep_equal)
+              if itv.equal?(otv)
+                puts "#{iv} has deep_equal but self.#{iv} and other.#{iv} are the same object."
+                return false
+              end
+              unless itv.deep_equal(otv)
+                puts "Not equal.\nself.#{iv}=#{itv.inspect}\nother.#{iv}=#{otv.inspect}"
+                return false
+              end
+            else
+              case itv
+                when Float, Symbol, TrueClass, FalseClass, Fixnum, NilClass
+                  return false if itv != otv
+                else
+                  if itv.equal?(otv)
+                    puts "#{iv} is dup-able but self.#{iv} and other.#{iv} are the same object."
+                    return false
+                  end
+                  if itv != otv
+                    puts "Not equal.\nself.#{iv}=#{itv.inspect}\nother.#{iv}=#{otv.inspect}"
+                    return false
+                  end
+              end
             end
+          end
+          true
         end
-    end # class RVG
+      end
+    end
+  end # class RVG
 end # module Magick

data/lib/rvg/describable.rb

@@ -2,47 +2,46 @@
 # $Id: describable.rb,v 1.5 2009/02/28 23:52:13 rmagick Exp $
 # Copyright (C) 2009 Timothy P. Hunter
 #++
-
 module Magick
-    class RVG
-        #--
-        # Corresponds to SVG's Description.class
-        #++
-        # This module defines a number of metadata attributes.
-        module Describable
-          private
+  class RVG
+    #--
+    # Corresponds to SVG's Description.class
+    #++
+    # This module defines a number of metadata attributes.
+    module Describable
+      private
 
-            def initialize(*args, &block)       #:nodoc:
-                super
-                @title, @desc, @metadata = nil
-            end
+      def initialize(*args, &block)       #:nodoc:
+        super
+        @title, @desc, @metadata = nil
+      end
 
-          public
+      public
 
-            # Sets the object description
-            attr_writer :desc
-            # Sets the object title
-            attr_writer :title
-            # Sets the object metadata
-            attr_writer :metadata
+      # Sets the object description
+      attr_writer :desc
+      # Sets the object title
+      attr_writer :title
+      # Sets the object metadata
+      attr_writer :metadata
 
-            # Returns the title of this object. The RVG object title is stored as
-            # the 'title' property on the image
-            def title
-                @title.to_s
-            end
+      # Returns the title of this object. The RVG object title is stored as
+      # the 'title' property on the image
+      def title
+        @title.to_s
+      end
 
-            # Returns the description of this object. The RVG object description is
-            # stored as the 'desc' property on the image
-            def desc
-                @desc.to_s
-            end
+      # Returns the description of this object. The RVG object description is
+      # stored as the 'desc' property on the image
+      def desc
+        @desc.to_s
+      end
 
-            # Returns additional metadata of this object. The RVG object metadata
-            # are stored as the 'metadata' property on the image
-            def metadata
-                @metadata.to_s
-            end
-        end     # module Describable
-    end # class RVG
+      # Returns additional metadata of this object. The RVG object metadata
+      # are stored as the 'metadata' property on the image
+      def metadata
+        @metadata.to_s
+      end
+    end     # module Describable
+  end # class RVG
 end # module Magick

data/lib/rvg/embellishable.rb

@@ -2,386 +2,390 @@
 # $Id: embellishable.rb,v 1.9 2009/02/28 23:52:13 rmagick Exp $
 # Copyright (C) 2009 Timothy P. Hunter
 #++
-
 module Magick
-    class RVG
-        # Parent class of Circle, Ellipse, Text, etc.
-        class Shape             #:nodoc:
-            include Stylable
-            include Transformable
-            include Duplicatable
-
-            # Each shape can have its own set of transforms and styles.
-            def add_primitives(gc)
-                gc.push
-                add_transform_primitives(gc)
-                add_style_primitives(gc)
-                gc.__send__(@primitive, *@args)
-                gc.pop
-            end
-        end     # class Shape
-
-        class Circle < Shape
-            # Define a circle with radius +r+ and centered at [<tt>cx</tt>, <tt>cy</tt>].
-            # Use the RVG::ShapeConstructors#circle method to create Circle objects in a container.
-            def initialize(r, cx=0, cy=0)
-                super()
-                r, cx, cy = Magick::RVG.convert_to_float(r, cx, cy)
-                if r < 0
-                    fail ArgumentError, "radius must be >= 0 (#{r} given)"
-                end
-                @primitive = :circle
-                @args = [cx, cy, cx+r, cy]
-                self
-            end
-        end     # class Circle
-
-        class Ellipse < Shape
-            # Define an ellipse with a center at [<tt>cx</tt>, <tt>cy</tt>], a horizontal radius +rx+
-            # and a vertical radius +ry+.
-            # Use the RVG::ShapeConstructors#ellipse method to create Ellipse objects in a container.
-            def initialize(rx, ry, cx=0, cy=0)
-                super()
-                rx, ry, cx, cy = Magick::RVG.convert_to_float(rx, ry, cx, cy)
-                if rx < 0 || ry < 0
-                    fail ArgumentError, "radii must be >= 0 (#{rx}, #{ry} given)"
-                end
-                @primitive = :ellipse
-                # Ellipses are always complete.
-                @args = [cx, cy, rx, ry, 0, 360]
-            end
-        end     # class Ellipse
-
-        class Line < Shape
-            # Define a line from [<tt>x1</tt>, <tt>y1</tt>] to [<tt>x2</tt>, <tt>y2</tt>].
-            # Use the RVG::ShapeConstructors#line method to create Line objects in a container.
-            def initialize(x1=0, y1=0, x2=0, y2=0)
-                super()
-                @primitive = :line
-                @args = [x1, y1, x2, y2]
-            end
-        end     # class Line
-
-        class Path < Shape
-            # Define an SVG path. The argument can be either a path string
-            # or a PathData object.
-            # Use the RVG::ShapeConstructors#path method to create Path objects in a container.
-            def initialize(path)
-                super()
-                @primitive = :path
-                @args = [path.to_s]
-            end
-        end     # class Path
-
-        class Rect < Shape
-            # Define a width x height rectangle. The upper-left corner is at [<tt>x</tt>, <tt>y</tt>].
-            # If either <tt>width</tt> or <tt>height</tt> is 0, the rectangle is not rendered.
-            # Use the RVG::ShapeConstructors#rect method to create Rect objects in a container.
-            def initialize(width, height, x=0, y=0)
-                super()
-                width, height, x, y = Magick::RVG.convert_to_float(width, height, x, y)
-                if width < 0 || height < 0
-                    fail ArgumentError, "width, height must be >= 0 (#{width}, #{height} given)"
-                end
-                @args = [x, y, x+width, y+height]
-                @primitive = :rectangle
-            end
-
-            # Specify optional rounded corners for a rectangle. The arguments
-            # are the x- and y-axis radii. If y is omitted it defaults to x.
-            def round(rx, ry=nil)
-                rx, ry = Magick::RVG.convert_to_float(rx, ry || rx)
-                if rx < 0 || ry < 0
-                    fail ArgumentError, "rx, ry must be >= 0 (#{rx}, #{ry} given)"
-                end
-                @args << rx << ry
-                @primitive = :roundrectangle
-                self
-            end
-        end     # class Rect
-
-        class PolyShape < Shape
-            def polypoints(points)
-                case points.length
-                    when 1
-                        points = Array(points[0])
-                    when 2
-                        x_coords = Array(points[0])
-                        y_coords = Array(points[1])
-                        unless x_coords.length > 0 && y_coords.length > 0
-                            fail ArgumentError, 'array arguments must contain at least one point'
-                        end
-                        n = x_coords.length - y_coords.length
-                        short = n > 0 ? y_coords : x_coords
-                        olen = short.length
-                        n.abs.times {|x| short << short[x % olen]}
-                        points = x_coords.zip(y_coords).flatten
-                end
-                n = points.length
-                if n < 4 || n.odd?
-                    fail ArgumentError, "insufficient/odd number of points specified: #{n}"
-                end
-                Magick::RVG.convert_to_float(*points)
-            end
-        end     # class PolyShape
-
-        class Polygon < PolyShape
-            # Draws a polygon. The arguments are [<tt>x</tt>, <tt>y</tt>] pairs that
-            # define the points that make up the polygon. At least two
-            # points must be specified. If the last point is not the
-            # same as the first, adds an additional point to close
-            # the polygon.
-            # Use the RVG::ShapeConstructors#polygon method to create Polygon objects in a container.
-            def initialize(*points)
-                super()
-                @primitive = :polygon
-                @args = polypoints(points)
-            end
-        end     # class Polygon
-
-        class Polyline < PolyShape
-            # Draws a polyline. The arguments are [<tt>x</tt>, <tt>y</tt>] pairs that
-            # define the points that make up the polyline. At least two
-            # points must be specified.
-            # Use the RVG::ShapeConstructors#polyline method to create Polyline objects in a container.
-            def initialize(*points)
-                super()
-                points = polypoints(points)
-                @primitive = :polyline
-                @args = Magick::RVG.convert_to_float(*points)
-            end
-        end     # class Polyline
-
-        class Image
-            include Stylable
-            include Transformable
-            include Describable
-            include PreserveAspectRatio
-            include Duplicatable
-
-          private
-
-            def align_to_viewport(scale)
-                tx = case @align
-                        when 'none', /\AxMin/
-                            0
-                        when NilClass, /\AxMid/
-                            (@width - @image.columns*scale) / 2.0
-                        when /\AxMax/
-                            @width - @image.columns*scale
-                end
-
-                ty = case @align
-                        when 'none', /YMin\z/
-                            0
-                        when NilClass, /YMid\z/
-                            (@height - @image.rows*scale) / 2.0
-                        when /YMax\z/
-                            @height - @image.rows*scale
-                end
-                [tx, ty]
-            end
-
-            def add_composite_primitive(gc)
-                if @align == 'none'
-                    # Let RMagick do the scaling
-                    scale = 1.0
-                    width, height = @width, @height
-                elsif @meet_or_slice == 'meet'
-                    scale = [@width/@image.columns, @height/@image.rows].min
-                    width, height = @image.columns, @image.rows
-                else
-                    # Establish clipping path around the current viewport
-                    name = __id__.to_s
-                    gc.define_clip_path(name) do
-                        gc.path("M#{@x},#{@y} l#{@width},0 l0,#{@height} l-#{@width},0 l0,-#{@height}z")
-                    end
-
-                    gc.clip_path(name)
-                    scale = [@width/@image.columns, @height/@image.rows].max
-                    width, height = @image.columns, @image.rows
-                end
-                tx, ty = align_to_viewport(scale)
-                gc.composite(@x+tx, @y+ty, width*scale, height*scale, @image)
-            end
-
-            def init_viewbox
-                @align = nil
-                @vbx_width, @vbx_height = @image.columns, @image.rows
-                @meet_or_slice = 'meet'
-            end
-
-          public
-
-            # Composite a raster image in the viewport defined by [x,y] and
-            # +width+ and +height+.
-            # Use the RVG::ImageConstructors#image method to create Text objects in a container.
-            def initialize(image, width=nil, height=nil, x=0, y=0)
-                super()             # run module initializers
-                @image = image.copy # use a copy of the image in case app. re-uses the argument
-                @x, @y, @width, @height = Magick::RVG.convert_to_float(x, y, width || @image.columns, height || @image.rows)
-                if @width < 0 || @height < 0
-                    fail ArgumentError, 'width, height must be >= 0'
-                end
-                init_viewbox
-            end
-
-            def add_primitives(gc)      #:nodoc:
-                # Do not render if width or height is 0
-                return if @width == 0 || @height == 0
-                gc.push
-                add_transform_primitives(gc)
-                add_style_primitives(gc)
-                add_composite_primitive(gc)
-                gc.pop
-            end
-        end     # class Image
-
-        # Methods that construct basic shapes within a container
-        module ShapeConstructors
-            # Draws a circle whose center is [<tt>cx</tt>, <tt>cy</tt>] and radius is +r+.
-            def circle(r, cx=0, cy=0)
-                circle = Circle.new(r, cx, cy)
-                @content << circle
-                circle
-            end
-
-            # Draws an ellipse whose center is [<tt>cx</tt>, <tt>cy</tt>] and having
-            # a horizontal radius +rx+ and vertical radius +ry+.
-            def ellipse(rx, ry, cx=0, cy=0)
-                ellipse = Ellipse.new(rx, ry, cx, cy)
-                @content << ellipse
-                ellipse
-            end
-
-            # Draws a line from [<tt>x1</tt>, <tt>y1</tt>] to  [<tt>x2</tt>, <tt>y2</tt>].
-            def line(x1=0, y1=0, x2=0, y2=0)
-                line = Line.new(x1, y1, x2, y2)
-                @content << line
-                line
-            end
-
-            # Draws a path defined by an SVG path string or a PathData
-            # object.
-            def path(path)
-                path = Path.new(path)
-                @content << path
-                path
-            end
-
-            # Draws a rectangle whose upper-left corner is [<tt>x</tt>, <tt>y</tt>] and
-            # with the specified +width+ and +height+. Unless otherwise
-            # specified the rectangle has square corners. Returns a
-            # Rectangle object.
-            #
-            # Draw a rectangle with rounded corners by calling the #round
-            # method on the Rectangle object. <tt>rx</tt> and <tt>ry</tt> are
-            # the corner radii in the x- and y-directions. For example:
-            #   canvas.rect(width, height, x, y).round(8, 6)
-            # If <tt>ry</tt> is omitted it defaults to <tt>rx</tt>.
-            def rect(width, height, x=0, y=0)
-                rect = Rect.new(width, height, x, y)
-                @content << rect
-                rect
-            end
-
-            # Draws a polygon. The arguments are [<tt>x</tt>, <tt>y</tt>] pairs that
-            # define the points that make up the polygon. At least two
-            # points must be specified. If the last point is not the
-            # same as the first, adds an additional point to close
-            # the polygon.
-            def polygon(*points)
-                polygon = Polygon.new(*points)
-                @content << polygon
-                polygon
-            end
-
-            # Draws a polyline. The arguments are [<tt>x</tt>, <tt>y</tt>] pairs that
-            # define the points that make up the polyline. At least two
-            # points must be specified.
-            def polyline(*points)
-                polyline = Polyline.new(*points)
-                @content << polyline
-                polyline
-            end
-        end     # module ShapeContent
-
-        # Methods that reference ("use") other drawable objects within a container
-        module UseConstructors
-            # Reference an object to be inserted into the container's
-            # content. [<tt>x</tt>,<tt>y</tt>] is the offset from the upper-left
-            # corner. If the argument is an RVG or Image object and +width+ and +height+
-            # are specified, these values will override the +width+ and +height+
-            # attributes on the argument.
-            def use(obj, x=0, y=0, width=nil, height=nil)
-                use = Use.new(obj, x, y, width, height)
-                @content << use
-                use
-            end
-        end     # module UseConstructors
-
-        # Methods that construct container objects within a container
-        module StructureConstructors
-            # Establishes a new viewport. [<tt>x</tt>, <tt>y</tt>] is the coordinate of the
-            # upper-left corner within the containing viewport. This is a
-            # _container_ method. Styles and
-            # transforms specified on this object will be used by objects
-            # contained within, unless overridden by an inner container or
-            # the contained object itself.
-            def rvg(cols, rows, x=0, y=0, &block)
-                rvg = Magick::RVG.new(cols, rows, &block)
-                begin
-                    x, y = Float(x), Float(y)
-                rescue ArgumentError
-                    args = [cols, rows, x, y]
-                    raise ArgumentError, "at least one argument is not convertable to Float (got #{args.collect {|a| a.class}.join(', ')})"
-                end
-                rvg.corner(x, y)
-                @content << rvg
-                rvg
-            end
-
-            # Defines a group.
-            #
-            # This method constructs a new
-            # Group _container_ object. The styles and
-            # transforms specified on this object will be used by objects
-            # contained within, unless overridden by an inner container or
-            # the contained object itself.
-            # Define grouped elements by calling RVG::Embellishable
-            # methods within the associated block.
-            def g(&block)
-                group = Group.new(&block)
-                @content << group
-                group
-            end
-        end     # module StructureConstructors
-
-        # Methods that construct raster image objects within a container
-        module ImageConstructors
-            # Composite a raster image at [<tt>x</tt>,<tt>y</tt>]
-            # in a viewport of the specified <tt>width</tt> and <tt>height</tt>.
-            # If not specified, the width and height are the width and height
-            # of the image. Use the RVG::PreserveAspectRatio#preserve_aspect_ratio method to
-            # control the placement and scaling of the image within the
-            # viewport. By default, the image is scaled to fit inside the
-            # viewport and centered within the viewport.
-            def image(image, width=nil, height=nil, x=0, y=0)
-                img = Image.new(image, width, height, x, y)
-                @content << img
-                img
+  class RVG
+    # Parent class of Circle, Ellipse, Text, etc.
+    class Shape  #:nodoc:
+      include Stylable
+      include Transformable
+      include Duplicatable
+
+      # Each shape can have its own set of transforms and styles.
+      def add_primitives(gc)
+        gc.push
+        add_transform_primitives(gc)
+        add_style_primitives(gc)
+        gc.__send__(@primitive, *@args)
+        gc.pop
+      end
+    end     # class Shape
+
+    class Circle < Shape
+      # Define a circle with radius +r+ and centered at [<tt>cx</tt>, <tt>cy</tt>].
+      # Use the RVG::ShapeConstructors#circle method to create Circle objects in a container.
+      def initialize(r, cx = 0, cy = 0)
+        super()
+        r, cx, cy = Magick::RVG.convert_to_float(r, cx, cy)
+        if r < 0
+          fail ArgumentError, "radius must be >= 0 (#{r} given)"
+        end
+        @primitive = :circle
+        @args = [cx, cy, cx+r, cy]
+        self
+      end
+    end     # class Circle
+
+    class Ellipse < Shape
+      # Define an ellipse with a center at [<tt>cx</tt>, <tt>cy</tt>], a horizontal radius +rx+
+      # and a vertical radius +ry+.
+      # Use the RVG::ShapeConstructors#ellipse method to create Ellipse objects in a container.
+      def initialize(rx, ry, cx = 0, cy = 0)
+        super()
+        rx, ry, cx, cy = Magick::RVG.convert_to_float(rx, ry, cx, cy)
+        if rx < 0 || ry < 0
+          fail ArgumentError, "radii must be >= 0 (#{rx}, #{ry} given)"
+        end
+        @primitive = :ellipse
+        # Ellipses are always complete.
+        @args = [cx, cy, rx, ry, 0, 360]
+      end
+    end     # class Ellipse
+
+    class Line < Shape
+      # Define a line from [<tt>x1</tt>, <tt>y1</tt>] to [<tt>x2</tt>, <tt>y2</tt>].
+      # Use the RVG::ShapeConstructors#line method to create Line objects in a container.
+      def initialize(x1 = 0, y1 = 0, x2 = 0, y2 = 0)
+        super()
+        @primitive = :line
+        @args = [x1, y1, x2, y2]
+      end
+    end     # class Line
+
+    class Path < Shape
+      # Define an SVG path. The argument can be either a path string
+      # or a PathData object.
+      # Use the RVG::ShapeConstructors#path method to create Path objects in a container.
+      def initialize(path)
+        super()
+        @primitive = :path
+        @args = [path.to_s]
+      end
+    end     # class Path
+
+    class Rect < Shape
+      # Define a width x height rectangle. The upper-left corner is at [<tt>x</tt>, <tt>y</tt>].
+      # If either <tt>width</tt> or <tt>height</tt> is 0, the rectangle is not rendered.
+      # Use the RVG::ShapeConstructors#rect method to create Rect objects in a container.
+      def initialize(width, height, x = 0, y = 0)
+        super()
+        width, height, x, y = Magick::RVG.convert_to_float(width, height, x, y)
+        if width < 0 || height < 0
+          fail ArgumentError, "width, height must be >= 0 (#{width}, #{height} given)"
+        end
+        @args = [x, y, x+width, y+height]
+        @primitive = :rectangle
+      end
+
+      # Specify optional rounded corners for a rectangle. The arguments
+      # are the x- and y-axis radii. If y is omitted it defaults to x.
+      def round(rx, ry = nil)
+        rx, ry = Magick::RVG.convert_to_float(rx, ry || rx)
+        if rx < 0 || ry < 0
+          fail ArgumentError, "rx, ry must be >= 0 (#{rx}, #{ry} given)"
+        end
+        @args << rx << ry
+        @primitive = :roundrectangle
+        self
+      end
+    end  # class Rect
+
+    class PolyShape < Shape
+      def polypoints(points)
+        case points.length
+          when 1
+            points = Array(points[0])
+          when 2
+            x_coords = Array(points[0])
+            y_coords = Array(points[1])
+            unless x_coords.length > 0 && y_coords.length > 0
+              fail ArgumentError, 'array arguments must contain at least one point'
             end
-        end     # module ImageConstructors
-
-        # Methods that create shapes, text, and other drawable objects
-        # within container objects such as ::Magick::RVG and
-        # ::Magick::RVG::Group
-        module Embellishable
-            include StructureConstructors
-            include ShapeConstructors
-            include TextConstructors
-            include UseConstructors
-            include ImageConstructors
-        end     # module Embellishable
-    end # class RVG
+            n = x_coords.length - y_coords.length
+            short = n > 0 ? y_coords : x_coords
+            olen = short.length
+            n.abs.times {|x| short << short[x % olen]}
+            points = x_coords.zip(y_coords).flatten
+        end
+        n = points.length
+        if n < 4 || n.odd?
+          fail ArgumentError, "insufficient/odd number of points specified: #{n}"
+        end
+        Magick::RVG.convert_to_float(*points)
+      end
+    end  # class PolyShape
+
+    class Polygon < PolyShape
+      # Draws a polygon. The arguments are [<tt>x</tt>, <tt>y</tt>] pairs that
+      # define the points that make up the polygon. At least two
+      # points must be specified. If the last point is not the
+      # same as the first, adds an additional point to close
+      # the polygon.
+      # Use the RVG::ShapeConstructors#polygon method to create Polygon objects in a container.
+      def initialize(*points)
+        super()
+        @primitive = :polygon
+        @args = polypoints(points)
+      end
+    end     # class Polygon
+
+    class Polyline < PolyShape
+      # Draws a polyline. The arguments are [<tt>x</tt>, <tt>y</tt>] pairs that
+      # define the points that make up the polyline. At least two
+      # points must be specified.
+      # Use the RVG::ShapeConstructors#polyline method to create Polyline objects in a container.
+      def initialize(*points)
+        super()
+        points = polypoints(points)
+        @primitive = :polyline
+        @args = Magick::RVG.convert_to_float(*points)
+      end
+    end     # class Polyline
+
+    class Image
+      include Stylable
+      include Transformable
+      include Describable
+      include PreserveAspectRatio
+      include Duplicatable
+
+      private
+
+      def align_to_viewport(scale)
+        tx = case @align
+            when 'none', /\AxMin/
+              0
+            when NilClass, /\AxMid/
+              (@width - @image.columns*scale) / 2.0
+            when /\AxMax/
+              @width - @image.columns*scale
+        end
+
+        ty = case @align
+            when 'none', /YMin\z/
+              0
+            when NilClass, /YMid\z/
+              (@height - @image.rows*scale) / 2.0
+            when /YMax\z/
+              @height - @image.rows*scale
+        end
+        [tx, ty]
+      end
+
+      def add_composite_primitive(gc)
+        if @align == 'none'
+          # Let RMagick do the scaling
+          scale = 1.0
+          width = @width
+          height = @height
+        elsif @meet_or_slice == 'meet'
+          scale = [@width/@image.columns, @height/@image.rows].min
+          width = @image.columns
+          height = @image.rows
+        else
+          # Establish clipping path around the current viewport
+          name = __id__.to_s
+          gc.define_clip_path(name) do
+            gc.path("M#{@x},#{@y} l#{@width},0 l0,#{@height} l-#{@width},0 l0,-#{@height}z")
+          end
+
+          gc.clip_path(name)
+          scale = [@width/@image.columns, @height/@image.rows].max
+          width = @image.columns
+          height = @image.rows
+        end
+        tx, ty = align_to_viewport(scale)
+        gc.composite(@x+tx, @y+ty, width*scale, height*scale, @image)
+      end
+
+      def init_viewbox
+        @align = nil
+        @vbx_width = @image.columns
+        @vbx_height = @image.rows
+        @meet_or_slice = 'meet'
+      end
+
+      public
+
+      # Composite a raster image in the viewport defined by [x,y] and
+      # +width+ and +height+.
+      # Use the RVG::ImageConstructors#image method to create Text objects in a container.
+      def initialize(image, width = nil, height = nil, x = 0, y = 0)
+        super()             # run module initializers
+        @image = image.copy # use a copy of the image in case app. re-uses the argument
+        @x, @y, @width, @height = Magick::RVG.convert_to_float(x, y, width || @image.columns, height || @image.rows)
+        if @width < 0 || @height < 0
+          fail ArgumentError, 'width, height must be >= 0'
+        end
+        init_viewbox
+      end
+
+      def add_primitives(gc) #:nodoc:
+        # Do not render if width or height is 0
+        return if @width == 0 || @height == 0
+        gc.push
+        add_transform_primitives(gc)
+        add_style_primitives(gc)
+        add_composite_primitive(gc)
+        gc.pop
+      end
+    end     # class Image
+
+    # Methods that construct basic shapes within a container
+    module ShapeConstructors
+      # Draws a circle whose center is [<tt>cx</tt>, <tt>cy</tt>] and radius is +r+.
+      def circle(r, cx = 0, cy = 0)
+        circle = Circle.new(r, cx, cy)
+        @content << circle
+        circle
+      end
+
+      # Draws an ellipse whose center is [<tt>cx</tt>, <tt>cy</tt>] and having
+      # a horizontal radius +rx+ and vertical radius +ry+.
+      def ellipse(rx, ry, cx = 0, cy = 0)
+        ellipse = Ellipse.new(rx, ry, cx, cy)
+        @content << ellipse
+        ellipse
+      end
+
+      # Draws a line from [<tt>x1</tt>, <tt>y1</tt>] to  [<tt>x2</tt>, <tt>y2</tt>].
+      def line(x1 = 0, y1 = 0, x2 = 0, y2 = 0)
+        line = Line.new(x1, y1, x2, y2)
+        @content << line
+        line
+      end
+
+      # Draws a path defined by an SVG path string or a PathData
+      # object.
+      def path(path)
+        path = Path.new(path)
+        @content << path
+        path
+      end
+
+      # Draws a rectangle whose upper-left corner is [<tt>x</tt>, <tt>y</tt>] and
+      # with the specified +width+ and +height+. Unless otherwise
+      # specified the rectangle has square corners. Returns a
+      # Rectangle object.
+      #
+      # Draw a rectangle with rounded corners by calling the #round
+      # method on the Rectangle object. <tt>rx</tt> and <tt>ry</tt> are
+      # the corner radii in the x- and y-directions. For example:
+      #   canvas.rect(width, height, x, y).round(8, 6)
+      # If <tt>ry</tt> is omitted it defaults to <tt>rx</tt>.
+      def rect(width, height, x = 0, y = 0)
+        rect = Rect.new(width, height, x, y)
+        @content << rect
+        rect
+      end
+
+      # Draws a polygon. The arguments are [<tt>x</tt>, <tt>y</tt>] pairs that
+      # define the points that make up the polygon. At least two
+      # points must be specified. If the last point is not the
+      # same as the first, adds an additional point to close
+      # the polygon.
+      def polygon(*points)
+        polygon = Polygon.new(*points)
+        @content << polygon
+        polygon
+      end
+
+      # Draws a polyline. The arguments are [<tt>x</tt>, <tt>y</tt>] pairs that
+      # define the points that make up the polyline. At least two
+      # points must be specified.
+      def polyline(*points)
+        polyline = Polyline.new(*points)
+        @content << polyline
+        polyline
+      end
+    end     # module ShapeContent
+
+    # Methods that reference ("use") other drawable objects within a container
+    module UseConstructors
+      # Reference an object to be inserted into the container's
+      # content. [<tt>x</tt>,<tt>y</tt>] is the offset from the upper-left
+      # corner. If the argument is an RVG or Image object and +width+ and +height+
+      # are specified, these values will override the +width+ and +height+
+      # attributes on the argument.
+      def use(obj, x = 0, y = 0, width = nil, height = nil)
+        use = Use.new(obj, x, y, width, height)
+        @content << use
+        use
+      end
+    end     # module UseConstructors
+
+    # Methods that construct container objects within a container
+    module StructureConstructors
+      # Establishes a new viewport. [<tt>x</tt>, <tt>y</tt>] is the coordinate of the
+      # upper-left corner within the containing viewport. This is a
+      # _container_ method. Styles and
+      # transforms specified on this object will be used by objects
+      # contained within, unless overridden by an inner container or
+      # the contained object itself.
+      def rvg(cols, rows, x = 0, y = 0, &block)
+        rvg = Magick::RVG.new(cols, rows, &block)
+        begin
+          x = Float(x)
+          y = Float(y)
+        rescue ArgumentError
+          args = [cols, rows, x, y]
+          raise ArgumentError, "at least one argument is not convertable to Float (got #{args.collect {|a| a.class}.join(', ')})"
+        end
+        rvg.corner(x, y)
+        @content << rvg
+        rvg
+      end
+
+      # Defines a group.
+      #
+      # This method constructs a new
+      # Group _container_ object. The styles and
+      # transforms specified on this object will be used by objects
+      # contained within, unless overridden by an inner container or
+      # the contained object itself.
+      # Define grouped elements by calling RVG::Embellishable
+      # methods within the associated block.
+      def g(&block)
+        group = Group.new(&block)
+        @content << group
+        group
+      end
+    end     # module StructureConstructors
+
+    # Methods that construct raster image objects within a container
+    module ImageConstructors
+      # Composite a raster image at [<tt>x</tt>,<tt>y</tt>]
+      # in a viewport of the specified <tt>width</tt> and <tt>height</tt>.
+      # If not specified, the width and height are the width and height
+      # of the image. Use the RVG::PreserveAspectRatio#preserve_aspect_ratio method to
+      # control the placement and scaling of the image within the
+      # viewport. By default, the image is scaled to fit inside the
+      # viewport and centered within the viewport.
+      def image(image, width = nil, height = nil, x = 0, y = 0)
+        img = Image.new(image, width, height, x, y)
+        @content << img
+        img
+      end
+    end     # module ImageConstructors
+
+    # Methods that create shapes, text, and other drawable objects
+    # within container objects such as ::Magick::RVG and
+    # ::Magick::RVG::Group
+    module Embellishable
+      include StructureConstructors
+      include ShapeConstructors
+      include TextConstructors
+      include UseConstructors
+      include ImageConstructors
+    end     # module Embellishable
+  end # class RVG
 end # module Magick