rmagick 1.7.4 → 1.8.0

data/lib/RMagick.rb

@@ -1,6 +1,6 @@
-# $Id: RMagick.rb,v 1.22 2004/10/06 22:23:49 rmagick Exp $
+# $Id: RMagick.rb,v 1.23 2005/03/05 16:19:10 rmagick Exp $
 #==============================================================================
-#                  Copyright (C) 2004 by Timothy P. Hunter
+#                  Copyright (C) 2005 by Timothy P. Hunter
 #   Name:       RMagick.rb
 #   Author:     Tim Hunter
 #   Purpose:    Extend Ruby to interface with ImageMagick.

data/lib/rvg/clippath.rb

@@ -0,0 +1,46 @@
+#--
+# $Id: clippath.rb,v 1.1 2005/03/12 17:02:00 rmagick Exp $
+# Copyright (C) 2005 Timothy P. Hunter
+#++
+class Magick::RVG
+
+    class ClipPath
+        include ShapeConstructors
+        include UseConstructors
+        include TextConstructors
+        include Describable
+        include Stylable
+        include Duplicatable
+
+        # Create a clipping path. Within the block create an outline
+        # from one or more paths, basic shapes, text objects, or +use+.
+        # Everything drawn within the outline will be displayed.
+        # Anything drawn outside the outline will not.
+        #
+        # If the clipping path contains a +use+, it
+        # must directly reference path, basic shape, or text objects.
+        #
+        # Attach the clipping path to an object with the :clip_path style.
+        def initialize(clip_path_units='userSpaceOnUse')
+            super()
+            if ! ['userSpaceOnUse', 'objectBoundingBox'].include?(clip_path_units)
+                raise ArgumentError, "undefined value for clip path units: #{clip_path_units}"
+            end
+            @clip_path_units = clip_path_units
+            @content = Content.new
+            yield(self) if block_given?
+        end
+
+        def add_primitives(gc, style)   #:nodoc:
+            name = __id__.to_s
+            gc.define_clip_path(name) do
+                gc.clip_units(@clip_path_units)
+                @content.each { |element| element.add_primitives(gc) }
+            end
+            gc.clip_path(name)
+        end
+
+    end     # class ClipPath
+
+end     # class Magick::RVG
+

data/lib/rvg/container.rb

@@ -0,0 +1,129 @@
+#--
+# $Id: container.rb,v 1.1 2005/03/12 17:02:00 rmagick Exp $
+# Copyright (C) 2005 Timothy P. Hunter
+#++
+
+class Magick::RVG
+
+    # Content is simply an Array with a deep_copy method.
+    # When unit-testing, it also has a deep_equal method.
+    class Content < Array       #:nodoc:
+
+        def deep_copy(h = {})
+            me = self.__id__
+            copy = h[me]
+            unless copy
+                copy = self.class.new
+                each do |c|
+                    copy << case
+                        when c.nil?
+                            nil
+                        when c.respond_to?(:deep_copy)
+                            c.deep_copy(h)
+                        when c.respond_to?(:dup)
+                            c.dup rescue c
+                        else
+                            c
+                        end
+                end
+                copy.freeze if frozen?
+                h[me] = copy
+            end
+            return copy
+        end
+
+    end     # class Content
+
+    # Define a collection of shapes, text, etc. that can be reused.
+    # Group objects are _containers_. That is, styles and transforms defined
+    # on the group are used by contained objects such as shapes, text, and
+    # nested groups unless overridden by a nested container or the object itself.
+    # Groups can be reused with the RVG::UseConstructors#use method.
+    # Create groups within
+    # containers with the RVG::StructureConstructors#g method.
+    #
+    # Example:
+    #   # All elements in the group will be translated by 50 in the
+    #   # x-direction and 10 in the y-direction.
+    #   rvg.g.translate(50, 10).styles(:stroke=>'red',:fill=>'none') do |grp|
+    #       # The line will be red.
+    #       grp.line(10,10, 20,20)
+    #       # The circle will be blue.
+    #       grp.circle(10, 20, 20).styles(:stroke=>'blue')
+    #   end
+    class Group
+        include Stylable
+        include Transformable
+        include Embellishable
+        include Describable
+        include Duplicatable
+
+        def initialize
+            super
+            @content = Content.new
+            yield(self) if block_given?
+        end
+
+        def add_primitives(gc)          #:nodoc:
+            gc.push
+            add_transform_primitives(gc)
+            add_style_primitives(gc)
+            @content.each { |element| element.add_primitives(gc) }
+            gc.pop
+        end
+
+        # Translate container according to #use arguments
+        def ref(x, y, width, height)    #:nodoc:
+            translate(x, y) if (x != 0 || y != 0)
+        end
+
+        # Append an arbitrary object to the group's content. Called
+        # by #use to insert a non-container object into a group.
+        def <<(obj)                     #:nodoc:
+            @content << obj
+        end
+
+    end     # class Group
+
+
+    # A Use object allows the re-use of RVG and RVG::Group
+    # objects within a container. Create a Use object with the
+    # RVG::UseConstructors#use method.
+    class Use
+        include Stylable
+        include Transformable
+        include Duplicatable
+
+        # In a container, Use objects are created indirectly via the
+        # RVG::UseConstructors#use method.
+        # The +x+ and +y+ arguments
+        # can be used to specify an additional translation for
+        # the group. The +width+ and +height+ arguments specify
+        # a width and height for referenced RVG objects.
+        def initialize(element, x=0, y=0, width=nil, height=nil)
+            super()
+
+            # If the element is not a group, defs, symbol, or rvg,
+            # wrap a group around it so it can get a transform and
+            # possibly a new viewport.
+            if ! element.respond_to?(:ref)
+                @element = Group.new
+                @element << element.deep_copy
+            else
+                @element = element.deep_copy
+            end
+            @element.ref(x, y, width, height)
+        end
+
+        def add_primitives(gc)      #:nodoc:
+            gc.push
+            add_transform_primitives(gc)
+            add_style_primitives(gc)
+            @element.add_primitives(gc)
+            gc.pop
+        end
+
+    end     # class Use
+
+end     # class Magick::RVG
+

data/lib/rvg/deep_equal.rb

@@ -0,0 +1,54 @@
+class Magick::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
+                return 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 = self.instance_variables
+
+                ivs.each do |iv|
+                    itv = self.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
+                        if !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
+
+                return true
+            end
+        end
+    end
+
+end     # class Magick::RVG

data/lib/rvg/describable.rb

@@ -0,0 +1,51 @@
+#--
+# $Id: describable.rb,v 1.1 2005/03/12 17:02:00 rmagick Exp $
+# Copyright (C) 2005 Timothy P. Hunter
+#++
+
+class Magick::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
+
+      public
+
+        # 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 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 Magick::RVG
+

data/lib/rvg/embellishable.rb

@@ -0,0 +1,395 @@
+#--
+# $Id: embellishable.rb,v 1.3 2005/04/10 15:12:45 rmagick Exp $
+# Copyright (C) 2005 Timothy P. Hunter
+#++
+
+class Magick::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 = RVG.convert_to_float(r, cx, cy)
+            if r < 0
+                raise 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 = RVG.convert_to_float(rx, ry, cx, cy)
+            if rx < 0 || ry < 0
+                raise 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 = RVG.convert_to_float(width, height, x, y)
+            if width < 0 || height < 0
+                raise 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 = RVG.convert_to_float(rx, ry || rx)
+            if rx < 0 || ry < 0
+                raise ArgumentError, "rx, ry must be >= 0 (#{rx}, #{ry} given)"
+            end
+            @args << rx << ry
+            @primitive = :roundrectangle
+            self
+        end
+
+    end     # class Rect
+
+    class Polygon < Shape
+
+        # 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()
+            n = points.length
+            if n < 4 || n % 2 != 0
+                raise ArgumentError, "insufficient/odd number of points specified: #{n}"
+            end
+            @primitive = :polygon
+            @args = RVG.convert_to_float(*points)
+        end
+
+    end     # class Polygon
+
+    class Polyline < Shape
+
+        # 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()
+            n = points.length
+            if n < 4 || n % 2 != 0
+                raise ArgumentError, "insufficient/odd number of points specified: #{n}"
+            end
+            @primitive = :polyline
+            @args = 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
+            return [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 = RVG.convert_to_float(x, y, width || @image.columns, height || @image.rows)
+            if @width < 0 || @height < 0
+                raise 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
+            return 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
+            return 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
+            return line
+        end
+
+        # Draws a path defined by an SVG path string or a PathData
+        # object.
+        def path(path)
+            path = Path.new(path)
+            @content << path
+            return 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
+            return 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
+            return 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
+            return 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
+            return 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 = 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
+            return 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
+            return 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
+            return 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 Magick::RVG
+