In addition to the methods listed above, class
    RVG also implements the styles method, the shape methods and the transform methods.
RVG.new(width=nil, height=nil) [ { |canvas| drawing method calls } ] -> rvg
Creates a container that can have its own coordinate system. Within the block, call drawing methods on canvas to render shapes, text, and raster images in the container.
An RVG object is always the outermost container for a drawing. Call the draw method on the returned RVG object to produce the final image.
If the RVG object is the outermost container, width and height are required and specify the width and height of the final drawing in pixels. You can call conversion methods to use units such as inches and millimeters instead of pixels.
Otherwise, width and height specify the area of the viewbox. If the RVG
    object will be used as an argument to the use method, then width and height may be
    omitted here, then specified as arguments to
    use.
An RVG object
See the tutorial for a simple
    example. The image below demonstrates an advanced use of
    RVG.new. This example creates an RVG object that
    draws an orange-and-green target. The width and height
    arguments are omitted in the RVG.new call.
    Instead, the viewport width and height are specified as
    arguments to 4 invocations of use. Each use specifies a
    different viewport size, so the same RVG object draws 4
    different-sized targets.
Click the image to see the example script.
canvas.background_fill = value
Specify a background fill color. The attribute value may be either a pixel or a color name. The default fill color is "#00000000". This color is usually called "none". This attribute has no effect on nested RVG objects.
canvas.background_fill = 'white'
canvas.background_fill_opacity = value
Specify the opacity of the background fill color when the
    background fill is not the
    default. The value is a number between 0.0 (fully transparent)
    and 1.0 (fully opaque). The default is 1.0. The attribute is
    ignored unless background_fill is specified. This
    attribute has no effect on nested RVG objects.
canvas.background_fill = 'white' canvas.background_fill_opacity = 0.50
canvas.background_image = image
Specify an image to be used as the canvas background. The value is an Image object. This attribute has no effect on nested RVG objects.
canvas.background_image = Magick::Image.read('myBackground.gif').first
    canvas.background_pattern = fill
Specify an Fill object to fill the canvas background. This attribute has no effect on nested RVG objects.
canvas.background_pattern = Magick::GradientFill.new(0, 0, 0, 100, "#900", "#000")
a Fill object
canvas.background_position = pos
If the dimensions of the image specified by background_image do not exactly match the canvas dimensions, this attribute specifies how to position the image on the background. This attribute has no effect on nested RVG objects.
canvas.background_image = Magick::Image.read('myBackground.gif').first
canvas.background_position = :scaled
    rvg.canvas -> image
After the draw method has been used, returns the rendered image. This is the same image that draw returns.
An image
rvg.desc -> string
    rvg.desc = string
desc attribute to
    assign a text description to the drawing. The description will
    be assigned to the "desc" property of the resulting image. This
    attribute has no effect on nested RVG objects.
  rvg.height -> height
rvg.metadata -> string
    rvg.metadata = string
metadata attribute to
    assign additional metadata to the drawing. The metadata string
    will be assigned to the "metadata" property of the resulting
    image. This attribute has no effect on nested RVG objects.
  rvg.title -> string
    rvg.title = string
title attribute to
    assign a title to the drawing. The title will be assigned to
    the "title" property of the resulting image. This attribute has
    no effect on nested RVG objects.
  rvg.width -> width
rvg.x -> x-offset
If this RVG object is nested within another RVG object, returns the x-offset in user coordinates from the upper-left corner of the enclosing RVG object.
rvg.y -> y-offset
If this RVG object is nested within another RVG object, returns the y-offset in user coordinates from the upper-left corner of the enclosing RVG object.
rvg.draw -> image
Causes all the drawing objects that have been added to the canvas to be rendered.
Regardless of the order in which methods were called,
    draw executes the methods in this order:
viewbox and
      preserve_aspect_ratioNested groups and RVG objects also follow this sequence.
An image
      img = rvg.draw
      img.write('myDrawing.jpg')
  rvg.g [{|grp| ...}] -> group
Calls RVG::Group.new to construct a group and adds it to the enclosing RVG object. Yields to a block if one is present, passing the new group as an argument.
Returns the new group, so RVG::Group methods
    can be chained to this method.
rvg.image(raster_image, width=nil, height=nil, x=0, y=0) -> image
Calls RVG::Image.new to construct an image and adds it to the enclosing RVG object.
Returns the new image, so RVG::Image methods
    can be chained to this method.
An RVG::Image object is not the same
    as a Magick::Image object!
rvg.preserve_aspect_ratio(align, meet_or_slice='meet') [{|self| ...}] -> self
If you use the viewbox method and
    the user coordinate system does not scale uniformly to the
    default coordinate system (for example, the width and height of
    the RVG object is 4x3 and the user coordinate system is 16x9),
    use the preserve_aspect_ratio method to specify
    whether or not the content is stretched to fit. If not, you can
    specify how to fit the content into the space.
Preserve_aspect_ratio yields to a block if one
    is present, passing self as an
    argument.
meet_or_slice argument
        is 'meet' or 'slice', this argument controls the placement
        of the content within the viewport. The align
        argument is the concatenation of an x-alignment and
        a y-alignment. The values are shown in these
        lists:
        Self, so other RVG
    methods can be chained to this method.
rvg.rvg(width, height, x=0, y=0) [{|new_rvg| ...}] -> self
This method constructs a new RVG object and adds it to the
    enclosing RVG object. Each nested RVG object can use the
    viewbox method to define its own
    coordinate system. The rvg method yields to a
    block, passing the nested RVG object as an argument. Within the
    block, any drawing objects added to the nested RVG object are
    rendered within the nested RVG object's viewport.
See the example for preserve_aspect_ratio.
The RVG object, so other RVG
    methods can be chained to this method.
rvg.text(x=0, y=0, text=nil) [{|text| ...}] -> text
Calls RVG::Text.new to construct a text object and adds it to the enclosing RVG object. Yields to a block if one is present, passing the new text object as an argument.
The RVG::Text object, so other
    RVG::Text methods can be chained to this
    method.
rvg.use(obj, x=0, y=0, width=nil, height=nil) -> use
Calls RVG::Use.new to
    construct a use object and adds it to the RVG
    object.
When the referenced argument is another RVG object,
    width and height can be used to specify the width and height
    of the viewport. If present and non-nil, these arguments
    override any width and height specified when the RVG object was
    created. You must specify the viewport size either when
    creating the RVG object or when referencing it with
    use.
See RVG::Use.new
The RVG::Use object, so other
    RVG::Use methods can be chained to this
    method.
rvg.viewbox(min_x, min_y, width, height) [{|self| ...}] -> self
The area of the RVG object is called the viewport.
    By default the origin of the coordinate system for an RVG
    object is (0,0). The user coordinates are pixels and the width
    and height are established by the width and height
    arguments to RVG.new.
Use the viewbox method to superimpose a user
    coordinate system on the viewport. The viewbox
    method lets you set up a coordinate system using the units of
    your choice.
The viewbox method yields to a block if one is
    present, passing self as an argument.
In the following examples, because the viewbox
    method specifies the dimensions of the coordinate system, the
    dimensions specified for the graphic objects can remain the
    same while the size of the canvas changes.
Rendered into a 300x200 viewport
Rendered into a 150x200 viewport
Self, so other RVG
    methods may be chained to viewbox.
RVG supports a subset of the unit identifiers defined by the SVG specification. In RVG, unit identifiers are methods in the Float and Integer classes. The units are (for the most part) defined in terms of "dots per inch," accordingly, the unit identifier methods are added only if the value
    Magick::RVG.dpi = NN
    is defined, where NN is the number of "dots" (pixels) per inch you wish to use. (Hint: 90 is a good default.)
For example, to specify a length of 10 inches, you can use
    Magick::RVG.dpi = 90
    length = 10.in  # => 900 pixels
    If the dpi is defined, the following methods are added to
    Float and Integer
SVG also supports em and ex, which are measurements based on the font size. RVG does not.