bench9000 0.1

data/vendor/psd.rb/lib/psd/nodes/build_preview.rb

@@ -0,0 +1,17 @@
+ class PSD
+  class Node
+    module BuildPreview
+      def renderer
+        PSD::Renderer.new(self)
+      end
+
+      def to_png
+        renderer.to_png
+      end
+
+      def save_as_png(output)
+        to_png.save(output)
+      end
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/nodes/has_children.rb

@@ -0,0 +1,13 @@
+class PSD
+  module HasChildren
+    # Returns all group/folder children of this node.
+    def groups
+      @children.select{ |c| c.is_a?(PSD::Group) }
+    end
+
+    # Returns all layer children of this node.
+    def layers
+      @children.select{ |c| c.is_a?(PSD::Layer) }
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/nodes/lock_to_origin.rb

@@ -0,0 +1,7 @@
+class PSD::Node
+  module LockToOrigin #:nodoc:
+    def lock_to_origin
+      translate(-left - 1, -top - 1)
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/nodes/parse_layers.rb

@@ -0,0 +1,18 @@
+class PSD::Node
+  module ParseLayers
+    # Organizes the flat layer structure into tree nodes.
+    def parse_layers(layers)
+      @children = []
+      layers.each do |layer|
+        if layer.is_a?(Hash)
+          node = PSD::Node::Group.new(layer)
+        elsif layer.is_a?(PSD::Layer)
+          node = PSD::Node::Layer.new(layer)
+        end
+
+        node.parent = self
+        @children << node
+      end
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/nodes/search.rb

@@ -0,0 +1,91 @@
+class PSD
+  class 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
+      # require unique layer/folder names, we always return an array of all
+      # found nodes.
+      def children_at_path(path, opts={})
+        path = path.split('/').delete_if { |p| p == "" } unless path.is_a?(Array)
+
+        query = path.shift
+        matches = children.select do |c|
+          if opts[:case_sensitive]
+            c.name == query
+          else
+            c.name.downcase == query.downcase
+          end
+        end
+
+        if path.length == 0
+          return matches
+        else
+          return matches.map { |m| m.children_at_path(path, opts) }.flatten
+        end
+      end
+      alias :children_with_path :children_at_path
+
+      # Given a layer comp ID, name, or :last for last document state, create a new
+      # 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
+          raise "Layer comp not found" if comp.nil?
+
+          id = comp[:id]
+        else
+          comp = psd.layer_comps.select { |c| c[:id] == id }.first
+          raise "Layer comp not found" if comp.nil?
+        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|
+          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?
+        end
+      end
+
+      def set_visibility(comp, c)
+        visible = true
+
+        c
+          .metadata
+          .data[:layer_comp]['layerSettings'].each do |l|
+            visible = l['enab'] if l.has_key?('enab')
+            break if l['compList'].include?(comp[:id])
+          end
+
+        c.force_visible = visible
+      end
+
+      def set_position(comp, c)
+        x = 0
+        y = 0
+
+        c
+          .metadata
+          .data[:layer_comp]['layerSettings'].each do |l|
+            next unless l.has_key?('Ofst')
+            
+            x = l['Ofst']['Hrzn']
+            y = l['Ofst']['Vrtc']
+            break if l['compList'].include?(comp[:id])
+          end
+
+        c.left += x
+        c.top += y
+      end
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/path_record.rb

@@ -0,0 +1,180 @@
+class PSD
+  # Parses a vector path
+  class PathRecord
+    attr_accessor :layer
+
+    # Facade to make it easier to parse the path record.
+    def self.read(layer)
+      pr = PSD::PathRecord.new(layer.file)
+      pr.layer = layer
+      pr
+    end
+
+    # Reads the record type and begins parsing accordingly.
+    def initialize(file)
+      @file = file
+
+      @record_type = @file.read_short
+
+      case @record_type
+      when 0, 3 then read_path_record
+      when 1, 2, 4, 5 then read_bezier_point
+      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
+      when 0, 3
+        {
+          num_points: @num_points
+        }
+      when 1, 2, 4, 5
+        {
+          linked: @linked,
+          preceding: {
+            vert: @preceding_vert,
+            horiz: @preceding_horiz
+          },
+          anchor: {
+            vert: @anchor_vert,
+            horiz: @anchor_horiz
+          },
+          leaving: {
+            vert: @leaving_vert,
+            horiz: @leaving_horiz
+          }
+        }
+      when 7
+        {
+          clipboard: {
+            top: @clipboard_top,
+            left: @clipboard_left,
+            bottom: @clipboard_bottom,
+            right: @clipboard_right,
+            resolution: @clipboard_resolution
+          }
+        }
+      when 8
+        {
+          initial_fill: @initial_fill
+        }
+      else
+        {}
+      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
+    end
+
+    private
+
+    def read_path_record
+      @num_points = @file.read_short
+      @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
+
+      @preceding_vert = @file.read_path_number
+      @preceding_horiz = @file.read_path_number
+
+      @anchor_vert = @file.read_path_number
+      @anchor_horiz = @file.read_path_number
+
+      @leaving_vert = @file.read_path_number
+      @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
+      @clipboard_bottom = @file.read_path_number
+      @clipboard_right = @file.read_path_number
+      @clipboard_resolution = @file.read_path_number
+      @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/vendor/psd.rb/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/vendor/psd.rb/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