psd 2.1.2 → 3.1.2

data/lib/psd/renderer/cairo_helpers.rb

@@ -0,0 +1,46 @@
+class PSD
+  class Renderer
+    # Adapted from 
+    # http://www.hokstad.com/simple-drawing-in-ruby-with-cairo
+    module CairoHelpers
+      def cairo_image_surface(w, h, bg=nil)
+        surface = Cairo::ImageSurface.new(w, h)
+        cr = Cairo::Context.new(surface)
+
+        if bg
+          cr.set_source_rgba(*bg)
+          cr.paint
+        end
+
+        yield cr
+
+        surface.finish
+
+        data = cr.target.data.to_s[0, 4 * w * h]
+
+        # Cairo data is stored as BGRA, ugh.
+        data = data.unpack("N*").map do |color|
+          color = ChunkyPNG::Color.to_truecolor_alpha_bytes(color)
+          ChunkyPNG::Color.rgba(color[2], color[1], color[0], color[3])
+        end
+
+        ChunkyPNG::Canvas.new(w, h, data)
+      end
+
+      def cairo_path(cr, *pairs)
+        first = true
+        pairs.each do |cmd|
+          if cmd == :c
+            cr.close_path
+            first = true
+          elsif first
+            cr.move_to(*cmd)
+            first = false
+          else
+            cr.curve_to(*cmd)
+          end 
+        end
+      end
+    end
+  end
+end

data/lib/psd/renderer/canvas.rb

@@ -1,34 +1,34 @@
 class PSD
   class Renderer
     class Canvas
-      attr_reader :canvas, :node, :width, :height, :left, :right, :top, :bottom, :opacity, :fill_opacity
+      attr_reader :canvas, :node, :opts, :width, :height, :opacity, :fill_opacity
+      
+      [:top, :right, :bottom, :left].each { |dir| delegate dir, to: :node }
 
-      def initialize(node, width = nil, height = nil, color = ChunkyPNG::Color::TRANSPARENT)
+      delegate :[], :[]=, :get_pixel, :set_pixel, to: :canvas
+
+      def initialize(node, width = nil, height = nil, opts = {})
         @node = node
+        @opts = opts
         @pixel_data = @node.group? ? [] : @node.image.pixel_data
         
         @width = (width || @node.width).to_i
         @height = (height || @node.height).to_i
-        @left = @node.left.to_i
-        @right = @node.right.to_i
-        @top = @node.top.to_i
-        @bottom = @node.bottom.to_i
 
         @opacity = @node.opacity.to_f
         @fill_opacity = @node.fill_opacity.to_f
 
-        @canvas = ChunkyPNG::Canvas.new(@width, @height, color)
-
-        initialize_canvas unless @node.group?
+        initialize_canvas
       end
 
       def paint_to(base)
         PSD.logger.debug "Painting #{node.name} to #{base.node.debug_name}"
 
-        apply_mask
+        apply_masks
         apply_clipping_mask
         apply_layer_styles
         apply_layer_opacity
+
         compose_pixels(base)
       end
 
@@ -38,9 +38,6 @@ class PSD
         @height = @canvas.height
       end
 
-      def [](x, y); @canvas[x, y]; end
-      def []=(x, y, value); @canvas[x, y] = value; end
-
       def method_missing(method, *args, &block)
         @canvas.send(method, *args, &block)
       end
@@ -48,20 +45,43 @@ class PSD
       private
 
       def initialize_canvas
-        PSD.logger.debug "Initializing canvas for #{node.debug_name}"
+        PSD.logger.debug "Initializing canvas for #{node.debug_name}; color = #{ChunkyPNG::Color.to_truecolor_alpha_bytes(fill_color)}"
+
+        @canvas = ChunkyPNG::Canvas.new(@width, @height, fill_color)
+        return if @node.group? || has_fill? || @opts[:base]
 
         # Sorry, ChunkyPNG.
         @canvas.send(:replace_canvas!, width, height, @pixel_data)
-
+      ensure
         # This can now be referenced by @canvas.pixels
         @pixel_data = nil
       end
 
-      def apply_mask
-        return unless @node.image.has_mask?
+      def has_fill?
+        !@opts[:base] && @node.layer? && @node.solid_color
+      end
 
-        PSD.logger.debug "Applying layer mask to #{node.name}"
-        Mask.new(self).apply!
+      def fill_color
+        if has_fill?
+          @node.solid_color.color
+        else
+          ChunkyPNG::Color::TRANSPARENT
+        end
+      end
+
+      def apply_masks
+        ([@node] + @node.ancestors).each do |n|
+          next unless n.raster_mask?
+          break if n.group? && !n.passthru_blending?
+
+          if n.layer?
+            PSD.logger.debug "Applying raster mask to #{@node.name}"
+            Mask.new(self).apply!
+          else
+            PSD.logger.debug "Applying raster mask to #{@node.name} from #{n.name}"
+            Mask.new(self, n).apply!
+          end
+        end
       end
 
       def apply_clipping_mask

data/lib/psd/renderer/canvas_management.rb

@@ -5,9 +5,9 @@ class PSD
         @canvas_stack.last
       end
 
-      def create_group_canvas(node, width=@width, height=@height)
+      def create_group_canvas(node, width = @width, height = @height, opts = {})
         PSD.logger.debug "Group canvas created. Node = #{node.name || ":root:"}, width = #{width}, height = #{height}"
-        push_canvas Canvas.new(node, width, height)
+        push_canvas Canvas.new(node, width, height, @opts.merge(opts))
       end
 
       def push_canvas(canvas)

data/lib/psd/renderer/clipping_mask.rb

@@ -7,8 +7,9 @@ class PSD
         @canvas = canvas
         @node = @canvas.node
         
-        mask_node = @canvas.node.next_sibling
-        @mask = Canvas.new(mask_node)
+        mask_node = @canvas.node.clipping_mask
+
+        @mask = MaskCanvas.new(mask_node)
       end
 
       def apply!
@@ -31,8 +32,8 @@ class PSD
               alpha = pixel.nil? ? 0 : ChunkyPNG::Color.a(pixel)
             end
             
-            color = @canvas[x, y]
-            @canvas[x, y] = (color & 0xffffff00) | (ChunkyPNG::Color.a(color) * alpha / 255)
+            color = @canvas.get_pixel(x, y)
+            @canvas.set_pixel x, y, (color & 0xffffff00) | (ChunkyPNG::Color.a(color) * alpha / 255)
           end
         end
       end

data/lib/psd/renderer/compose.rb

@@ -6,20 +6,15 @@ class PSD
   module Compose
     extend self
 
-    DEFAULT_OPTS = {
-      opacity: 255,
-      fill_opacity: 255
-    }
-
     #
     # Normal blend modes
     #
 
-    def normal(fg, bg, opts={})
-      return apply_opacity(fg, opts) if fully_transparent?(bg)
+    def normal(fg, bg, opacity)
+      return apply_opacity(fg, opacity) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
-      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, opacity)
       new_r = blend_channel(r(bg), r(fg), mix_alpha)
       new_g = blend_channel(g(bg), g(fg), mix_alpha)
       new_b = blend_channel(b(bg), b(fg), mix_alpha)
@@ -32,11 +27,11 @@ class PSD
     # Subtractive blend modes
     #
 
-    def darken(fg, bg, opts={})
-      return apply_opacity(fg, opts) if fully_transparent?(bg)
+    def darken(fg, bg, opacity)
+      return apply_opacity(fg, opacity) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
-      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, opacity)
       new_r = r(fg) <= r(bg) ? blend_channel(r(bg), r(fg), mix_alpha) : r(bg)
       new_g = g(fg) <= g(bg) ? blend_channel(g(bg), g(fg), mix_alpha) : g(bg)
       new_b = b(fg) <= b(bg) ? blend_channel(b(bg), b(fg), mix_alpha) : b(bg)
@@ -44,11 +39,11 @@ class PSD
       rgba(new_r, new_g, new_b, dst_alpha)
     end
 
-    def multiply(fg, bg, opts={})
-      return apply_opacity(fg, opts) if fully_transparent?(bg)
+    def multiply(fg, bg, opacity)
+      return apply_opacity(fg, opacity) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
-      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, opacity)
       new_r = blend_channel(r(bg), r(fg) * r(bg) >> 8, mix_alpha)
       new_g = blend_channel(g(bg), g(fg) * g(bg) >> 8, mix_alpha)
       new_b = blend_channel(b(bg), b(fg) * b(bg) >> 8, mix_alpha)
@@ -56,11 +51,11 @@ class PSD
       rgba(new_r, new_g, new_b, dst_alpha)
     end
 
-    def color_burn(fg, bg, opts={})
-      return apply_opacity(fg, opts) if fully_transparent?(bg)
+    def color_burn(fg, bg, opacity)
+      return apply_opacity(fg, opacity) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
-      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, opacity)
 
       calculate_foreground = Proc.new do |b, f|
         if f > 0
@@ -78,11 +73,11 @@ class PSD
       rgba(new_r, new_g, new_b, dst_alpha)
     end
 
-    def linear_burn(fg, bg, opts={})
-      return apply_opacity(fg, opts) if fully_transparent?(bg)
+    def linear_burn(fg, bg, opacity)
+      return apply_opacity(fg, opacity) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
-      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, opacity)
 
       new_r = blend_channel(r(bg), (r(fg) < (255 - r(bg))) ? 0 : r(fg) - (255 - r(bg)), mix_alpha)
       new_g = blend_channel(g(bg), (g(fg) < (255 - g(bg))) ? 0 : g(fg) - (255 - g(bg)), mix_alpha)
@@ -95,11 +90,11 @@ class PSD
     # Additive blend modes
     #
 
-    def lighten(fg, bg, opts={})
-      return apply_opacity(fg, opts) if fully_transparent?(bg)
+    def lighten(fg, bg, opacity)
+      return apply_opacity(fg, opacity) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
-      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, opacity)
 
       new_r = r(fg) >= r(bg) ? blend_channel(r(bg), r(fg), mix_alpha) : r(bg)
       new_g = g(fg) >= g(bg) ? blend_channel(g(bg), g(fg), mix_alpha) : g(bg)
@@ -108,11 +103,11 @@ class PSD
       rgba(new_r, new_g, new_b, dst_alpha)
     end
 
-    def screen(fg, bg, opts={})
-      return apply_opacity(fg, opts) if fully_transparent?(bg)
+    def screen(fg, bg, opacity)
+      return apply_opacity(fg, opacity) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
-      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, opacity)
 
       new_r = blend_channel(r(bg), 255 - ((255 - r(bg)) * (255 - r(fg)) >> 8), mix_alpha)
       new_g = blend_channel(g(bg), 255 - ((255 - g(bg)) * (255 - g(fg)) >> 8), mix_alpha)
@@ -121,11 +116,11 @@ class PSD
       rgba(new_r, new_g, new_b, dst_alpha)
     end
 
-    def color_dodge(fg, bg, opts={})
-      return apply_opacity(fg, opts) if fully_transparent?(bg)
+    def color_dodge(fg, bg, opacity)
+      return apply_opacity(fg, opacity) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
-      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, opacity)
 
       calculate_foreground = Proc.new do |b, f|
         f < 255 ? [(b << 8) / (255 - f), 255].min : b
@@ -138,11 +133,11 @@ class PSD
       rgba(new_r, new_g, new_b, dst_alpha)
     end
 
-    def linear_dodge(fg, bg, opts={})
-      return apply_opacity(fg, opts) if fully_transparent?(bg)
+    def linear_dodge(fg, bg, opacity)
+      return apply_opacity(fg, opacity) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
-      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, opacity)
 
       new_r = blend_channel(r(bg), (r(bg) + r(fg)) > 255 ? 255 : r(bg) + r(fg), mix_alpha)
       new_g = blend_channel(g(bg), (g(bg) + g(fg)) > 255 ? 255 : g(bg) + g(fg), mix_alpha)
@@ -156,11 +151,11 @@ class PSD
     # Contrasting blend modes
     #
 
-    def overlay(fg, bg, opts={})
-      return apply_opacity(fg, opts) if fully_transparent?(bg)
+    def overlay(fg, bg, opacity)
+      return apply_opacity(fg, opacity) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
-      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, opacity)
 
       calculate_foreground = Proc.new do |b, f|
         if b < 128
@@ -177,11 +172,11 @@ class PSD
       rgba(new_r, new_g, new_b, dst_alpha)
     end
 
-    def soft_light(fg, bg, opts={})
-      return apply_opacity(fg, opts) if fully_transparent?(bg)
+    def soft_light(fg, bg, opacity)
+      return apply_opacity(fg, opacity) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
-      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, opacity)
 
       calculate_foreground = Proc.new do |b, f|
         c1 = b * f >> 8
@@ -196,11 +191,11 @@ class PSD
       rgba(new_r, new_g, new_b, dst_alpha)
     end
 
-    def hard_light(fg, bg, opts={})
-      return apply_opacity(fg, opts) if fully_transparent?(bg)
+    def hard_light(fg, bg, opacity)
+      return apply_opacity(fg, opacity) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
-      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, opacity)
 
       calculate_foreground = Proc.new do |b, f|
         if f < 128
@@ -217,11 +212,11 @@ class PSD
       rgba(new_r, new_g, new_b, dst_alpha)
     end
 
-    def vivid_light(fg, bg, opts={})
-      return apply_opacity(fg, opts) if fully_transparent?(bg)
+    def vivid_light(fg, bg, opacity)
+      return apply_opacity(fg, opacity) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
-      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, opacity)
 
       calculate_foreground = Proc.new do |b, f|
         if f < 255
@@ -238,11 +233,11 @@ class PSD
       rgba(new_r, new_g, new_b, dst_alpha)
     end
 
-    def linear_light(fg, bg, opts={})
-      return apply_opacity(fg, opts) if fully_transparent?(bg)
+    def linear_light(fg, bg, opacity)
+      return apply_opacity(fg, opacity) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
-      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, opacity)
 
       calculate_foreground = Proc.new do |b, f|
         if b < 255
@@ -259,11 +254,11 @@ class PSD
       rgba(new_r, new_g, new_b, dst_alpha)
     end
 
-    def pin_light(fg, bg, opts={})
-      return apply_opacity(fg, opts) if fully_transparent?(bg)
+    def pin_light(fg, bg, opacity)
+      return apply_opacity(fg, opacity) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
-      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, opacity)
 
       calculate_foreground = Proc.new do |b, f|
         if f >= 128
@@ -280,11 +275,11 @@ class PSD
       rgba(new_r, new_g, new_b, dst_alpha)
     end
 
-    def hard_mix(fg, bg, opts={})
-      return apply_opacity(fg, opts) if fully_transparent?(bg)
+    def hard_mix(fg, bg, opacity)
+      return apply_opacity(fg, opacity) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
-      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, opacity)
 
       new_r = blend_channel(r(bg), (r(bg) + r(fg) <= 255) ? 0 : 255, mix_alpha)
       new_g = blend_channel(g(bg), (g(bg) + g(fg) <= 255) ? 0 : 255, mix_alpha)
@@ -297,11 +292,11 @@ class PSD
     # Inversion blend modes
     #
 
-    def difference(fg, bg, opts={})
-      return apply_opacity(fg, opts) if fully_transparent?(bg)
+    def difference(fg, bg, opacity)
+      return apply_opacity(fg, opacity) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
-      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, opacity)
 
       new_r = blend_channel(r(bg), (r(bg) - r(fg)).abs, mix_alpha)
       new_g = blend_channel(g(bg), (g(bg) - g(fg)).abs, mix_alpha)
@@ -310,11 +305,11 @@ class PSD
       rgba(new_r, new_g, new_b, dst_alpha)
     end
 
-    def exclusion(fg, bg, opts={})
-      return apply_opacity(fg, opts) if fully_transparent?(bg)
+    def exclusion(fg, bg, opacity)
+      return apply_opacity(fg, opacity) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
-      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, opacity)
 
       new_r = blend_channel(r(bg), r(bg) + r(fg) - (r(bg) * r(fg) >> 7), mix_alpha)
       new_g = blend_channel(g(bg), g(bg) + g(fg) - (g(bg) * g(fg) >> 7), mix_alpha)
@@ -323,16 +318,18 @@ class PSD
       rgba(new_r, new_g, new_b, dst_alpha)
     end
 
+    [:r, :g, :b, :a, :rgba, :fully_transparent?].each do |meth|
+      define_method(meth) { |*args| ChunkyPNG::Color.send(meth, *args) }
+    end
+
     # If the blend mode is missing, we fall back to normal composition.
     def method_missing(method, *args, &block)
-      return ChunkyPNG::Color.send(method, *args) if ChunkyPNG::Color.respond_to?(method)
       normal(*args)
     end
 
     private
 
-    def calculate_alphas(fg, bg, opts)
-      opacity = calculate_opacity(opts)
+    def calculate_alphas(fg, bg, opacity)
       src_alpha = a(fg) * opacity >> 8
       dst_alpha = a(bg)
 
@@ -342,12 +339,8 @@ class PSD
       return mix_alpha, dst_alpha
     end
 
-    def calculate_opacity(opts)
-      opts[:opacity] * opts[:fill_opacity] / 255
-    end
-
-    def apply_opacity(color, opts)
-      (color & 0xffffff00) | ((color & 0x000000ff) * calculate_opacity(opts) / 255)
+    def apply_opacity(color, opacity)
+      (color & 0xffffff00) | ((color & 0x000000ff) * opacity / 255)
     end
 
     def blend_channel(bg, fg, alpha)