painter 0.0.4

data/lib/painter.rb

@@ -0,0 +1,133 @@
+require 'ffi'
+require 'painter/image_struct'
+require 'painter/stdio'
+require 'painter/cgd2'
+require 'painter/operation'
+require 'painter/image'
+require 'painter/font'
+require 'painter/canvas'
+require 'painter/color'
+require 'painter/rect'
+require 'painter/pixel'
+require 'painter/text'
+require 'painter/point'
+require 'painter/line'
+
+class Painter
+  attr_reader :image_pointer
+
+  def self.write(path, x, y, file_format)
+    instance = new
+    instance.initializeFromCreate(x,y)
+    yield instance
+    File.open(path, 'w') do |f|
+      instance.format(file_format) do |data|
+        f.write data
+      end
+    end
+  ensure
+    instance.release!
+  end
+
+  def self.open(path, format = nil)
+    instance = new
+    instance.initializeFromOpen(path, format)
+    yield instance
+  ensure
+    instance.release!
+  end
+
+  def release!
+    CGD2::gdImageDestroy(@image_pointer)
+  end
+
+  def degrees(n)
+    n * 2 * Math::PI / 360
+  end
+
+  ALPHA_MAX         = 127
+  ALPHA_OPAQUE      =   0
+  ALPHA_TRANSPARENT = 127
+  RGB_MAX           = 255
+
+  def release(ptr)
+    CGD2::gdImageDestroy(ptr)
+  end
+
+  def initializeFromCreate(x, y, options = {})
+    @image_pointer = FFI::Pointer.new(CGD2::gdImageCreateTrueColor(x, y))
+  end
+
+
+  FORMAT_TO_FUNCTION = {
+    'jpg' => :gdImageCreateFromJpeg,
+    'png'  => :gdImageCreateFromPng,
+    'gif'  => :gdImageCreateFromGif,
+    'gd'   => :gdImageCreateFromGd,
+    'gd2'  => :gdImageCreateFromGd2,
+    'wbmp' => :gdImageCreateFromWBMP,
+    'xbm'  => :gdImageCreateFromXbm
+  }
+
+  def format_from_filename(path)
+    path[/\.([^.]*)$/, 1].downcase
+  end
+
+  def initializeFromOpen(path, format = nil)
+    f = Painter::Stdio.fopen(path, "rb")
+    format ||= format_from_filename(path)
+    function_name = FORMAT_TO_FUNCTION[format.to_s]
+    raise "Unknown format: #{format}" unless function_name
+    @image_pointer = CGD2.send(function_name, f)
+    Painter::Stdio.fclose(f)
+  end
+
+  def info
+    @info ||= Painter::ImageStruct.new @image_pointer
+  end
+
+  # Operations
+  {'pixel' => 'Pixel', 'rect' => 'Rect', 'text' => 'Text', 'line' => 'Line'}.each do |op, klass|
+    class_eval <<-END
+      def #{op}
+        #{op}_instance = #{klass}.new(self)
+        yield #{op}_instance
+        #{op}_instance.draw
+      end
+    END
+  end
+
+  def resize_to(destination)
+    CGD2::gdImageCopyResampled(destination.image_pointer, self.image_pointer,
+      0, 0, 0, 0,
+      destination.info.x, destination.info.y, self.info.x, self.info.y)
+  end
+
+  OUTPUT_FORMAT_TO_FUNCTION = {
+    'gif'  => :gdImageGifPtr,
+    'jpeg' => :gdImageJpegPtr,
+    'jpg'  => :gdImageJpegPtr,
+    'png'  => :gdImagePngPtr,
+    'wbmp' => :gdImageWBMPPtr,
+    'gd'   => :gdImageGdPtr,
+    'gd2'  => :gdImageGd2
+  }
+  def format(file_format, quality = 100)
+    size = FFI::MemoryPointer.new(:pointer)
+    function_name = OUTPUT_FORMAT_TO_FUNCTION[file_format.to_s]
+    raise "Unknown format: #{file_format}" unless function_name
+    args = [@image_pointer, size]
+    if function_name == :gdImageJpegPtr
+      args << quality
+    end
+    begin
+      ip = CGD2.send(function_name, *args)
+      size = size.get_int(0)
+      data = ip.get_bytes(0, size)
+      yield data
+    ensure
+      CGD2::gdFree(ip)
+    end
+  end
+
+end

data/lib/painter/cgd2.rb

@@ -0,0 +1,43 @@
+class Painter
+  module CGD2
+    extend FFI::Library
+    local_path = ["/opt/local/lib/libgd.2.dylib", '/usr/lib/libgd.so.2'].detect do |lib|
+      File.exists?(lib)
+    end
+    ffi_lib local_path
+  
+    # BGD_DECLARE(gdImagePtr) gdImageCreate (int sx, int sy)
+    attach_function :gdImageCreate, [:int, :int], :pointer
+    attach_function :gdImageCreateTrueColor, [:int, :int], :pointer
+  
+    # void gdImageFilledRectangle(gdImagePtr im, int x1, int y1, int x2, int y2, int color) (FUNCTION)
+    attach_function :gdImageFilledRectangle, [:pointer, :int, :int, :int, :int, :int], :void
+
+    attach_function :gdImageSetPixel, [:pointer, :int, :int, :int], :void
+    attach_function :gdImageLine, [:pointer, :int, :int, :int, :int, :int], :void
+
+    #char *gdImageStringFT(gdImagePtr im, int *brect, int fg, char *fontname, double ptsize, double angle, int x, int y, char *string) (FUNCTION)
+    attach_function :gdImageStringFT, [:pointer, :pointer, :int, :string, :double, :double, :int, :int, :string], :pointer
+  
+    # void* gdImagePngPtr(gdImagePtr im, int *size) (FUNCTION)
+    [:gdImageGifPtr, :gdImagePngPtr, :gdImageWBMPPtr,
+    :gdImageGdPtr, :gdImageGd2].each do |format_function|
+      attach_function format_function, [:pointer, :pointer], :pointer
+    end
+
+    attach_function :gdImageJpegPtr, [:pointer, :pointer, :int], :pointer
+
+    [:gdImageCreateFromJpeg, :gdImageCreateFromPng, :gdImageCreateFromGif,
+      :gdImageCreateFromGd, :gdImageCreateFromGd2, :gdImageCreateFromWBMP,
+      :gdImageCreateFromXbm].each do |format_function|
+        attach_function format_function, [:pointer], :pointer
+    end
+
+    #Resizing
+    attach_function :gdImageCopyResampled, [:pointer, :pointer, :int, :int, :int, :int, :int, :int, :int, :int], :void
+
+    # gdImageDestroy(gdImagePtr im) (FUNCTION)
+    attach_function :gdImageDestroy, [:pointer], :void
+    attach_function :gdFree, [:pointer], :void
+  end
+end

data/lib/painter/color.rb

@@ -0,0 +1,110 @@
+class Painter
+  class Color
+    attr_reader :rgba
+    alias :to_i :rgba
+    class << self
+      alias [] new
+    end
+    
+    def initialize(r, g, b, a = ALPHA_OPAQUE)
+      r = self.class.normalize(r, RGB_MAX, :red)
+      g = self.class.normalize(g, RGB_MAX, :green)
+      b = self.class.normalize(b, RGB_MAX, :blue)
+      a = self.class.normalize(a, ALPHA_MAX, :alpha)
+
+      init_with_rgba(self.class.pack(r, g, b, a))
+    end
+    
+    def init_with_rgba(rgba, index = nil, palette = nil)  #:nodoc:
+      @rgba = rgba
+      @index = index
+      @palette = palette
+      self
+    end
+    
+    def self.pack(r, g, b, a)   #:nodoc:
+      (a << 24) + (r << 16) + (g << 8) + b
+    end
+    
+    def to_s
+      s  = 'RGB'
+      s += "A" if alpha != ALPHA_OPAQUE
+      s += "[#{@index}]" if @index
+      s += '#' + [red, green, blue].map { |e| '%02X' % e }.join('')
+      s += '%02X' % alpha if alpha != ALPHA_OPAQUE
+      s
+    end
+    
+    
+    def self.normalize(value, max, component = nil)   #:nodoc:
+      case value
+      when Integer
+        (value < 0) ? 0 : (value > max) ? max : value
+      when Float
+        normalize((value * max).round, max, component)
+      when Color
+        value.send(component)
+      else
+        return normalize(value.to_i, max) if value.respond_to?(:to_i)
+        raise TypeError
+      end
+    end
+    # Return the red component of this color (0..RGB_MAX).
+    def red
+      (rgba & 0xFF0000) >> 16
+    end
+    alias r red
+
+    # Modify the red component of this color. If this color is associated
+    # with a palette entry, this also modifies the palette.
+    #def red=(value)
+    #  self.rgba = (rgba & ~0xFF0000) |
+    #    (self.class.normalize(value, RGB_MAX, :red) << 16)
+    #end
+    #alias r= red=
+
+    # Return the green component of this color (0..RGB_MAX).
+    def green
+      (rgba & 0x00FF00) >> 8
+    end
+    alias g green
+
+    # Modify the green component of this color. If this color is associated
+    # with a palette entry, this also modifies the palette.
+    #def green=(value)
+    #  self.rgba = (rgba & ~0x00FF00) |
+    #    (self.class.normalize(value, RGB_MAX, :green) << 8)
+    #end
+    #alias g= green=
+
+    # Return the blue component of this color (0..RGB_MAX).
+    def blue
+      rgba & 0x0000FF
+    end
+    alias b blue
+
+    # Modify the blue component of this color. If this color is associated
+    # with a palette entry, this also modifies the palette.
+    #def blue=(value)
+    #  self.rgba = (rgba & ~0x0000FF) |
+    #    self.class.normalize(value, RGB_MAX, :blue)
+    #end
+    #alias b= blue=
+
+    # Return the alpha component of this color (0..ALPHA_MAX).
+    def alpha
+      (rgba & 0x7F000000) >> 24
+    end
+    alias a alpha
+
+    # Modify the alpha component of this color. If this color is associated
+    # with a palette entry, this also modifies the palette.
+    def alpha=(value)
+      self.rgba = (rgba & ~0xFF000000) |
+        (self.class.normalize(value, ALPHA_MAX, :alpha) << 24)
+    end
+    alias a= alpha=
+    
+    
+  end
+end

data/lib/painter/image_struct.rb

@@ -0,0 +1,35 @@
+class Painter
+  class ImageStruct < FFI::Struct
+    MAXCOLORS = 256
+    layout :pixels,  :pointer,
+           :sx,  :int,
+           :sy, :int,
+           :colorsTotal, :int,
+           :red, [:int, MAXCOLORS],
+           :green, [:int, MAXCOLORS],
+           :blue, [:int, MAXCOLORS],
+           :open, [:int, MAXCOLORS],
+           :transparent, :int,
+           :polyInts, :pointer,
+           :polyAllocated, :int,
+           :brush, :pointer,
+           :tile, :pointer,
+           :brushColorMap, [:int, MAXCOLORS],
+           :tileColorMap, [:int, MAXCOLORS],
+           :styleLength, :int,
+           :stylePos, :int,
+           :style, :pointer,
+           :interlace, :int,
+           :alpha, [:int, MAXCOLORS],
+           :trueColor, :int,
+           :tpixels, :pointer,
+           :alphaBlendingFlag, :int,
+           :saveAlphaFlag, :int
+    def x
+      self[:sx]
+    end
+    def y
+      self[:sy]
+    end
+  end
+end

data/lib/painter/line.rb

@@ -0,0 +1,8 @@
+class Painter
+  class Line < Operation
+    def draw
+      ::Painter::CGD2::gdImageLine(@image.image_pointer,
+        @_from.x, @_from.y, @_to.x, @_to.y, _color.rgba)
+    end
+  end
+end

data/lib/painter/operation.rb

@@ -0,0 +1,45 @@
+class Painter
+  class Operation
+    def self.pretty_accessor(*names)
+      names.each do |n|
+        attr_reader n.to_sym
+        class_eval <<-END
+          def #{n}(v)
+            @_#{n} = v
+          end
+          def _#{n}
+            @_#{n}
+          end
+        END
+      end
+    end
+    def initialize(i)
+      @image = i
+    end
+
+    pretty_accessor :at
+
+    %w[at from to].each do |point|
+      class_eval <<-END
+        def #{point}(x,y)
+          @_#{point} = Point.new(x,y)
+        end
+      END
+    end
+
+    def angle(n)
+      @_angle = (n * Math::PI / 180.0)
+    end
+
+    def _angle
+      @_angle || 0
+    end
+    
+    def color(r,g,b,a = nil)
+      @_color = Painter::Color.new(r,g,b,a)
+    end
+    def _color
+      @_color || Painter::Color.new(1, 1, 1)
+    end
+  end
+end

data/lib/painter/pixel.rb

@@ -0,0 +1,8 @@
+class Painter
+  class Pixel < Operation
+    def draw
+      ::Painter::CGD2::gdImageSetPixel(@image.image_pointer,
+        @_at.x, @_at.y, _color.rgba)
+    end
+  end
+end

data/lib/painter/point.rb

@@ -0,0 +1,4 @@
+class Painter
+  class Point < Struct.new(:x,:y)
+  end
+end

data/lib/painter/rect.rb

@@ -0,0 +1,19 @@
+class Painter
+  class Rect < Operation
+    pretty_accessor :bottomX, :bottomY
+
+    def topLeft(x,y)
+      @_topLeft = Point.new(x,y)
+    end
+
+    def bottomRight(x,y)
+      @_bottomRight = Point.new(x,y)
+    end
+
+    def draw
+      ::Painter::CGD2::gdImageFilledRectangle(@image.image_pointer,
+        @_topLeft.x, @_topLeft.y,
+        @_bottomRight.x, @_bottomRight.y, _color.rgba)
+    end
+  end
+end

data/lib/painter/stdio.rb

@@ -0,0 +1,8 @@
+class Painter
+  module Stdio
+    extend FFI::Library
+    ffi_lib FFI::Library::LIBC
+    attach_function :fopen, [:string, :string], :pointer
+    attach_function :fclose, [:pointer], :int
+  end
+end

data/lib/painter/text.rb

@@ -0,0 +1,23 @@
+class Painter
+  class Text < Operation
+    class BlankFontError < StandardError
+    end
+    class MissingFontError < StandardError
+    end
+    pretty_accessor :font, :size, :text, :point
+
+    def draw
+      raise BlankFontError if _font.nil?
+      raise MissingFontError, _font unless File.exists?(_font)
+      brect = FFI::MemoryPointer.new(:int, 8)
+      error = CGD2::gdImageStringFT(@image.image_pointer, brect, _color.rgba, _font,
+        _size.to_f, _angle.to_f, _at.x, _at.y, _text.gsub('&', '&amp;'))
+      raise "Drawing error: #{error}" unless error.null?
+      brect = brect.read_array_of_int(8)
+      { :lower_left   => [brect[0], brect[1]],
+        :lower_right  => [brect[2], brect[3]],
+        :upper_right  => [brect[4], brect[5]],
+        :upper_left   => [brect[6], brect[7]]}
+    end
+  end
+end

data/spec/color_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe Painter::Color do
+  it "should initialize from int" do
+    Painter::Color.new(50,100,200).rgba.should eql(3302600)
+  end
+  
+  it "should initialize with []" do
+    Painter::Color[50,100,200].rgba.should eql(3302600)
+  end
+  
+  it "should have to_i" do
+    color = Painter::Color[50,100,200]
+    color.rgba.should eql(3302600)
+    color.to_i.should eql(color.rgba)
+  end
+  
+  [
+    [:red, 50],
+    [:green, 100],
+    [:blue, 200]
+  ].each do |color_name, value|
+    it "should return the #{color_name} value" do
+      color = Painter::Color[50,100,200]
+      color.send(color_name).should eql(value)
+    end
+    
+    it "should return color #{color_name} by first letter" do
+      color_name = color_name.to_s[0..0].to_sym
+      color = Painter::Color[50,100,200]
+      color.send(color_name).should eql(value)
+    end
+  end
+  
+  
+end

data/spec/image_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe Painter::Image::TrueColor do
+  it_should_behave_like "painter"
+
+  before do
+    Painter::CGD2.stub!(:gdFree)
+  end
+
+  it "should generate png string" do
+    image = Painter::Image::TrueColor.new(100, 100)
+    Painter::CGD2.should_receive(:gdImagePngPtr).and_return(mock("Pointer", :get_bytes => ''))    
+    image.png do |data|
+      data.size.should > 0
+    end
+  end
+
+  it "should read the image struct" do
+    Painter.open("#{File.dirname(__FILE__)}/fixtures/sample.jpg", :jpg) do |i|
+      i.info.x.should == 438
+    end
+  end
+
+end

data/spec/integration.rb

@@ -0,0 +1,52 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe 'integration' do
+  it "should draw an image" do
+    srand(Time.now.to_i)
+    Painter.write("#{File.dirname(__FILE__)}/output/captcha.png", 200, 100, :png) do |painter|
+      painter.rect do |rect|
+        rect.color 255, 255, 255
+        rect.topLeft 0, 0
+        rect.bottomRight 200, 100
+      end
+      painter.text do |text|
+        text.font "#{File.dirname(__FILE__)}/fixtures/Vera.ttf"
+        text.at 10, 50
+        text.text "Hello World"
+        text.angle rand(20)
+        text.size 14
+      end
+      offset = rand(10)
+      0.upto(300) do |i|
+        painter.pixel do |pixel|
+          pixel.at i, ((Math.sin((i + offset) / (4 * Math::PI)) * 30).to_i + 50)
+          pixel.color(rand(5), rand(5), rand(5))
+        end
+      end
+      painter.line do |line|
+        line.from 0, (25 + rand(50))
+        line.to 200, (25 + rand(50))
+        line.color rand(10), rand(10), rand(10)
+      end
+    end
+  end
+
+  it "should write to a variety of formats" do
+    [:jpg, :png, :wbmp, :gif].each do |format|
+      Painter.write("#{File.dirname(__FILE__)}/output/format.#{format}", 48, 48, format) do |output|
+        Painter.open("#{File.dirname(__FILE__)}/fixtures/sample.jpg", :jpg) do |source|
+          source.resize_to(output)
+        end
+      end
+    end
+  end
+
+  it "should resize images" do
+    Painter.write("#{File.dirname(__FILE__)}/output/resized.png", 48, 48, :png) do |output|
+      Painter.open("#{File.dirname(__FILE__)}/fixtures/sample.jpg", :jpg) do |source|
+        source.resize_to(output)
+      end
+    end
+  end
+
+end

data/spec/rect_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe "rect" do
+  it_should_behave_like "painter"
+  before(:each) do
+    @painter = Painter.new
+    @painter.initializeFromCreate(640, 480)
+  end
+
+  it "should call GD draw function" do
+    Painter::CGD2.should_receive(:gdImageFilledRectangle).with(@painter.image_pointer, 0, 0, 10, 10, @white.rgba)
+    @painter.rect do |rect|
+      rect.topLeft 0, 0
+      rect.bottomRight 10, 10
+    end
+  end
+
+  it "should convert Color to int" do
+    Painter::CGD2.should_receive(:gdImageFilledRectangle).with(@painter.image_pointer, 0, 0, 10, 10, @black.rgba)
+    @painter.rect do |rect|
+      rect.color 0, 0, 0
+      rect.topLeft 0, 0
+      rect.bottomRight 10, 10
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'rbconfig'
+require 'spec'
+
+$: << 'lib'
+require 'painter'
+describe "painter", :shared => true do
+  before(:each) do
+    @white = Painter::Color.new(1, 1, 1)
+    @black = Painter::Color.new(0, 0, 0)
+  end
+end

data/spec/text_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe "text" do
+  it_should_behave_like "painter"
+  before(:each) do
+    @painter = Painter.new
+    @painter.initializeFromCreate(640, 480)
+  end
+  
+  it "should call C function on draw" do      
+    Painter::CGD2.should_receive(:gdImageStringFT).
+      with(@painter.image_pointer, anything, @black.rgba, "#{File.dirname(__FILE__)}/fixtures/Vera.ttf", 14.0, 0.0, 100, 50, "Hello World").
+      and_return(mock("Pointer", :null? => true))
+    @painter.text do |text|
+      text.color 0, 0, 0
+      text.font "#{File.dirname(__FILE__)}/fixtures/Vera.ttf"
+      text.at 100, 50
+      text.text "Hello World"
+      text.angle 0
+      text.size 14
+    end
+  end
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification 
+name: painter
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 4
+  version: 0.0.4
+platform: ruby
+authors: 
+- Ben Sandofsky
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-20 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ffi
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: A clean wrapper around the GD2 graphics library, based on gd2-ffi
+email: sandofsky@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/painter/cgd2.rb
+- lib/painter/color.rb
+- lib/painter/image_struct.rb
+- lib/painter/line.rb
+- lib/painter/operation.rb
+- lib/painter/pixel.rb
+- lib/painter/point.rb
+- lib/painter/rect.rb
+- lib/painter/stdio.rb
+- lib/painter/text.rb
+- lib/painter.rb
+- spec/color_spec.rb
+- spec/fixtures/sample.jpg
+- spec/fixtures/Vera.ttf
+- spec/image_spec.rb
+- spec/integration.rb
+- spec/output/captcha.png
+- spec/output/format.gif
+- spec/output/format.jpg
+- spec/output/format.png
+- spec/output/format.wbmp
+- spec/output/resized.png
+- spec/rect_spec.rb
+- spec/spec_helper.rb
+- spec/text_spec.rb
+- README
+- Rakefile
+has_rdoc: true
+homepage: http://github.com/sandofsky/painter
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A clean wrapper around the GD2 graphics library, based on gd2-ffi
+test_files: 
+- spec/color_spec.rb
+- spec/image_spec.rb
+- spec/image_spec.rb
+- spec/rect_spec.rb
+- spec/text_spec.rb
+- spec/spec_helper.rb