psd 2.1.2 → 3.9.0

data/lib/psd/path_record.rb

@@ -19,28 +19,13 @@ class PSD
       case @record_type
       when 0, 3 then read_path_record
       when 1, 2, 4, 5 then read_bezier_point
+      when 6 then read_path_fill_rule_record
       when 7 then read_clipboard_record
       when 8 then read_initial_fill
       else @file.seek(24, IO::SEEK_CUR)
       end
     end
 
-    # Writes out the path to file.
-    def write(outfile)
-      outfile.write_short @record_type
-      case @record_type
-      when 0 then write_path_record(outfile)
-      when 3 then write_path_record(outfile)
-      when 1 then write_bezier_point(outfile)
-      when 2 then write_bezier_point(outfile)
-      when 4 then write_bezier_point(outfile)
-      when 5 then write_bezier_point(outfile)
-      when 7 then write_clipboard_record(outfile)
-      when 8 then write_initial_fill(outfile)
-      else outfile.seek(24, IO::SEEK_CUR)
-      end
-    end
-
     # Exports the path record to an easier to work with hash.
     def to_hash
       case @record_type
@@ -51,6 +36,7 @@ class PSD
       when 1, 2, 4, 5
         {
           linked: @linked,
+          closed: [1, 2].include?(@record_type),
           preceding: {
             vert: @preceding_vert,
             horiz: @preceding_horiz
@@ -83,34 +69,6 @@ class PSD
       end.merge({ record_type: @record_type })
     end
 
-    # Attempts to translate the path
-    def translate(x=0, y=0)
-      return unless is_bezier_point?
-
-      document_width, document_height = @layer.document_dimensions
-      translate_x_ratio = x.to_f / document_width.to_f
-      translate_y_ratio = y.to_f / document_height.to_f
-
-      @preceding_vert += translate_y_ratio
-      @preceding_horiz += translate_x_ratio
-      @anchor_vert += translate_y_ratio
-      @anchor_horiz += translate_x_ratio
-      @leaving_vert += translate_y_ratio
-      @leaving_horiz += translate_x_ratio
-    end
-
-    # Attempts to scale the path
-    def scale(xr, yr)
-      return unless is_bezier_point?
-
-      @preceding_vert *= yr
-      @preceding_horiz *= xr
-      @anchor_vert *= yr
-      @anchor_horiz *= xr
-      @leaving_vert *= yr
-      @leaving_horiz *= xr
-    end
-
     # Is this record a bezier point?
     def is_bezier_point?
       [1,2,4,5].include? @record_type
@@ -123,11 +81,6 @@ class PSD
       @file.seek(22, IO::SEEK_CUR)
     end
 
-    def write_path_record(file)
-      file.write_short @num_points
-      file.seek(22, IO::SEEK_CUR)
-    end
-
     def read_bezier_point
       @linked = [1,4].include? @record_type
 
@@ -141,13 +94,8 @@ class PSD
       @leaving_horiz = @file.read_path_number
     end
 
-    def write_bezier_point(outfile)
-      outfile.write_path_number @preceding_vert
-      outfile.write_path_number @preceding_horiz
-      outfile.write_path_number @anchor_vert
-      outfile.write_path_number @anchor_horiz
-      outfile.write_path_number @leaving_vert
-      outfile.write_path_number @leaving_horiz
+    def read_path_fill_rule_record
+      @file.seek(24, IO::SEEK_CUR)
     end
 
     def read_clipboard_record
@@ -159,22 +107,9 @@ class PSD
       @file.seek(4, IO::SEEK_CUR)
     end
 
-    def write_clipboard_record(file)
-      [@clipboard_top, @clipboard_left, @clipboard_bottom,
-        @clipboard_right, @clipboard_resolution].each do |point|
-          file.write_path_number point
-      end
-      file.seek(4, IO::SEEK_CUR)
-    end
-
     def read_initial_fill
       @initial_fill = @file.read_short
       @file.seek(22, IO::SEEK_CUR)
     end
-
-    def write_initial_fill(file)
-      file.write_short @initial_fill
-      file.seek(22, IO::SEEK_CUR)
-    end
   end
-end
+end

data/lib/psd/renderer/blender.rb

@@ -16,7 +16,8 @@ class PSD
       # Composes the foreground Canvas onto the background Canvas using the
       # blending mode specified by the foreground.
       def compose!
-        PSD.logger.debug "Composing #{fg.node.debug_name} onto #{bg.node.debug_name} with #{fg.node.blending_mode} blending"
+        PSD.logger.debug "#{fg.node.debug_name} -> #{bg.node.debug_name}: #{fg.node.blending_mode} blending"
+        PSD.logger.debug "fg: (#{fg.left}, #{fg.top}) #{fg.width}x#{fg.height}; bg: (#{bg.left}, #{bg.top}) #{bg.width}x#{bg.height}"
 
         offset_x = fg.left - bg.left
         offset_y = fg.top - bg.top
@@ -30,12 +31,12 @@ class PSD
 
             color = Compose.send(
               fg.node.blending_mode,
-              fg.canvas[x, y],
-              bg.canvas[base_x, base_y],
-              compose_options
+              fg.get_pixel(x, y),
+              bg.get_pixel(base_x, base_y),
+              calculated_opacity
             )
 
-            bg.canvas[base_x, base_y] = color
+            bg.set_pixel base_x, base_y, color
           end
         end
       end
@@ -48,6 +49,10 @@ class PSD
           fill_opacity: @fill_opacity
         }
       end
+
+      def calculated_opacity
+        @calculated_opacity ||= compose_options[:opacity] * compose_options[:fill_opacity] / 255
+      end
     end
   end
 end

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,35 @@
 class PSD
   class Renderer
     class Canvas
-      attr_reader :canvas, :node, :width, :height, :left, :right, :top, :bottom, :opacity, :fill_opacity
+      extend Forwardable
 
-      def initialize(node, width = nil, height = nil, color = ChunkyPNG::Color::TRANSPARENT)
+      attr_reader :canvas, :node, :opts, :width, :height, :opacity, :fill_opacity
+
+      def_delegators :node, :top, :right, :bottom, :left
+      def_delegators :canvas, :[], :[]=, :get_pixel, :set_pixel
+
+      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 +39,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 +46,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
+
+      def fill_color
+        if has_fill?
+          @node.solid_color.color
+        else
+          ChunkyPNG::Color::TRANSPARENT
+        end
+      end
 
-        PSD.logger.debug "Applying layer mask to #{node.name}"
-        Mask.new(self).apply!
+      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
@@ -92,4 +113,4 @@ class PSD
       end
     end
   end
-end
+end

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

@@ -5,21 +5,17 @@ class PSD
   # Mostly based on similar code from libpsd.
   module Compose
     extend self
-
-    DEFAULT_OPTS = {
-      opacity: 255,
-      fill_opacity: 255
-    }
+    extend ChunkyPNG::Color
 
     #
     # 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 +28,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 +40,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 +52,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 +74,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 +91,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 +104,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 +117,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 +134,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 +152,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 +173,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 +192,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 +213,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 +234,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 +255,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 +276,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 +293,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 +306,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)
@@ -325,14 +321,12 @@ class PSD
 
     # 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 +336,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)
@@ -358,4 +348,4 @@ class PSD
       bg + ((255 - bg) * fg >> 8)
     end
   end
-end
+end