psd 1.5.0 → 2.0.0

data/lib/psd/nodes/search.rb

@@ -26,7 +26,7 @@ class PSD
       alias :children_with_path :children_at_path
 
       # Given a layer comp ID, name, or :last for last document state, create a new
-      # tree based on the layers/groups that belong to the comp only.
+      # tree with layer/group visibility altered based on the layer comp.
       def filter_by_comp(id)
         if id.is_a?(String)
           comp = psd.layer_comps.select { |c| c[:name] == id }.first
@@ -46,18 +46,19 @@ class PSD
       private
 
       def filter_for_comp!(id, node)
-        node.children.select! do |c|
+        # Force layers to be visible if they are enabled for the comp
+        node.children.each do |c|
+          enabled = c.visible?
+
           c
             .metadata
-            .data[:layer_comp]['layerSettings'].map { |l| !l.has_key?('enab') || l['enab'] == true ? l['compList'] : nil }
-            .flatten
-            .compact
-            .include?(id)
-        end
+            .data[:layer_comp]['layerSettings'].each do |l|
+              enabled = l['enab'] if l.has_key?('enab')
+              break if l['compList'].include?(id)
+            end
 
-        node.children.each do |c|
-          c.force_visible = true
-          filter_for_comp!(id, c) if c.is_a?(PSD::Node::Group)
+          c.force_visible = enabled
+          filter_for_comp!(id, c) if c.group?
         end
       end
     end

data/lib/psd/renderer.rb

@@ -0,0 +1,91 @@
+require_relative 'renderer/canvas_management'
+
+class PSD
+  class Renderer
+    include CanvasManagement
+
+    def initialize(node)
+      @root_node = node
+
+      # Our canvas always starts as the full document size because
+      # all measurements are relative to this size. We can later crop
+      # the image if needed.
+      @width = @root_node.document_dimensions[0].to_i
+      @height = @root_node.document_dimensions[1].to_i
+
+      @canvas_stack = []
+      @node_stack = [@root_node]
+
+      @rendered = false
+    end
+
+    def render!
+      PSD.logger.debug "Beginning render process"
+
+      # Create our base canvas
+      create_group_canvas(active_node, active_node.width, active_node.height)
+
+      # Begin the rendering process
+      execute_pipeline
+
+      @rendered = true
+    end
+
+    def execute_pipeline
+      PSD.logger.debug "Executing pipeline on #{active_node.debug_name}"
+      children.reverse.each do |child|
+        # We skip over hidden nodes. Maybe something configurable in the future?
+        next unless child.visible?
+
+        if child.group?
+          push_node(child)
+
+          if child.passthru_blending?
+            PSD.logger.debug "#{child.name} is a group with passthru blending"
+            execute_pipeline
+          else
+            PSD.logger.debug "#{child.name} is a group with #{child.blending_mode} blending"
+            
+            create_group_canvas(child)
+            execute_pipeline
+            
+            child_canvas = pop_canvas
+            child_canvas.paint_to active_canvas
+          end
+
+          pop_node and next
+        end
+
+        canvas = Canvas.new(child)
+        canvas.paint_to active_canvas
+      end
+    end
+
+    def to_png
+      render! unless @rendered
+      active_canvas.canvas
+    end
+
+    private
+
+    def children
+      if active_node.layer?
+        [active_node]
+      else
+        active_node.children
+      end
+    end
+
+    def push_node(node)
+      @node_stack << node
+    end
+
+    def pop_node
+      @node_stack.pop
+    end
+
+    def active_node
+      @node_stack.last
+    end
+  end
+end

data/lib/psd/renderer/blender.rb

@@ -0,0 +1,53 @@
+class PSD
+  class Renderer
+    class Blender
+      attr_reader :fg, :bg
+
+      # Takes a foreground Canvas and a background Canvas
+      def initialize(fg, bg)
+        @fg = fg
+        @bg = bg
+
+        @opacity = @fg.opacity.to_i
+        @fill_opacity = @fg.fill_opacity.to_i
+        PSD.logger.debug "Blender: name = #{fg.node.name}, opacity = #{@opacity}, fill opacity = #{@fill_opacity}"
+      end
+
+      # 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"
+
+        offset_x = fg.left - bg.left
+        offset_y = fg.top - bg.top
+
+        fg.height.times do |y|
+          fg.width.times do |x|
+            base_x = x + offset_x
+            base_y = y + offset_y
+
+            next if base_x < 0 || base_y < 0 || base_x >= bg.width || base_y >= bg.height
+
+            color = Compose.send(
+              fg.node.blending_mode,
+              fg.canvas[x, y],
+              bg.canvas[base_x, base_y],
+              compose_options
+            )
+
+            bg.canvas[base_x, base_y] = color
+          end
+        end
+      end
+
+      private
+
+      def compose_options
+        {
+          opacity: @opacity,
+          fill_opacity: @fill_opacity
+        }
+      end
+    end
+  end
+end

data/lib/psd/renderer/canvas.rb

@@ -0,0 +1,95 @@
+class PSD
+  class Renderer
+    class Canvas
+      attr_reader :canvas, :node, :width, :height, :left, :right, :top, :bottom, :opacity, :fill_opacity
+
+      def initialize(node, width = nil, height = nil, color = ChunkyPNG::Color::TRANSPARENT)
+        @node = node
+        @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?
+      end
+
+      def paint_to(base)
+        PSD.logger.debug "Painting #{node.name} to #{base.node.debug_name}"
+
+        apply_mask
+        apply_clipping_mask
+        apply_layer_styles
+        apply_layer_opacity
+        compose_pixels(base)
+      end
+
+      def canvas=(canvas)
+        @canvas = canvas
+        @width = @canvas.width
+        @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
+
+      private
+
+      def initialize_canvas
+        PSD.logger.debug "Initializing canvas for #{node.debug_name}"
+
+        # Sorry, ChunkyPNG.
+        @canvas.send(:replace_canvas!, width, height, @pixel_data)
+
+        # This can now be referenced by @canvas.pixels
+        @pixel_data = nil
+      end
+
+      def apply_mask
+        return unless @node.image.has_mask?
+
+        PSD.logger.debug "Applying layer mask to #{node.name}"
+        Mask.new(self).apply!
+      end
+
+      def apply_clipping_mask
+        return unless @node.clipped?
+        ClippingMask.new(self).apply!
+      end
+
+      def apply_layer_styles
+        PSD.logger.debug "Applying layer styles to #{node.name}"
+        LayerStyles.new(self).apply!
+      end
+
+      def apply_layer_opacity
+        return if @node.root?
+        PSD.logger.debug "Adjusting opacity for #{node.name}"
+        
+        @node.ancestors.each do |parent|
+          break unless parent.passthru_blending?
+          @opacity = (@opacity * parent.opacity.to_f) / 255.0
+        end
+
+        PSD.logger.debug "Inherited opacity for #{@node.debug_name} is #{@opacity}"
+        @opacity = @opacity.to_i
+      end
+
+      def compose_pixels(base)
+        Blender.new(self, base).compose!
+      end
+    end
+  end
+end

data/lib/psd/renderer/canvas_management.rb

@@ -0,0 +1,26 @@
+class PSD
+  class Renderer
+    module CanvasManagement
+      def active_canvas
+        @canvas_stack.last
+      end
+
+      def create_group_canvas(node, width=@width, height=@height)
+        PSD.logger.debug "Group canvas created. Node = #{node.name || ":root:"}, width = #{width}, height = #{height}"
+        push_canvas Canvas.new(node, width, height)
+      end
+
+      def push_canvas(canvas)
+        @canvas_stack << canvas
+      end
+
+      def pop_canvas
+        @canvas_stack.pop
+      end
+
+      def stack_inspect
+        @canvas_stack.map { |c| c.node.name || ":root:" }.join("\n")
+      end
+    end
+  end
+end

data/lib/psd/renderer/clipping_mask.rb

@@ -0,0 +1,41 @@
+class PSD
+  class Renderer
+    class ClippingMask
+      attr_reader :canvas, :mask
+
+      def initialize(canvas)
+        @canvas = canvas
+        @node = @canvas.node
+        
+        mask_node = @canvas.node.next_sibling
+        @mask = Canvas.new(mask_node)
+      end
+
+      def apply!
+        return unless @node.clipped?
+
+        PSD.logger.debug "Applying clipping mask #{mask.node.name} to #{@node.name}"
+
+        @canvas.height.times do |y|
+          @canvas.width.times do |x|
+            doc_x = @canvas.left + x
+            doc_y = @canvas.top + y
+
+            mask_x = doc_x - @mask.left
+            mask_y = doc_y - @mask.top
+
+            if mask_x < 0 || mask_x > mask.width || mask_y < 0 || mask_y > mask.height
+              alpha = 0
+            else
+              pixel = mask.canvas.pixels[mask_y * mask.width + mask_x]
+              alpha = pixel.nil? ? 0 : ChunkyPNG::Color.a(pixel)
+            end
+            
+            color = @canvas[x, y]
+            @canvas[x, y] = (color & 0xffffff00) | (ChunkyPNG::Color.a(color) * alpha / 255)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/psd/{compose.rb → renderer/compose.rb}

@@ -15,9 +15,8 @@ class PSD
     # Normal blend modes
     #
 
-    # Normal composition, delegate to ChunkyPNG
     def normal(fg, bg, opts={})
-      return fg if fully_transparent?(bg)
+      return apply_opacity(fg, opts) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
       mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
@@ -27,13 +26,14 @@ class PSD
 
       rgba(new_r, new_g, new_b, dst_alpha)
     end
+    alias_method :passthru, :normal
 
     #
     # Subtractive blend modes
     #
 
     def darken(fg, bg, opts={})
-      return fg if fully_transparent?(bg)
+      return apply_opacity(fg, opts) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
       mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
@@ -45,7 +45,7 @@ class PSD
     end
 
     def multiply(fg, bg, opts={})
-      return fg if fully_transparent?(bg)
+      return apply_opacity(fg, opts) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
       mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
@@ -57,7 +57,7 @@ class PSD
     end
 
     def color_burn(fg, bg, opts={})
-      return fg if fully_transparent?(bg)
+      return apply_opacity(fg, opts) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
       mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
@@ -79,7 +79,7 @@ class PSD
     end
 
     def linear_burn(fg, bg, opts={})
-      return fg if fully_transparent?(bg)
+      return apply_opacity(fg, opts) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
       mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
@@ -96,7 +96,7 @@ class PSD
     #
 
     def lighten(fg, bg, opts={})
-      return fg if fully_transparent?(bg)
+      return apply_opacity(fg, opts) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
       mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
@@ -109,7 +109,7 @@ class PSD
     end
 
     def screen(fg, bg, opts={})
-      return fg if fully_transparent?(bg)
+      return apply_opacity(fg, opts) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
       mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
@@ -122,7 +122,7 @@ class PSD
     end
 
     def color_dodge(fg, bg, opts={})
-      return fg if fully_transparent?(bg)
+      return apply_opacity(fg, opts) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
       mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
@@ -139,7 +139,7 @@ class PSD
     end
 
     def linear_dodge(fg, bg, opts={})
-      return fg if fully_transparent?(bg)
+      return apply_opacity(fg, opts) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
       mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
@@ -157,7 +157,7 @@ class PSD
     #
 
     def overlay(fg, bg, opts={})
-      return fg if fully_transparent?(bg)
+      return apply_opacity(fg, opts) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
       mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
@@ -178,7 +178,7 @@ class PSD
     end
 
     def soft_light(fg, bg, opts={})
-      return fg if fully_transparent?(bg)
+      return apply_opacity(fg, opts) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
       mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
@@ -197,7 +197,7 @@ class PSD
     end
 
     def hard_light(fg, bg, opts={})
-      return fg if fully_transparent?(bg)
+      return apply_opacity(fg, opts) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
       mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
@@ -218,7 +218,7 @@ class PSD
     end
 
     def vivid_light(fg, bg, opts={})
-      return fg if fully_transparent?(bg)
+      return apply_opacity(fg, opts) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
       mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
@@ -239,7 +239,7 @@ class PSD
     end
 
     def linear_light(fg, bg, opts={})
-      return fg if fully_transparent?(bg)
+      return apply_opacity(fg, opts) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
       mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
@@ -260,7 +260,7 @@ class PSD
     end
 
     def pin_light(fg, bg, opts={})
-      return fg if fully_transparent?(bg)
+      return apply_opacity(fg, opts) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
       mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
@@ -281,7 +281,7 @@ class PSD
     end
 
     def hard_mix(fg, bg, opts={})
-      return fg if fully_transparent?(bg)
+      return apply_opacity(fg, opts) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
       mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
@@ -298,7 +298,7 @@ class PSD
     #
 
     def difference(fg, bg, opts={})
-      return fg if fully_transparent?(bg)
+      return apply_opacity(fg, opts) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
       mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
@@ -311,7 +311,7 @@ class PSD
     end
 
     def exclusion(fg, bg, opts={})
-      return fg if fully_transparent?(bg)
+      return apply_opacity(fg, opts) if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
       mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))
@@ -346,6 +346,10 @@ class PSD
       opts[:opacity] * opts[:fill_opacity] / 255
     end
 
+    def apply_opacity(color, opts)
+      (color & 0xffffff00) | ((color & 0x000000ff) * calculate_opacity(opts) / 255)
+    end
+
     def blend_channel(bg, fg, alpha)
       ((bg << 8) + (fg - bg) * alpha) >> 8
     end