rmagick4j 0.3.5

data/lib/rvg/transformable.rb

@@ -0,0 +1,133 @@
+#--
+# $Id: transformable.rb,v 1.4 2008/02/24 18:26:37 rmagick Exp $
+# Copyright (C) 2008 Timothy P. Hunter
+#++
+
+module Magick
+    class RVG
+
+        # Transforms is an Array with a deep_copy method.
+        # During unit-testing it also has a deep_equal method.
+        class Transforms < Array        #:nodoc:
+
+            def deep_copy(h=nil)
+                copy = self.class.new
+                each { |transform| copy << [transform[0], transform[1].dup] }
+                return copy
+            end
+
+        end     # class Transform
+
+        # Transformations are operations on the coordinate system.
+        # All the transformations defined within a container (an RVG object
+        # or a group) are applied before drawing any shapes or text.
+        # All transformations are applied in the order they were
+        # defined. <em>Note:</em> This means that
+        #   g.translate(10,20).scale(2)
+        # is not the same as
+        #   g.scale(2).translate(10,20)
+        module Transformable
+
+          private
+
+            # Apply transforms in the same order they were specified!
+            def add_transform_primitives(gc)
+                @transforms.each { |transform| gc.__send__(transform[0], *transform[1]) }
+            end
+
+            def initialize(*args, &block)
+                super()
+                @transforms = Transforms.new
+            end
+
+          public
+
+            # Applies the transformation matrix [sx, rx, ry, sy, tx, ty]
+            def matrix(sx, rx, ry, sy, tx, ty)
+                begin
+                    @transforms << [:affine, [Float(sx), Float(rx), Float(ry), Float(sy), Float(tx), Float(ty)]]
+                rescue ArgumentError
+                    raise ArgumentError, "arguments must be convertable to float (got #{sx.class}, #{rx.class}, #{ry.class}, #{sy.class}, #{sx.class}, #{sx.class}, #{tx.class}, #{ty.class})"
+                end
+                yield(self) if block_given?
+                self
+            end
+
+            # Add <tt>tx</tt> to all x-coordinates and <tt>ty</tt>
+            # to all y-coordinates. If <tt>ty</tt> is omitted it defaults
+            # to <tt>tx</tt>.
+            def translate(tx, ty=nil)
+                ty ||= tx
+                begin
+                    @transforms << [:translate, [Float(tx), Float(ty)]]
+                rescue ArgumentError
+                    raise ArgumentError, "arguments must be convertable to float (got #{tx.class}, #{ty.class})"
+                end
+                yield(self) if block_given?
+                self
+            end
+
+            # Multiply the x-coordinates by <tt>sx</tt> and the y-coordinates
+            # by <tt>sy</tt>. If <tt>sy</tt> is omitted it defaults to <tt>sx</tt>.
+            def scale(sx, sy=nil)
+                sy ||= sx
+                begin
+                    @transforms << [:scale, [Float(sx), Float(sy)]]
+                rescue ArgumentError
+                    raise ArgumentError, "arguments must be convertable to float (got #{sx.class}, #{sy.class})"
+                end
+                yield(self) if block_given?
+                self
+            end
+
+            # This method can take either of two argument lists:
+            # [rotate(angle)] rotate by <tt>angle</tt> degrees
+            # [rotate(angle, cx, cy)] rotate by <tt>angle</tt> degrees about
+            #                         the point [<tt>cx</tt>, <tt>cy</tt>].
+            def rotate(angle, *args)
+                begin
+                    case args.length
+                        when 0
+                            @transforms << [:rotate, [Float(angle)]]
+                        when 2
+                            cx, cy = Float(args[0]), Float(args[1])
+                            @transforms << [:translate, [cx, cy]]
+                            @transforms << [:rotate, [angle]]
+                            @transforms << [:translate, [-cx, -cy]]
+                        else
+                            raise ArgumentError, "wrong number of arguments (#{args.length} for 1 or 3)"
+                    end
+                rescue ArgumentError
+                    raise ArgumentError, "arguments must be convertable to float (got #{[angle, *args].collect {|a| a.class}.join(', ')})"
+                end
+                yield(self) if block_given?
+                self
+            end
+
+            # Skew the X-axis by <tt>angle</tt> degrees.
+            def skewX(angle)
+                begin
+                    @transforms << [:skewx, [Float(angle)]]
+                rescue ArgumentError
+                    raise ArgumentError, "argument must be convertable to float (got #{angle.class})"
+                end
+                yield(self) if block_given?
+                self
+            end
+
+            # Skew the Y-axis by <tt>angle</tt> degrees.
+            def skewY(angle)
+                begin
+                    @transforms << [:skewy, [Float(angle)]]
+                rescue ArgumentError
+                    raise ArgumentError, "argument must be convertable to float (got #{angle.class})"
+                end
+                yield(self) if block_given?
+                self
+            end
+
+        end     # module Transformable
+
+    end # class RVG
+end # module Magick
+

data/lib/rvg/units.rb

@@ -0,0 +1,66 @@
+# $Id: units.rb,v 1.4 2008/02/24 18:26:37 rmagick Exp $
+# Copyright (C) 2008 Timothy P. Hunter
+module Magick
+    class RVG
+
+        # Define RVG.dpi and RVG.dpi=. Add conversions to Fixnum and Float classes
+        class << self
+            attr_reader :dpi
+            def dpi=(n)
+                if !defined?(@dpi)
+                    [Float, Fixnum].each do |c|
+                        c.class_eval <<-END_DEFS
+                            # the default measurement - 1px is 1 pixel
+                            def px
+                                self
+                            end
+                            # inches
+                            def in
+                                self * ::Magick::RVG.dpi
+                            end
+                            # millimeters
+                            def mm
+                                self * ::Magick::RVG.dpi / 25.4
+                            end
+                            # centimeters
+                            def cm
+                                self * ::Magick::RVG.dpi / 2.54
+                            end
+                            # points
+                            def pt
+                                self * ::Magick::RVG.dpi / 72.0
+                            end
+                            # picas
+                            def pc
+                                self * ::Magick::RVG.dpi / 6.0
+                            end
+                            # percentage of the argument
+                            def pct(of)
+                                self * Float(of) / 100.0
+                            end
+                            # the default is deg
+                            def deg
+                                self
+                            end
+                            # radians -> degrees
+                            def rad
+                                self * 180.0 / Math::PI
+                            end
+                            # grads -> degrees
+                            def grad
+                                self * 9.0 / 10.0
+                            end
+                        END_DEFS
+                    end
+                end
+
+                @dpi = Float(n)
+                return @dpi
+            rescue ArgumentError
+                raise TypeError, "Can't convert `#{n}' to Float"
+            end
+        end     # class << self
+
+    end # class RVG
+end # module Magick
+

data/test/RMagickTestSuite.rb

@@ -0,0 +1,129 @@
+puts Time.new
+begin
+  require 'rubygems'
+  gem PLATFORM == 'java' ? 'rmagick4j' : 'rmagick'
+rescue Exception
+  puts "No gems! #{$!}"
+end
+puts Time.new
+require 'RMagick'
+puts Time.new
+
+# TODO I know this isn't a real test, but it's what I've got for now.
+# TODO Probably eventually want to hook into RMagick's existing tests.
+
+def main
+  if ARGV.length > 0
+    ARGV.each {|arg| send(arg).display}
+  else
+    image = addTransparencyWithAMask.raise
+    # image = open_clown.blur_image(0, 5)
+    open(File.dirname(__FILE__) +'/test.jpg', 'w') do |file|
+      file.write(image.to_blob {self.format = 'JPEG'})
+    end
+  end
+  puts Time.new
+end
+
+def addRaisedEdges
+  open_clown.raise
+end
+
+def addText
+  clown = open_clown
+  text = Magick::Draw.new
+  text.annotate(clown, 0, 0, 0, 60, "My friend!") {
+    self.gravity = Magick::SouthGravity
+    self.pointsize = 48
+    self.stroke = 'transparent'
+    self.fill = '#0000A9'
+    self.font_weight = Magick::BoldWeight
+  }
+  clown.first
+end
+
+def addTransparencyWithAMask
+  clown = open_clown.first
+  mask = Magick::Image.new(clown.columns, clown.rows) {
+    self.background_color = 'black'
+  }
+  bg = Magick::Image.read("pattern:checkerboard") {
+    self.size = "#{clown.columns}x#{clown.rows}"
+  }
+  bg = bg.first
+
+  height = clown.rows * 0.8
+  width = clown.columns * 0.7
+  x = (clown.columns - width) / 2
+  y = (clown.rows - height) / 2
+
+  gc = Magick::Draw.new
+  gc.stroke('white').fill('white')
+  gc.roundrectangle(x, y, x+width, y+height, 24, 24)
+  gc.draw(mask)
+
+  mask = mask.blur_image(0, 20)
+
+  mask.matte = false
+  clown.matte = true
+
+  clown = clown.composite(mask, Magick::CenterGravity, Magick::CopyOpacityCompositeOp)
+  bg.composite(clown, Magick::CenterGravity, Magick::OverCompositeOp)
+end
+
+def addWatermark
+  mark = Magick::Image.new(300, 50) do
+    self.background_color = 'none'
+  end
+  gc = Magick::Draw.new
+  gc.annotate(mark, 0, 0, 0, 0, "Image by RMagick") do
+    self.gravity = Magick::CenterGravity
+    self.pointsize = 32
+    self.font_family = "Times"
+    self.fill = "white"
+    self.stroke = "none"
+  end
+  mark.rotate!(-90)
+  clown = open_clown.first
+  clown = clown.watermark(mark, 0.15, 0, Magick::EastGravity)
+  clown
+end
+
+def crop_resized
+  open_clown.crop_resized(50, 50)
+end
+
+def cropToANewSize
+  clown = open_clown
+  face = clown.crop(50, 15, 150, 165)
+  white_bg = Magick::Image.new(clown.columns, clown.rows)
+  white_bg.composite(face, 50, 15, Magick::OverCompositeOp)
+end
+
+def flipIt
+  open_clown.flip!
+end
+
+def makeAThumbnail
+  clown = open_clown
+  tiny = clown.resize(0.25)
+  white_bg = Magick::Image.new(clown.columns, clown.rows)
+  white_bg.composite(tiny, Magick::CenterGravity, Magick::OverCompositeOp)
+end
+
+def open_clown
+  #Magick::ImageList.new("clown.jpg")
+  open(File.dirname(__FILE__) + "/clown.jpg") {|file| Magick::ImageList.new.from_blob(file.read)}
+end
+
+def rotateToAnyAngle
+  clown = open_clown
+  clown.rotate(130)
+end
+
+def turnItIntoBlackAndWhite
+  clown = Magick::ImageList.new("clown.jpg")
+  clown.quantize(256, Magick::GRAYColorspace)
+end
+
+main

data/test/eyetests/bullseye.rb

@@ -0,0 +1,150 @@
+TEST_ROOT = File.expand_path(File.dirname(__FILE__))
+
+require 'java'
+require 'rubygems'
+
+#require 'RMagick'
+require 'profligacy/swing'
+require 'profligacy/lel'
+require  TEST_ROOT + '/tests/new_image.rb'
+require 'tmpdir'
+Kernel.srand(Time.now.to_i)
+OUTPUT_DIR = File.join(Dir.tmpdir,Kernel.rand(100).to_s)
+Dir.mkdir(OUTPUT_DIR)
+
+module Bullseye
+  include Profligacy
+  
+  DefaultListModel = javax.swing.DefaultListModel
+  ImageIO = javax.imageio.ImageIO
+  JButton = javax.swing.JButton
+  JFile = java.io.File
+  JFrame = javax.swing.JFrame
+  JLabel = javax.swing.JLabel
+  JList = javax.swing.JList
+  JPanel = javax.swing.JPanel
+  JScrollPane = javax.swing.JScrollPane
+  JTextField = javax.swing.JTextField
+  
+  class ImagePanel < JPanel
+    attr_accessor :image_1, :image_2
+    
+    def paint(graphics)
+      
+      unless image_1.nil?
+        begin
+          pic = load_image(image_1)
+          graphics.drawImage(pic, 0, 0, nil)
+        rescue
+          pic = Magick::Image.new(300, 300)
+          pic.background_color = 'red'
+          pic.erase!
+          graphics.drawImage(pic._image.getImage, 0, 0, nil)
+        end
+      end
+      
+      unless image_2.nil?
+        begin
+          pic = load_image(image_2)
+          graphics.drawImage(pic, 310, 0, nil)
+        rescue
+          pic = Magick::Image.new(300, 300)
+          pic.background_color = 'red'
+          pic.erase!
+          graphics.drawImage(pic._image.getImage, 310, 0, nil)
+        end
+      end
+    end
+
+    def load_image(filename)
+      file = JFile.new(filename)
+      raise ArgumentError.new("File #{filename} does not exist") unless file.exists
+      ImageIO.read(file)
+    end
+  end
+  
+  class ScriptRunner < Struct.new(:picture_panel, :source)
+    def initialize(picture_panel, source)
+      super(picture_panel, source)
+      @running = false
+    end
+    
+    def run_script
+      @running = true
+      script_name = source.selected_value.downcase.gsub(' ','_')
+      selected_script = File.join(TEST_ROOT, 'tests', script_name + '.rb')
+      NOTIFIER.notify 'Running script in MRI.'
+      output_commands = `sh -c 'ruby #{selected_script} #{OUTPUT_DIR}'`
+      NOTIFIER.notify 'Running in JRuby.'
+      output_commands += `jruby #{selected_script} #{OUTPUT_DIR}`
+      if output_commands == ''
+        NOTIFIER.notify 'Done'
+        picture_panel.image_1 = File.join(OUTPUT_DIR, script_name + '.jruby.jpg')
+        picture_panel.image_2 = File.join(OUTPUT_DIR, script_name + '.mri.jpg')
+        picture_panel.repaint
+      else
+        puts output_commands
+        NOTIFIER.notify 'Error'
+      end
+      @running = false
+    end
+  end
+  
+  class Notifier < Struct.new(:output)
+    def notify(string)
+      output.text = string.to_s
+    end
+  end
+  
+  class ScriptList < JList
+    def initialize
+      @default_model = DefaultListModel.new
+      super(@default_model)
+      load_test_scripts
+      self.setSelectedIndex(0)
+    end
+   
+    def load_test_scripts
+      Dir[File.dirname(__FILE__) + '/tests/*.rb'].each do |script|
+        script = script.gsub(/(^.*tests\/|.rb$)/,'').split('_').map{|x| x.capitalize}.join(' ')
+        @default_model.addElement(script) unless script == 'New Image'
+      end
+    end
+  end
+  
+  def self.scrollable(component)
+    JScrollPane.new component, 
+       JScrollPane::VERTICAL_SCROLLBAR_AS_NEEDED, 
+       JScrollPane::HORIZONTAL_SCROLLBAR_NEVER
+  end
+  
+  lel = '[ <label_results       | <label_scripts   ]
+         [ (610,300)image_panel | <scripts_list    ]
+         [ >status              | >run_button      ]'
+
+  ui = Swing::LEL.new(JFrame, lel) do |c, i|
+    c.label_scripts = JLabel.new('Scripts')
+    c.scripts_list = scrollable(scripts = ScriptList.new)
+    c.run_button = JButton.new('Run')
+    c.label_results = JLabel.new('Results')
+    c.image_panel = ImagePanel.new
+    c.status = JLabel.new ""
+
+    Bullseye::NOTIFIER = Notifier.new(c.status)
+    script_runner = ScriptRunner.new(c.image_panel, scripts)
+    run_script = proc {
+        scripts.enabled = c.run_button.enabled = false
+        Thread.new do
+          NOTIFIER.notify 'Running scripts...'
+          script_runner.run_script
+          scripts.enabled = c.run_button.enabled = true
+        end
+    }
+
+    scripts.addMouseListener { |event| run_script.call if event.click_count == 2 }
+    i.run_button = {:action => proc { |t,e| run_script.call } }
+  end.build :args => 'Bullseye'
+   
+  ui.default_close_operation = JFrame::EXIT_ON_CLOSE
+
+end