corbanbrook-rcomposite 0.3.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Corban Brook
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,135 @@
+                                  
+                                  RComposite
+
+
+Class Summary:
+
+* Layers: There are 4 types of Layer Models,
+
+  * Layer: The base layer model. Can load an image from disk, blob,
+    or RMagick Image object. Contains methods to transform, change layer mode,
+    change opacity level, and more.
+
+  * FillLayer: A solid color, gradient, or pattern fill layer.
+
+  * AdjustmentLayer: Invert, Threshold, Levels, Blur adjustment layer.
+    Applies layer effect over everything under it in the layer stack.
+
+  * LayerMask: Mask any of the above layer types. LayerMasks are a special
+    type of layer which is a Alpha Channel mask that can be applied to any
+    layer type. Since LayerMask is also a layer, it can also be transformed
+    in any way.
+
+  * LayerSets: 2 types of LayerSet Models,
+
+    * LayerSet: The LayerSet is a container, or directory in which to bundle
+      layers. LayerSet contains methods to do group transforms on its bundled
+      layers. Transforms like rotation, movement and scaling are performed on
+      all the layers it contains while maintaining each layer on a seperate plane
+      without merging.
+
+    * Canvas: The canvas is a special LayerSet which is a blank workspace containing
+      other layers and layer sets.
+
+
+Usage:
+
+First you must require the gem or lib:
+
+  require 'rubygems'
+  require 'rcomposite'
+  include RComposite # includes the RComposite module methods into this scope
+
+After including the Module, we will need to create a blank canvas.
+
+  canvas = Canvas.new(640, 480)
+
+Creating a layer:
+
+  photo = Layer.new :file => 'photo.jpg'
+
+Creating a fill layer:
+
+  blue = FillLayer.new '#000090'
+
+Changing a Layers properties:
+
+  blue.opacity 40
+  blue.mode Multiply
+
+The layers may be added to the canvas. Whatever is added first will be on top:
+
+  canvas.layer blue
+  canvas.layer photo
+
+The canvas can be saved:
+
+  canvas.save_as 'bluesky.jpg'
+
+The real power of RComposite lies in its use of blocks and simplified syntax.
+Take a look at the following example:
+
+  Canvas.new(320,240) do
+
+    layer_set :slides do
+      layer :file => 'slide1.png' do
+        opacity 65
+        offset 12, 12
+        mode Lighten
+      end
+
+      adjustment_layer Blur, 0.5, 1.5 do
+        layer_mask :file => 'butterfly-mask.png'
+      end
+
+      layer :file => 'slide2.png' do
+        offset 28, 28
+        opacity 30
+        mode Darken
+      end
+
+      rotate 45
+      offset 70, 50
+      scale 80, 80
+    end
+
+    fill_layer SolidColor, '#f83898FF' do
+      opacity 70
+      mode Multiply
+
+      layer_mask :file => 'butterfly-mask.png' do
+        offset -30, -30
+        image.rotate! 40
+      end
+    end
+
+    fill_layer Gradient, 0, 0, 0, 50, '#606', '#033' do
+      opacity 90
+      mode Overlay
+
+      layer_mask :file => 'butterfly-mask.png' do
+        offset -20, -20
+      end
+    end
+
+    layer :file => 'background.png' do
+      image.resize!(320, 240)
+    end
+
+    save_as 'composite.jpg'
+  end
+
+This nice thing about RComposite is that it doesnt hide the underlaying RMagick
+Image object from you. It is always available through the image accessor
+
+  layer :file => 'photo.jpg' do
+    image.crop_resized!(100,300) # crop_resized! is a RMagick method
+  end
+
+
+
+@corban                                                    weare.buildingsky.net
+________________________________________________________________________________
+
+       Copyright (c) 2009 Corban Brook, released under the MIT license
+                                                                                  

data/lib/rcomposite/adjustmentlayer.rb

@@ -0,0 +1,48 @@
+module RComposite
+  Levels = 1
+  Curves = 2
+  ColorBalance = 3
+  BrightnessContrast = 4
+  HueSaturation = 5
+  SelectiveColor = 6
+  ChannelMixer = 7
+  GradientMap = 8
+  PhotoFilter = 9
+  Invert = 10 # negate
+  Threshold = 11 # threshold
+  Polarize = 12 # 
+  Blur = 13
+
+  class AdjustmentLayer < Layer
+    attr_reader :type, :args
+    
+    def initialize(type, *args, &block)
+      @type = type
+      @args = args
+      @mode = Normal
+      @offset_x = 0
+      @offset_y = 0
+      @opacity_percent = 100
+      @layer_mask = nil
+      
+      case type
+        when Invert
+          @proc = proc { negate }
+        when Threshold    
+          @proc = proc { threshold *args }
+        when Levels
+          @proc = proc { level *args }
+        when Blur
+          @proc = proc { gaussian_blur *args }
+      end
+      @proc = proc { |*args| @proc }.call(*@args)
+    end
+
+    def merge_down(image)
+      @image = image.clone.instance_eval &@proc
+      @image.matte = true
+
+      super(image)
+    end
+  end
+end

data/lib/rcomposite/canvas.rb

@@ -0,0 +1,16 @@
+module RComposite
+  class Canvas < LayerSet
+    attr_reader :width, :height
+    attr_accessor :image
+
+    def initialize(width, height, &block)
+      @image = Magick::Image.new width, height
+      @width = width
+      @height = height
+      $RCompositeCanvasWidth = @width
+      $RCompositeCanvasHeight = @height
+
+      super(:canvas, &block)
+    end
+  end
+end

data/lib/rcomposite/filllayer.rb

@@ -0,0 +1,44 @@
+module RComposite
+  # Fill layer types
+
+  SolidColor = 0
+  Gradient = 1
+  Pattern = 2
+  
+  class FillLayer < Layer
+    attr_accessor :image
+    attr_reader :offset_x, :offset_y
+
+    def initialize(type, *args, &block)
+      case type
+        when SolidColor
+          color = args[0]
+
+          fill = Magick::GradientFill.new(0, 0, 0, 0, color, color)
+          
+        when Gradient
+          x1 = args[0]
+          y1 = args[1]
+          x2 = args[2]
+          y2 = args[3]
+          color1 = args[4]
+          color2 = args[5]
+
+          fill = Magick::GradientFill.new(x1, y1, x2, y2, color1, color2)
+        
+        when Pattern
+          image = args[0]
+
+          fill = Magick::TextureFill.new(image)
+      end
+
+      @image = Magick::Image.new($RCompositeCanvasWidth, $RCompositeCanvasHeight, fill)
+
+      @image.matte = true
+      @mode = Normal
+      @offset_x = 0
+      @offset_y = 0
+      @opacity_percent = 100
+    end
+  end
+end

data/lib/rcomposite/layer.rb

@@ -0,0 +1,114 @@
+module RComposite
+  # Layer mode constants 
+  #   some of photoshops layer modes are directly equvilent to RMagick 
+  #   some are not, and some arent supported at all.
+
+  Normal = Magick::OverCompositeOp # PS equivilent
+  Dissolve = Magick::DissolveCompositeOp
+  Darken = Magick::DarkenCompositeOp # PS equivilent
+  Multiply = Magick::MultiplyCompositeOp # PS equivilent
+  #ColorBurn
+  #LinearBurn
+  Lighten = Magick::LightenCompositeOp # PS equivilent
+  Screen = Magick::ScreenCompositeOp # PS equivilent
+  #ColorDodge
+  #LinearDodge
+  Overlay = Magick::OverlayCompositeOp # PS equivilent
+  #SoftLight
+  #HardLight
+  #VividLight
+  #LinearLight
+  #PinLight
+  #HardMix
+  Difference = Magick::DifferenceCompositeOp # PS equivilent
+  #Exclusion
+  Hue = Magick::HueCompositeOp
+  Saturation = Magick::SaturateCompositeOp
+  Color = Magick::ColorizeCompositeOp
+  Luminosity = Magick::LuminizeCompositeOp
+  
+  class Layer
+    attr_accessor :image
+    attr_reader :offset_x, :offset_y
+
+    def initialize(options = {})
+      if options[:file]
+        @image = Magick::Image.read(options[:file]).first
+        @image.background_color = 'transparent'
+      elsif options[:blob]
+        @image = Magick::Image.from_blob(options[:blob]).first
+        @image.background_color = 'transparent'
+      elsif options[:image]
+        if options[:image].is_a? Magick::Image
+          @image = options[:image]
+        end
+      end
+
+      if @image
+        @image.matte = true
+        @mode = Normal
+        @offset_x = 0
+        @offset_y = 0
+        @opacity_percent = 100
+        @layer_mask = nil
+      else
+        raise "Layer not created -- no layer source."
+      end
+    end
+
+    def layer_mask(options, &block)
+      @layer_mask = LayerMask.new options
+      
+      @layer_mask.instance_eval &block if block_given?
+    end
+
+    def merge_down(image)
+      @layer_mask.apply self if @layer_mask
+      image.composite!(@image, @offset_x, @offset_y, @mode)
+    end
+
+    def width
+      @image.columns
+    end
+
+    def height
+      @image.rows
+    end
+
+    def offset(x, y)
+      @offset_x = x
+      @offset_y = y
+    end
+
+    def opacity(percent)
+      @opacity_percent = percent
+      # intercept original alpha channel with pixel intensity
+      alpha_channel = @image.channel(Magick::AlphaChannel).negate
+      intensity = (Magick::MaxRGB * (percent/100.0)).round
+      alpha_channel.composite!(Magick::Image.new(width, height) { self.background_color = Magick::Pixel.new(intensity,intensity,intensity) }, Magick::CenterGravity, Multiply)
+      alpha_channel.matte = false
+      
+      @image.composite!(alpha_channel, Magick::CenterGravity, Magick::CopyOpacityCompositeOp)
+      return true
+    end
+
+
+    def mode(mode = nil)
+      return @mode if mode.nil?
+      @mode = mode
+    end
+
+    def save_as(filename)
+      @image.write(filename)
+    end
+  
+    def join_set(set)
+      set.add_layer(self)
+    end
+
+    def leave_set(set)
+      set.remove_layer(self)
+    end
+
+  end
+end

data/lib/rcomposite/layermask.rb

@@ -0,0 +1,16 @@
+module RComposite
+  class LayerMask < Layer
+    def apply(layer)
+      # apply layer mask to layer before merging down
+      fill = Magick::GradientFill.new(0,0,0,0, '#000', '#000')
+      mask = Magick::Image.new(layer.width, layer.height, fill)
+      mask.composite!(@image, @offset_x, @offset_y, Magick::OverCompositeOp)
+      
+      alpha_channel = layer.image.channel(Magick::AlphaChannel).negate
+      alpha_channel.composite!(mask, 0, 0, Magick::MultiplyCompositeOp)
+      alpha_channel.matte = false
+      layer.image.composite!(alpha_channel, 0, 0, Magick::CopyOpacityCompositeOp)
+    end
+  
+  end
+end

data/lib/rcomposite/layerset.rb

@@ -0,0 +1,194 @@
+module RComposite
+  class LayerSet
+    attr_accessor :layers
+    attr_reader :min_x, :min_y, :max_x, :max_y, :bounding_width, :bounding_height, :name
+    
+    def initialize(name, &block)
+      @layers = []
+      @layer_sets = {}
+
+      bounding_box
+      @name = name
+
+      self.instance_eval &block if block_given?
+    end
+
+    def layer_set(set_or_name, &block) 
+      if set_or_name.is_a? RComposite::LayerSet
+        # referencing a previously instanstiated LayerSet and adding to Canvas.
+        set = set_or_name
+        @layers << set
+        @layer_sets[set.name] = set 
+      
+      elsif @layer_sets[set_or_name]
+        # referencing a previously added LayerSet.
+        set = @layer_sets[set_or_name]
+      
+      else    
+        # creating a new LayerSet and adding to Canvas.
+        set = LayerSet.new set_or_name  
+        @layers << set
+        @layer_sets[set_or_name] = set
+      end     
+
+      # tie floating block methods (layer, rotate, offset, etc) to LayerSet object.
+      set.instance_eval &block if block_given?
+
+      return set
+    end
+    
+    def layer(options, &block) 
+      if options.is_a? RComposite::Layer
+        layer = options
+      else
+        layer = Layer.new options
+      end
+      @layers << layer
+
+      # tie floating block methods (opacity, mode, offset, etc) to Layer object.
+      layer.instance_eval &block if block_given?
+
+      return layer
+    end
+
+    def fill_layer(type, *args, &block)
+      layer = FillLayer.new type, *args
+      @layers << layer
+
+      # tie floating block methods (opacity, mode, offset, etc) to Layer object.
+      layer.instance_eval &block if block_given?
+
+      return layer
+    end
+
+    def adjustment_layer(type, *args, &block) 
+      layer = AdjustmentLayer.new type, *args
+      @layers << layer
+
+      # tie floating block methods (opacity, mode, offset, etc) to Layer object.
+      layer.instance_eval &block if block_given?
+    
+      return layer
+    end
+    
+    def flatten
+      flattened_image = render
+      
+      # clear layers and sets
+      @layers.clear
+      @layer_sets.clear
+
+      # only 1 flattened layer now   
+      @layers << Layer.new(flattened_image)
+   end
+
+    def render
+      return composite_layers(@image.clone, @layers)
+    end
+
+    def composite_layers(image, layers) 
+      layers.reverse.each do |layer| 
+        case layer
+          when RComposite::LayerSet
+            image = composite_layers image, layer.layers
+          when RComposite::Layer
+            layer.merge_down image
+        end     
+      end     
+      
+      return image
+    end
+  
+    def save_as(filename)
+      render.write(filename)
+    end
+
+################################################################################################################################
+
+    def add_layer(layer)
+      @layers << layer
+      bounding_box
+    end
+
+    def remove_layer(layer)
+      @layers.delete(layer)
+      bounding_box
+    end
+    
+    def bounding_box
+      if @layers.size > 0
+        x1 = []
+        y1 = []
+        x2 = []
+        y2 = []
+        @layers.each do |layer|
+          x1 << layer.offset_x
+          y1 << layer.offset_y
+          x2 << layer.width + layer.offset_x 
+          y2 << layer.height + layer.offset_y 
+        end
+
+        @min_x = x1.min
+        @min_y = y1.min
+        @max_x = x2.max
+        @max_y = y2.max
+        @bounding_width = @max_x - @min_x
+        @bounding_height = @max_y - @min_y
+      else
+        @min_x = 0
+        @min_y = 0
+        @max_x = 0
+        @max_y = 0
+        @bounding_width = 0
+        @boudning_height = 0
+      end
+    end
+  
+    def offset(x, y)
+      bounding_box # recalculate bounding box
+      shift_x = x - @min_x
+      shift_y = y - @min_y
+      @layers.each do |layer|
+        layer.offset(layer.offset_x + shift_x, layer.offset_y + shift_y)
+      end
+      bounding_box
+    end
+
+    def scale(width, height)
+      bounding_box # recalculate bounding box
+      width_scale = width.to_f / bounding_width.to_f
+      height_scale = height.to_f / bounding_height.to_f
+      @layers.each do |layer|
+        layer.image.scale!((layer.width * width_scale).round, (layer.height * height_scale).round) 
+        layer.offset(((layer.offset_x - @min_x) * width_scale).round + @min_x, ((layer.offset_y - @min_y) * height_scale).round + @min_y)
+      end
+      bounding_box
+    end
+    
+    def rotate(degrees)
+      bounding_box # recalculate bounding box
+      bounding_mid_x = @bounding_width / 2
+      bounding_mid_y = @bounding_height / 2
+      @layers.each do |layer|
+        layer_mid_x = (layer.width/2.0).round + layer.offset_x - @min_x - bounding_mid_x
+        layer_mid_y = ((layer.height/2.0).round + layer.offset_y - @min_y - bounding_mid_y) * -1
+
+        radians = (degrees * -1) / (180 / Math::PI)
+        
+        cos = Math.cos(radians)
+        sin = Math.sin(radians)
+
+        new_mid_x = ((layer_mid_x * cos) - (layer_mid_y * sin)).round
+        new_mid_y = ((layer_mid_x * sin) + (layer_mid_y * cos)).round
+      
+        layer.image.rotate!(degrees)
+
+        new_offset_x = new_mid_x - (layer.width/2.0).round + @min_x + bounding_mid_x
+        new_offset_y = new_mid_y * -1 - (layer.height/2.0).round + @min_y + bounding_mid_y
+
+        layer.offset(new_offset_x, new_offset_y)
+      end
+      bounding_box
+    end
+  end
+end

data/lib/rcomposite.rb

@@ -0,0 +1,8 @@
+require 'rmagick'
+
+require 'rcomposite/layerset'
+require 'rcomposite/layer'
+require 'rcomposite/canvas'
+require 'rcomposite/filllayer'
+require 'rcomposite/adjustmentlayer'
+require 'rcomposite/layermask'

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: corbanbrook-rcomposite
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Corban Brook
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-24 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rmagick
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: 
+description: Rubyshop is an RMagick abstraction library to easily manipulate and composite images through the use of a canvas, layers, layer masks, adjustment layers, fill layers, and layer sets (much like in Photoshop)
+email: corbanbrook@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- MIT-LICENSE
+files: 
+- README
+- MIT-LICENSE
+- lib/rcomposite.rb
+- lib/rcomposite/layer.rb
+- lib/rcomposite/layerset.rb
+- lib/rcomposite/adjustmentlayer.rb
+- lib/rcomposite/filllayer.rb
+- lib/rcomposite/canvas.rb
+- lib/rcomposite/layermask.rb
+has_rdoc: true
+homepage: http://github.com/corbanbrook/rcomposite
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: An RMagick abstration layer for easy image compositing
+test_files: []
+