psd 1.3.3 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 448518141d3b745904f809280d0e826e08bf8dc0
-  data.tar.gz: 4c0725157152e2f924b95cf023603a9b86bd1f54
+  metadata.gz: 9cbcd0dd708df678b81c59484b465c4e83153dfd
+  data.tar.gz: 3f8a84f7b4a8dd36c1567dd11e8e3c751a22a1a7
 SHA512:
-  metadata.gz: e559032f4b160eb26451c38aa4bc3fa7869aa6984f60c5d062596087cf32a38fdc181e3c703a56b22ba88fc965abe727fa158eb427f76042e46c55f694593ab3
-  data.tar.gz: 4e31eb123c902d3381e3895d262589f8d269aca4e30c8a74f541d03ef6a9e527aefc9c895df5e358f62e5e8f5b584e4a6a5070b4cf83a10892c629ba46550d96
+  metadata.gz: e66d305e6d0157a0e4c52d2e84ea8a71ace66dbc7cbaea88469a5e1b8dc91e6e87f75e795a0eb3c612c642150b5b2ed3213e6cb45803643707d8ddb270e7d799
+  data.tar.gz: c61813c1eeee66eb8fbe2236462b93fc988f68f864d1f60d88f3135905b0b8ba5bd5a112cdf8855d485e32615c6f1a307658c75843641ac9e160ca7d986c77be

data/README.md

@@ -43,7 +43,7 @@ Or install it yourself as:
 
 The [full source code documentation](http://rubydoc.info/gems/psd/frames) is available, but here are some common ways to use and access the PSD data:
 
-**Loading a PSD**
+### Loading a PSD
 
 ``` ruby
 require 'psd'
@@ -74,11 +74,12 @@ PSD.open('path/to/file.psd') do
 end
 ```
 
-**Traversing the Document**
+### Traversing the Document
 
 To access the document as a tree structure, use `psd.tree` to get the root node. From there, you can traverse the tree using any of these methods:
 
 * `root`: get the root node from anywhere in the tree
+* `children`: get all immediate children of the node
 * `ancestors`: get all ancestors in the path of this node (excluding the root)
 * `siblings`: get all sibling tree nodes including the current one (e.g. all layers in a folder)
 * `descendants`: get all descendant nodes not including the current one
@@ -97,7 +98,7 @@ If you know the path to a group or layer within the tree, you can search by that
 psd.tree.children_at_path("Version A/Matte")
 ```
 
-**Layer Comps**
+### Layer Comps
 
 You can also filter nodes based on a layer comp. To generate a new tree consisting only of the layers that are enabled in a certain layer comp:
 
@@ -112,7 +113,7 @@ puts tree.children.map(&:name)
 
 This returns a new node tree and does not alter the original so you won't lose any data.
 
-**Accessing Layer Data**
+### Accessing Layer Data
 
 To get data such as the name or dimensions of a layer:
 
@@ -134,7 +135,7 @@ psd.tree.descendant_layers.first.text[:font]
   "font-family: \"HelveticaNeue-Light\", \"AdobeInvisFont\", \"MyriadPro-Regular\";\nfont-size: 33.0pt;\ncolor: rgba(19, 120, 98, 255);"}
 ```
 
-**Exporting Data**
+### Exporting Data
 
 When working with the tree structure, you can recursively export any node to a Hash.
 
@@ -196,7 +197,7 @@ png = psd.image.to_png # reference to PNG data
 psd.image.save_as_png 'path/to/output.png' # writes PNG to disk
 ```
 
-**Debugging**
+### Debugging
 
 If you run into any problems parsing a PSD, you can enable debug logging via the `PSD_DEBUG` environment variable. For example:
 
@@ -210,6 +211,20 @@ You can also give a path to a file instead. If you need to enable debugging prog
 PSD.debug = true
 ```
 
+### Preview Building
+
+**This is currently an experimental feature. It works "well enough" but is not perfect yet.**
+
+You can build previews of any subset or version of the PSD document. This is useful for generating previews of layer comps or exporting individual layer groups as images.
+
+``` ruby
+# Save a layer comp
+psd.tree.filter_by_comp("Version A").save_as_png('./Version A.png')
+
+# Generate PNG of individual layer group
+psd.tree.children_at_path("Group 1").first.to_png
+```
+
 ## To-do
 
 There are a few features that are currently missing from PSD.rb.

data/lib/psd.rb

@@ -103,8 +103,6 @@ class PSD
     @resources = Resources.new(@file)
     @resources.parse
 
-    PSD.logger.debug @resources.data.inspect
-
     return @resources
   end
 

data/lib/psd/blend_mode.rb

@@ -35,17 +35,18 @@ class PSD
       vLit: 'vivid light',
       lLit: 'linear light',
       pLit: 'pin light',
-      hMix: 'hard mix'
+      hMix: 'hard mix',
+      pass: 'passthru'
     }
 
     # Get the readable name for this blend mode.
     def mode
-      BLEND_MODES[blend_key.to_sym]
+      BLEND_MODES[blend_key.strip.to_sym]
     end
 
     # Set the blend mode with the readable name.
     def mode=(val)
-      blend_key = BLEND_MODES.invert[val.downcase]
+      blend_key = BLEND_MODES.invert[val.strip.downcase]
     end
 
     # Opacity is stored as an integer between 0-255. This converts the opacity

data/lib/psd/channel_image.rb

@@ -7,7 +7,8 @@ class PSD
     include ImageFormat::LayerRLE
     include ImageFormat::LayerRAW
 
-    attr_reader :width, :height
+    attr_reader :width, :height, :mask_data
+    
 
     def initialize(file, header, layer)
       @layer = layer
@@ -18,6 +19,9 @@ class PSD
       super(file, header)
 
       @channels_info = @layer.channels_info
+      @has_mask = @layer.mask.width * @layer.mask.height > 0
+      @opacity = @layer.opacity / 255.0
+      @mask_data = []
     end
 
     def skip
@@ -33,6 +37,7 @@ class PSD
 
     def parse
       PSD.logger.debug "Layer = #{@layer.name}, Size = #{width}x#{height}"
+      PSD.logger.debug @channels_info
 
       @chan_pos = 0
 
@@ -65,10 +70,14 @@ class PSD
         end
       end
 
+      @width = @layer.width
+      @height = @layer.height
+
       if @channel_data.length != @length
         PSD.logger.error "#{@channel_data.length} read; expected #{@length}"
       end
 
+      parse_user_mask
       process_image_data
     end
 
@@ -80,9 +89,27 @@ class PSD
       when 1 then parse_rle!
       when 2, 3 then parse_zip!
       else
-        PSD.logger.error "Unknown image compression. Attempting to skip."
+        PSD.logger.error "Unknown image compression: #{@compression}. Attempting to skip."
         @file.seek(@end_pos)
       end
     end
+
+    def parse_user_mask
+      return unless has_mask?
+
+      channel = @channels_info.select { |c| c[:id] == -2 }.first
+      index = @channels_info.index { |c| c[:id] == -2 }
+      return if channel.nil?
+
+      start = @channel_length * index
+      length = @layer.mask.width * @layer.mask.height
+      PSD.logger.debug "Copying user mask: #{length} bytes at #{start}"
+
+      @mask_data = @channel_data[start, length]
+
+      if @mask_data.length != length
+        PSD.logger.error "Mask length is incorrect. Expected = #{length}, Actual = #{@mask_data.length}"
+      end
+    end
   end
 end

data/lib/psd/clipping_mask.rb

@@ -0,0 +1,40 @@
+class PSD
+  class ClippingMask
+    def initialize(layer, png=nil)
+      @layer = layer
+      @png = png
+    end
+
+    def apply
+      return @png unless @layer.clipped?
+
+      mask = @layer.next_sibling
+
+      PSD.logger.debug "Applying clipping mask #{mask.name} to #{@layer.name}"
+
+      width, height = @layer.document_dimensions
+      full_png = ChunkyPNG::Canvas.new(width.to_i, height.to_i, ChunkyPNG::Color::TRANSPARENT)
+      full_png.compose!(@png, @layer.left, @layer.top)
+
+      height.times do |y|
+        width.times do |x|
+          if y < mask.top || y > mask.bottom || x < mask.left || x > mask.right
+            alpha = 0
+          else
+            mask_x = x - mask.left
+            mask_y = y - mask.top
+
+            pixel = mask.image.pixel_data[mask_y * mask.width + mask_x]
+            alpha = pixel.nil? ? 0 : ChunkyPNG::Color.a(pixel)
+          end
+          
+          color = ChunkyPNG::Color.to_truecolor_alpha_bytes(full_png[x, y])
+          color[3] = color[3] * alpha / 255
+          full_png[x, y] = ChunkyPNG::Color.rgba(*color)
+        end
+      end
+
+      full_png.crop!(@layer.left, @layer.top, @layer.width, @layer.height)
+    end
+  end
+end

data/lib/psd/color.rb

@@ -3,10 +3,12 @@ class PSD
   # document in the color space as defined by the user instead of a normalized
   # value of some kind. This means that we have to do all the conversion ourselves
   # for each color space.
-  class Color
+  module Color
+    extend self
+
       # This is a relic of libpsd that will likely go away in a future version. It
       # stored the entire color value in a 32-bit address space for speed.
-    def self.color_space_to_argb(color_space, color_component)
+    def color_space_to_argb(color_space, color_component)
       color = case color_space
       when 0
         rgb_to_color *color_component
@@ -26,7 +28,7 @@ class PSD
       color_to_argb(color)
     end
 
-    def self.color_to_argb(color)
+    def color_to_argb(color)
       [
         (color) >> 24,
         ((color) & 0x00FF0000) >> 16,
@@ -35,19 +37,19 @@ class PSD
       ]
     end
 
-    def self.rgb_to_color(*args)
+    def rgb_to_color(*args)
       argb_to_color(255, *args)
     end
 
-    def self.argb_to_color(a, r, g, b)
+    def argb_to_color(a, r, g, b)
       (a << 24) | (r << 16) | (g << 8) | b
     end
 
-    def self.hsb_to_color(*args)
+    def hsb_to_color(*args)
       ahsb_to_color(255, *args)
     end
 
-    def self.ahsb_to_color(alpha, hue, saturation, brightness)
+    def ahsb_to_color(alpha, hue, saturation, brightness)
       if saturation == 0.0
         b = g = r = (255 * brightness).to_i
       else
@@ -66,7 +68,7 @@ class PSD
       argb_to_color alpha, r, g, b
     end
 
-    def self.hue_to_color(hue, m1, m2)
+    def hue_to_color(hue, m1, m2)
       hue = (hue % 360).to_i
       if hue < 60
         v = m1 + (m2 - m1) * hue / 60
@@ -81,7 +83,7 @@ class PSD
       (v * 255).to_i
     end
 
-    def self.cmyk_to_color(c, m, y, k)
+    def cmyk_to_color(c, m, y, k)
       r = 1 - (c * (1 - k) + k) * 255
       g = 1 - (m * (1 - k) + k) * 255
       b = 1 - (y * (1 - k) + k) * 255
@@ -93,16 +95,16 @@ class PSD
       rgb_to_color r, g, b
     end
 
-    def self.lab_to_color(*args)
+    def lab_to_color(*args)
       alab_to_color(255, *args)
     end
 
-    def self.alab_to_color(alpha, l, a, b)
+    def alab_to_color(alpha, l, a, b)
       xyz = lab_to_xyz(l, a, b)
       axyz_to_color alpha, xyz[:x], xyz[:y], xyz[:z]
     end
 
-    def self.lab_to_xyz(l, a, b)
+    def lab_to_xyz(l, a, b)
       y = (l + 16) / 116
       x = y + (a / 500)
       z = y - (b / 200)
@@ -112,7 +114,7 @@ class PSD
       end
     end
 
-    def self.cmyk_to_rgb(c, m, y, k)
+    def cmyk_to_rgb(c, m, y, k)
       Hash[{
         r: (65535 - (c * (255 - k) + (k << 8))) >> 8,
         g: (65535 - (m * (255 - k) + (k << 8))) >> 8,

data/lib/psd/compose.rb

@@ -0,0 +1,357 @@
+class PSD
+  # Collection of methods that composes two RGBA pixels together
+  # in various ways based on Photoshop blend modes.
+  #
+  # Mostly based on similar code from libpsd.
+  module Compose
+    extend self
+
+    DEFAULT_OPTS = {
+      opacity: 255,
+      fill_opacity: 255
+    }
+
+    #
+    # Normal blend modes
+    #
+
+    # Normal composition, delegate to ChunkyPNG
+    def normal(fg, bg, opts={})
+      return fg if opaque?(fg) || fully_transparent?(bg)
+      return bg if fully_transparent?(fg)
+
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+      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)
+
+      rgba(new_r, new_g, new_b, dst_alpha)
+    end
+
+    #
+    # Subtractive blend modes
+    #
+
+    def darken(fg, bg, opts={})
+      return fg if fully_transparent?(bg)
+      return bg if fully_transparent?(fg)
+
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+      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)
+
+      rgba(new_r, new_g, new_b, dst_alpha)
+    end
+
+    def multiply(fg, bg, opts={})
+      return fg if fully_transparent?(bg)
+      return bg if fully_transparent?(fg)
+
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+      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)
+
+      rgba(new_r, new_g, new_b, dst_alpha)
+    end
+
+    def color_burn(fg, bg, opts={})
+      return fg if fully_transparent?(bg)
+      return bg if fully_transparent?(fg)
+
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+
+      calculate_foreground = Proc.new do |b, f|
+        if f > 0
+          f = ((255 - b) << 8) / f
+          f > 255 ? 0 : (255 - f)
+        else
+          b
+        end
+      end
+
+      new_r = blend_channel(r(bg), calculate_foreground.call(r(bg), r(fg)), mix_alpha)
+      new_g = blend_channel(g(bg), calculate_foreground.call(g(bg), g(fg)), mix_alpha)
+      new_b = blend_channel(b(bg), calculate_foreground.call(b(bg), b(fg)), mix_alpha)
+
+      rgba(new_r, new_g, new_b, dst_alpha)
+    end
+
+    def linear_burn(fg, bg, opts={})
+      return fg if fully_transparent?(bg)
+      return bg if fully_transparent?(fg)
+
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+
+      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)
+      new_b = blend_channel(b(bg), b(fg) < (255 - b(bg)) ? 0 : b(fg) - 255 - b(bg), mix_alpha)
+
+      rgba(new_r, new_g, new_b, dst_alpha)
+    end
+
+    #
+    # Additive blend modes
+    #
+
+    def lighten(fg, bg, opts={})
+      return fg if fully_transparent?(bg)
+      return bg if fully_transparent?(fg)
+
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+
+      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)
+      
+      rgba(new_r, new_g, new_b, dst_alpha)
+    end
+
+    def screen(fg, bg, opts={})
+      return fg if fully_transparent?(bg)
+      return bg if fully_transparent?(fg)
+
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+
+      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)
+      new_b = blend_channel(b(bg), 255 - ((255 - b(bg)) * (255 - b(fg)) >> 8), mix_alpha)
+
+      rgba(new_r, new_g, new_b, dst_alpha)
+    end
+
+    def color_dodge(fg, bg, opts={})
+      return fg if fully_transparent?(bg)
+      return bg if fully_transparent?(fg)
+
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+
+      calculate_foreground = Proc.new do |b, f|
+        f < 255 ? [(b << 8) / (255 - f), 255].min : b
+      end
+
+      new_r = blend_channel(r(bg), calculate_foreground.call(r(bg), r(fg)), mix_alpha)
+      new_g = blend_channel(g(bg), calculate_foreground.call(g(bg), g(fg)), mix_alpha)
+      new_b = blend_channel(b(bg), calculate_foreground.call(b(bg), b(fg)), mix_alpha)
+
+      rgba(new_r, new_g, new_b, dst_alpha)
+    end
+
+    def linear_dodge(fg, bg, opts={})
+      return fg if fully_transparent?(bg)
+      return bg if fully_transparent?(fg)
+
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+
+      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)
+      new_b = blend_channel(b(bg), (b(bg) + b(fg)) > 255 ? 255 : b(bg) + b(fg), mix_alpha)
+
+      rgba(new_r, new_g, new_b, dst_alpha)
+    end
+
+
+    #
+    # Contrasting blend modes
+    #
+
+    def overlay(fg, bg, opts={})
+      return fg if fully_transparent?(bg)
+      return bg if fully_transparent?(fg)
+
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+
+      calculate_foreground = Proc.new do |b, f|
+        if b < 128
+          b * f >> 7
+        else
+          255 - ((255 - b) * (255 - f) >> 7)
+        end
+      end
+
+      new_r = blend_channel(r(bg), calculate_foreground.call(r(bg), r(fg)), mix_alpha)
+      new_g = blend_channel(g(bg), calculate_foreground.call(g(bg), g(fg)), mix_alpha)
+      new_b = blend_channel(b(bg), calculate_foreground.call(b(bg), b(fg)), mix_alpha)
+
+      rgba(new_r, new_g, new_b, dst_alpha)
+    end
+
+    def soft_light(fg, bg, opts={})
+      return fg if fully_transparent?(bg)
+      return bg if fully_transparent?(fg)
+
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+
+      calculate_foreground = Proc.new do |b, f|
+        c1 = b * f >> 8
+        c2 = 255 - ((255 - b) * (255 - f) >> 8)
+        ((255 - b) * c1 >> 8) + (b * c2 >> 8)
+      end
+
+      new_r = blend_channel(r(bg), calculate_foreground.call(r(bg), r(fg)), mix_alpha)
+      new_g = blend_channel(g(bg), calculate_foreground.call(g(bg), g(fg)), mix_alpha)
+      new_b = blend_channel(b(bg), calculate_foreground.call(b(bg), b(fg)), mix_alpha)
+
+      rgba(new_r, new_g, new_b, dst_alpha)
+    end
+
+    def hard_light(fg, bg, opts={})
+      return fg if fully_transparent?(bg)
+      return bg if fully_transparent?(fg)
+
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+
+      calculate_foreground = Proc.new do |b, f|
+        if f < 128
+          b * f >> 7
+        else
+          255 - ((255 - f) * (255 - b) >> 7)
+        end
+      end
+
+      new_r = blend_channel(r(bg), calculate_foreground.call(r(bg), r(fg)), mix_alpha)
+      new_g = blend_channel(g(bg), calculate_foreground.call(g(bg), g(fg)), mix_alpha)
+      new_b = blend_channel(b(bg), calculate_foreground.call(b(bg), b(fg)), mix_alpha)
+
+      rgba(new_r, new_g, new_b, dst_alpha)
+    end
+
+    def vivid_light(fg, bg, opts={})
+      return fg if fully_transparent?(bg)
+      return bg if fully_transparent?(fg)
+
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+
+      calculate_foreground = Proc.new do |b, f|
+        if f < 255
+          [(b * b / (255 - f) + f * f / (255 - b)) >> 1, 255].min
+        else
+          b
+        end
+      end
+
+      new_r = blend_channel(r(bg), calculate_foreground.call(r(bg), r(fg)), mix_alpha)
+      new_g = blend_channel(g(bg), calculate_foreground.call(g(bg), g(fg)), mix_alpha)
+      new_b = blend_channel(b(bg), calculate_foreground.call(b(bg), b(fg)), mix_alpha)
+
+      rgba(new_r, new_g, new_b, dst_alpha)
+    end
+
+    def linear_light(fg, bg, opts={})
+      return fg if fully_transparent?(bg)
+      return bg if fully_transparent?(fg)
+
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+
+      calculate_foreground = Proc.new do |b, f|
+        if b < 255
+          [f * f / (255 - b), 255].min
+        else
+          255
+        end
+      end
+
+      new_r = blend_channel(r(bg), calculate_foreground.call(r(bg), r(fg)), mix_alpha)
+      new_g = blend_channel(g(bg), calculate_foreground.call(g(bg), g(fg)), mix_alpha)
+      new_b = blend_channel(b(bg), calculate_foreground.call(b(bg), b(fg)), mix_alpha)
+
+      rgba(new_r, new_g, new_b, dst_alpha)
+    end
+
+    def pin_light(fg, bg, opts={})
+      return fg if fully_transparent?(bg)
+      return bg if fully_transparent?(fg)
+
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+
+      calculate_foreground = Proc.new do |b, f|
+        if f >= 128
+          [b, (f - 128) * 2].max
+        else
+          [b, f * 2].min
+        end
+      end
+
+      new_r = blend_channel(r(bg), calculate_foreground.call(r(bg), r(fg)), mix_alpha)
+      new_g = blend_channel(g(bg), calculate_foreground.call(g(bg), g(fg)), mix_alpha)
+      new_b = blend_channel(b(bg), calculate_foreground.call(b(bg), b(fg)), mix_alpha)
+
+      rgba(new_r, new_g, new_b, dst_alpha)
+    end
+
+    def hard_mix(fg, bg, opts={})
+      return fg if fully_transparent?(bg)
+      return bg if fully_transparent?(fg)
+
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+
+      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)
+      new_b = blend_channel(b(bg), (b(bg) + b(fg) <= 255) ? 0 : 255, mix_alpha)
+
+      rgba(new_r, new_g, new_b, dst_alpha)
+    end
+
+    #
+    # Inversion blend modes
+    #
+
+    def difference(fg, bg, opts={})
+      return fg if fully_transparent?(bg)
+      return bg if fully_transparent?(fg)
+
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+
+      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)
+      new_b = blend_channel(b(bg), (b(bg) - b(fg)).abs, mix_alpha)
+
+      rgba(new_r, new_g, new_b, dst_alpha)
+    end
+
+    def exclusion(fg, bg, opts={})
+      return fg if fully_transparent?(bg)
+      return bg if fully_transparent?(fg)
+
+      mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
+
+      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)
+      new_b = blend_channel(b(bg), b(bg) + b(fg) - (b(bg) * b(fg) >> 7), mix_alpha)
+
+      rgba(new_r, new_g, new_b, dst_alpha)
+    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)
+      src_alpha = a(fg) * opacity >> 8
+      dst_alpha = a(bg)
+
+      mix_alpha = (src_alpha << 8) / (src_alpha + ((256 - src_alpha) * dst_alpha >> 8))
+      dst_alpha = dst_alpha + ((256 - dst_alpha) * src_alpha >> 8)
+
+      return mix_alpha, dst_alpha
+    end
+
+    def calculate_opacity(opts)
+      opts[:opacity] * opts[:fill_opacity] / 255
+    end
+
+    def blend_channel(bg, fg, alpha)
+      ((bg << 8) + (fg - bg) * alpha) >> 8
+    end
+
+    def blend_alpha(bg, fg)
+      bg + ((255 - bg) * fg >> 8)
+    end
+  end
+end