rmagick4j 0.3.5

data/lib/rmagick4j/image_list.rb

@@ -0,0 +1,21 @@
+
+module Magick
+  
+  class ImageList < Array
+
+    def flatten_images
+      img = @images.map { |obj| obj._image }
+      
+      image = img.inject do |memo, obj|
+        memo.flatten(obj)
+      end
+      
+      Image.from_image(image)
+    end
+    
+    def to_blob(&add)
+      # TODO Support lists.
+      first.to_blob(&add)
+    end
+  end
+end

data/lib/rmagick4j/pixel.rb

@@ -0,0 +1,170 @@
+require 'observer'
+
+module Magick
+  Pixel = Magick4J::PixelPacket
+  
+  class Pixel
+    include Comparable
+    include Observable
+    
+    alias_method :to_java_color, :to_color
+    alias_method :to_color, :to_string
+
+    def type_check(value, conversion, typename)
+      unless value.respond_to? conversion
+        raise TypeError.new "can't convert #{value.class.name} into #{typename}" 
+      end
+      value.send(conversion)
+    end
+    
+    def initialize(red=0, green=0, blue=0, opacity=0)
+      # TODO: I think PixelPacket should be int-based (Pixel requires argument
+      # conversion, but PixelPacket requires us to reconvert to double (see
+      # to_f below).  This is a bunch of work.
+      red = type_check(red, :to_int, "Integer")
+      green = type_check(green, :to_int, "Integer")
+      blue = type_check(blue, :to_int, "Integer")
+      opacity = type_check(opacity, :to_int, "Integer")
+
+      # TODO: Add support to CMYKColorspace.
+      super(red, green, blue, opacity)
+    end
+    
+    def self.from_color(color_name)
+      result = Magick4J::ColorDatabase.lookUp(color_name)
+      raise ArgumentError, "invalid color name: #{color_name}" if result.nil?
+      result
+    end
+    
+    def self.from_HSL(array)
+      raise ArgumentError, 'array argument must have at least 3 elements' if array.size < 3
+      # It can't be 'hue, saturation, lightness = array' because array length
+      # can be greater than 3.
+      hue, saturation, lightness = array[0], array[1], array[2]
+      r, g, b = if saturation == 0
+                  3*[[[0, QuantumRange*lightness].max, QuantumRange].min.floor.to_i]
+                else
+                  m2 =  if lightness <= 0.5
+                          lightness*(saturation + 1.0)
+                        else
+                          lightness + saturation - (lightness*saturation)
+                        end
+                  m1 = 2.0*lightness - m2
+                  
+                  [
+                    [[0, QuantumRange*from_hue(m1, m2, hue+1.0/3.0)].max, QuantumRange].min.floor.to_i,
+                    [[0, QuantumRange*from_hue(m1, m2, hue)].max, QuantumRange].min.floor.to_i,
+                    [[0, QuantumRange*from_hue(m1, m2, hue-1.0/3.0)].max, QuantumRange].min.floor.to_i
+                  ]
+                end
+      Pixel.new(r, g, b)
+    end
+
+    def eql?(other)
+      (self <=> other) == 0
+    end
+    
+    def <=>(pixel)
+      # Alphabetical algorithm.
+      if red != pixel.red
+        red <=> pixel.red
+      elsif green != pixel.green
+        green <=> pixel.green
+      elsif blue == pixel.blue
+        blue <=> pixel.blue
+      elsif opacity != pixel.opacity
+        opacity <=> pixel.opacity
+      else
+# Enebo: I added as a last test in conditional (is this needed? test?)
+# Serabe: In fact, I don't know, but it is the way RMagick does it.
+        self.class <=> pixel.class
+      end
+    end
+    
+    alias_method :yellow, :blue
+    alias_method :yellow=, :blue=
+
+    # TODO: Hook colorspace into this method
+    # Extracted from color.c:1698
+    def fcmp(pixel, fuzz=0.0, colorspace=nil)
+      raise TypeError.new("wrong argument type #{pixel.class.name} (expected Data)") unless pixel.kind_of? Pixel
+      raise TypeError.new("") unless fuzz.kind_of? Numeric
+      if colorspace and !colorspace.kind_of? ::Magick::ColorspaceType
+        raise TypeError.new("Not a colorspace") 
+      end
+      
+      fuzz = 3.0*([fuzz.to_f, 0.7071067811865475244008443621048490].max**2)
+      
+      # TODO: How does matte affect this algorithm?
+      
+      distance = (red-pixel.red)**2
+      return false if distance > fuzz
+      distance += (green-pixel.green)**2
+      return false if distance > fuzz
+      distance += (blue-pixel.blue)**2
+      return false if distance > fuzz
+      true #The colors are similar!!!
+    end
+    
+    alias_method :magenta, :green
+    alias_method :magenta=, :green=
+    
+    # Thanks, FSM, for the RMagick documentation.
+    def intensity
+      0.299*red+0.587*green+0.114*blue
+    end
+    
+    alias_method :black, :opacity
+    alias_method :black=, :opacity=
+    
+    alias_method :cyan, :red
+    alias_method :cyan=, :red=
+    
+    # Extracted from gem.c:429
+    def to_HSL
+      r, g, b = QuantumScale*red, QuantumScale*green, QuantumScale*blue
+      max = [r, g, b].max
+      min = [r, g, b].min
+      lightness = (min+max)/2.0
+      delta = max - min
+      if(delta == 0.0)
+        hue, saturation = 0.0, 0.0
+      else
+        saturation =  if lightness <0.5
+                        delta /(min+max)
+                      else
+                        delta / (2.0-(min+max))
+                      end
+        hue = if r == max
+                calculate_hue(b, g, max, delta)
+              elsif g == max
+                (1.0/3.0) + calculate_hue(r, b, max, delta)
+              elsif b == max
+                (2.0/3.0)+calculate_hue(g, r, max, delta)
+              end
+        if hue < 0.0
+          hue += 1.0
+        elsif hue > 1.0
+          hue -= 1.0
+        end
+      end
+      [hue, saturation, lightness]
+    end
+    
+    private
+    
+    def calculate_hue(val1, val2, max, delta)
+      (( ((max-val1)/6.0)+ (delta/2.0))- (((max-val2)/6.0)+(delta/2.0)))/delta
+    end
+    
+    def from_hue(m1, m2, hue)
+      hue += 1.0 if hue < 0.0
+      hue -= 1.0 if hue > 1.0
+      
+      return m1+6.0*(m2-m1)*hue if (6.0*hue) < 1.0
+      return m2 if (2.0*hue) < 1.0
+      return m1+6.0*(m2-m1)*(2.0/3.0-hue) if (3.0*hue) < 2.0
+      m1
+    end
+  end
+end

data/lib/rmagick4j/rmagick4j.rb

@@ -0,0 +1,19 @@
+require 'java'
+
+rmagick4j_dir = File.dirname(__FILE__)
+
+# TODO See about using Raven to get gems of jhlabs and svgsalamander?
+require File.join(rmagick4j_dir, '..', 'jhlabs-filters.jar')
+require File.join(rmagick4j_dir, '..', 'magick4j.jar')
+require File.join(rmagick4j_dir, '..', 'svgsalamander.jar')
+
+#RMagick classes, keep in alphabetical order, please.
+require File.join(rmagick4j_dir, 'constants')
+require File.join(rmagick4j_dir, 'draw')
+require File.join(rmagick4j_dir, 'enum')
+require File.join(rmagick4j_dir, 'gradient_fill')
+require File.join(rmagick4j_dir, 'image')
+require File.join(rmagick4j_dir, 'image_list')
+require File.join(rmagick4j_dir, 'pixel')
+require File.join(rmagick4j_dir, 'texture_fill')
+require File.join(rmagick4j_dir, 'type_metric')

data/lib/rmagick4j/texture_fill.rb

@@ -0,0 +1,14 @@
+
+module Magick
+  class TextureFill
+    
+    def fill(image)
+      @fill.fill(image._image)
+    end
+    
+    def initialize(image)
+      image = image.cur_image if image.respond_to? :cur_image
+      @fill = Magick4J.TextureFill.new(image._image)
+    end
+  end
+end

data/lib/rmagick4j/type_metric.rb

@@ -0,0 +1,8 @@
+
+module Magick
+  class TypeMetric
+
+    attr_accessor :ascent, :descent, :height, :max_advance, :width
+
+  end
+end

data/lib/rmagick4j/version.rb

@@ -0,0 +1,5 @@
+module RMagick4J
+  module Version
+    VERSION = "0.3.5"
+  end
+end

data/lib/rvg/clippath.rb

@@ -0,0 +1,48 @@
+#--
+# $Id: clippath.rb,v 1.4 2008/02/24 18:26:36 rmagick Exp $
+# Copyright (C) 2008 Timothy P. Hunter
+#++
+module Magick
+    class 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 RVG
+end # module Magick
+

data/lib/rvg/container.rb

@@ -0,0 +1,131 @@
+#--
+# $Id: container.rb,v 1.4 2008/02/24 18:26:36 rmagick Exp $
+# Copyright (C) 2008 Timothy P. Hunter
+#++
+
+module Magick
+    class 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 RVG
+end # module Magick
+

data/lib/rvg/deep_equal.rb

@@ -0,0 +1,56 @@
+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
+                    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 RVG
+end # module Magick