psd 2.1.2 → 3.1.2

data/lib/psd/nodes/build_preview.rb

@@ -1,12 +1,12 @@
  class PSD
-  class Node
+  module Node
     module BuildPreview
-      def renderer
-        PSD::Renderer.new(self)
+      def renderer(opts = {})
+        PSD::Renderer.new(self, opts)
       end
 
       def to_png
-        renderer.to_png
+        @png ||= renderer.to_png
       end
 
       def save_as_png(output)

data/lib/psd/nodes/group.rb

@@ -0,0 +1,35 @@
+require 'psd/node'
+
+class PSD
+  module Node
+    # Represents a group, or folder, in the PSD document. It can have
+    # zero or more children nodes.
+    class Group < PSD::Node::Base
+      def passthru_blending?
+        blending_mode == 'passthru'
+      end
+
+      def empty?
+        children.each do |child|
+          return false unless child.empty?
+        end
+        
+        return true
+      end
+
+      # Export this layer and it's children to a hash recursively.
+      def to_hash
+        super.merge({
+          type: :group,
+          children: children.map(&:to_hash)
+        })
+      end
+
+      # If the method is missing, we blindly send it to the layer.
+      # The layer handles the case in which the method doesn't exist.
+      def method_missing(method, *args, &block)
+        @layer.send(method, *args, &block)
+      end
+    end
+  end
+end

data/lib/psd/nodes/layer.rb

@@ -0,0 +1,40 @@
+require 'psd/node'
+
+class PSD
+  module Node
+    class Layer < PSD::Node::Base
+      attr_reader :layer
+
+      [:text, :ref_x, :ref_y, :blending_mode].each do |prop|
+        delegate prop, to: :@layer
+        delegate "#{prop}=", to: :@layer
+      end
+
+      def empty?
+        width == 0 || height == 0
+      end
+
+      # Exports this layer to a Hash.
+      def to_hash
+        super.merge({
+          type: :layer,
+          text: @layer.text,
+          ref_x: @layer.reference_point.x,
+          ref_y: @layer.reference_point.y,
+          mask: @layer.mask.to_hash,
+          image: {
+            width: @layer.image.width,
+            height: @layer.image.height,
+            channels: @layer.channels_info
+          }
+        })
+      end
+
+      # If the method is missing, we blindly send it to the layer.
+      # The layer handles the case in which the method doesn't exist.
+      def method_missing(method, *args, &block)
+        @layer.send(method, *args, &block)
+      end
+    end
+  end
+end

data/lib/psd/nodes/root.rb

@@ -0,0 +1,90 @@
+require 'psd/node'
+
+class PSD
+  module Node
+    # Represents the root node of a Photoshop document
+    class Root < PSD::Node::Base
+      include Ancestry
+      include Search
+      include BuildPreview
+
+      attr_accessor :children
+      attr_reader :psd
+
+      alias_method :document_width, :width
+      alias_method :document_height, :height
+
+      RootLayer = Struct.new("RootLayer", :node, *Base::PROPERTIES)
+
+      def self.layer_for_psd(psd)
+        RootLayer.new.tap do |layer|
+          layer.top = 0
+          layer.left = 0
+          layer.right = psd.header.width.to_i
+          layer.bottom = psd.header.height.to_i
+        end
+      end
+
+      # Stores a reference to the parsed PSD and builds the
+      # tree hierarchy.
+      def initialize(psd)
+        super self.class.layer_for_psd(psd)
+
+        @psd = psd
+        build_hierarchy
+      end
+
+      # Returns the width and height of the entire PSD document.
+      def document_dimensions
+        [document_width, document_height]
+      end
+
+      # The depth of the root node is always 0.
+      def depth
+        0
+      end
+
+      def opacity; 255; end
+      def fill_opacity; 255; end
+
+      # Recursively exports the hierarchy to a Hash
+      def to_hash
+        {
+          children: children.map(&:to_hash),
+          document: {
+            width: document_width,
+            height: document_height,
+            resources: {
+              layer_comps: @psd.layer_comps,
+              guides: @psd.guides,
+              slices: @psd.slices
+            }
+          }
+        }
+      end
+
+      private
+
+      def build_hierarchy
+        current_group = self
+        parse_stack = []
+
+        # First we build the hierarchy
+        @psd.layers.each do |layer|
+          if layer.folder?
+            parse_stack.push current_group
+            current_group = PSD::Node::Group.new(layer, parse_stack.last)
+          elsif layer.folder_end?
+            parent = parse_stack.pop
+            parent.children.push current_group
+            current_group = parent
+          else
+            current_group.children.push PSD::Node::Layer.new(layer, current_group)
+          end
+        end
+
+        update_dimensions!
+      end
+    end
+  end
+end

data/lib/psd/nodes/search.rb

@@ -1,5 +1,5 @@
 class PSD
-  class Node
+  module Node
     module Search
       # Searches the tree structure for a node at the given path. The path is
       # defined by the layer/folder names. Because the PSD format does not
@@ -8,6 +8,7 @@ class PSD
       def children_at_path(path, opts={})
         path = path.split('/').delete_if { |p| p == "" } unless path.is_a?(Array)
 
+        path = path.dup
         query = path.shift
         matches = children.select do |c|
           if opts[:case_sensitive]
@@ -20,7 +21,7 @@ class PSD
         if path.length == 0
           return matches
         else
-          return matches.map { |m| m.children_at_path(path, opts) }.flatten
+          return matches.map { |m| m.children_at_path(path.dup, opts) }.flatten
         end
       end
       alias :children_with_path :children_at_path
@@ -39,34 +40,32 @@ class PSD
         end
 
         root = PSD::Node::Root.new(psd)
-        filter_for_comp!(comp, root)
-
-        return root
-      end
-
-      private
-
-      def filter_for_comp!(comp, node)
+        
         # Force layers to be visible if they are enabled for the comp
-        node.children.each do |c|
+        root.descendants.each do |c|
           set_visibility(comp, c) if Resource::Section::LayerComps.visibility_captured?(comp)
           set_position(comp, c) if Resource::Section::LayerComps.position_captured?(comp)
 
-          filter_for_comp!(comp, c) if c.group?
+          PSD.logger.debug "#{c.path}: visible = #{c.visible?}, position = #{c.left}, #{c.top}"
         end
+
+        return root
       end
 
+      private
+
       def set_visibility(comp, c)
         visible = true
+        found = false
 
         c
           .metadata
           .data[:layer_comp]['layerSettings'].each do |l|
             visible = l['enab'] if l.has_key?('enab')
-            break if l['compList'].include?(comp[:id])
+            found = true and break if l['compList'].include?(comp[:id])
           end
 
-        c.force_visible = visible
+        c.force_visible = found && visible
       end
 
       def set_position(comp, c)
@@ -76,15 +75,16 @@ class PSD
         c
           .metadata
           .data[:layer_comp]['layerSettings'].each do |l|
-            next unless l.has_key?('Ofst')
+            if l.has_key?('Ofst')
+              x = l['Ofst']['Hrzn']
+              y = l['Ofst']['Vrtc']
+            end
             
-            x = l['Ofst']['Hrzn']
-            y = l['Ofst']['Vrtc']
             break if l['compList'].include?(comp[:id])
           end
 
-        c.left += x
-        c.top += y
+        c.left_offset = x
+        c.top_offset = y
       end
     end
   end

data/lib/psd/path_record.rb

@@ -25,22 +25,6 @@ class PSD
       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 +35,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 +68,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 +80,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,15 +93,6 @@ 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
-    end
-
     def read_clipboard_record
       @clipboard_top = @file.read_path_number
       @clipboard_left = @file.read_path_number
@@ -159,22 +102,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

data/lib/psd/renderer.rb

@@ -1,11 +1,12 @@
-require_relative 'renderer/canvas_management'
+require 'psd/renderer/canvas_management'
 
 class PSD
   class Renderer
     include CanvasManagement
 
-    def initialize(node)
+    def initialize(node, opts = {})
       @root_node = node
+      @opts = opts
 
       # Our canvas always starts as the full document size because
       # all measurements are relative to this size. We can later crop
@@ -23,7 +24,7 @@ class PSD
       PSD.logger.debug "Beginning render process"
 
       # Create our base canvas
-      create_group_canvas(active_node, active_node.width, active_node.height)
+      create_group_canvas(active_node, active_node.width, active_node.height, base: true)
 
       # Begin the rendering process
       execute_pipeline
@@ -34,7 +35,7 @@ class PSD
     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?
+        # We skip over hidden nodes.
         next unless child.visible?
 
         if child.group?
@@ -56,7 +57,7 @@ class PSD
           pop_node and next
         end
 
-        canvas = Canvas.new(child)
+        canvas = Canvas.new(child, nil, nil, @opts)
         canvas.paint_to active_canvas
       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