psd 2.1.2 → 3.9.0

data/lib/psd/renderer/layer_styles/color_overlay.rb

@@ -1,8 +1,26 @@
 class PSD
   class LayerStyles
     class ColorOverlay
-      def self.should_apply?(data)
-        data.has_key?('SoFi')
+      # TODO: CMYK support
+      def self.should_apply?(canvas, data)
+        data.has_key?('SoFi') && 
+        data['SoFi']['enab'] &&
+        canvas.node.header.rgb?
+      end
+
+      def self.can_apply?(canvas, data)
+        data.has_key?('SoFi') && 
+        data['SoFi']['enab'] &&
+        canvas.node.header.rgb?
+      end
+
+      def self.for_canvas(canvas)
+        data = canvas.node.object_effects
+        return nil if data.nil?
+        return nil unless can_apply?(canvas, data.data)
+
+        styles = LayerStyles.new(canvas)
+        self.new(styles)
       end
 
       def initialize(styles)
@@ -12,41 +30,22 @@ class PSD
       end
 
       def apply!
-        # TODO - implement CMYK color overlay
-        return if @node.header.cmyk?
-
-        width = @canvas.width
-        height = @canvas.height
-
-        # puts width, height
-        # puts @canvas.canvas.width, @canvas.canvas.height
-
         PSD.logger.debug "Layer style: layer = #{@node.name}, type = color overlay, blend mode = #{blending_mode}"
 
-        height.times do |y|
-          width.times do |x|
+        @canvas.height.times do |y|
+          @canvas.width.times do |x|
             pixel = @canvas[x, y]
             alpha = ChunkyPNG::Color.a(pixel)
             next if alpha == 0
 
-            overlay_color = ChunkyPNG::Color.rgba(r, g, b, alpha)
-            @canvas[x, y] = Compose.send(blending_mode, overlay_color, pixel)
+            new_pixel = Compose.send(blending_mode, overlay_color, pixel, overlay_opacity)
+            @canvas[x, y] = (new_pixel & 0xFFFFFF00) | alpha
           end
         end
       end
 
-      private
-
-      def blending_mode
-        @blending_mode ||= BlendMode::BLEND_MODES[BLEND_TRANSLATION[overlay_data['Md  ']].to_sym]
-      end
-
-      def overlay_data
-        @data['SoFi']
-      end
-
-      def color_data
-        overlay_data['Clr ']
+      def overlay_color
+        @overlay_color ||= ChunkyPNG::Color.rgb(r, g, b)
       end
 
       def r
@@ -60,6 +59,25 @@ class PSD
       def b
         @b ||= color_data['Bl  '].round
       end
+
+      def a
+        @a ||= (overlay_data['Opct'][:value] * 2.55).ceil
+      end
+      alias_method :overlay_opacity, :a
+
+      private
+
+      def blending_mode
+        @blending_mode ||= BlendMode::BLEND_MODES[BLEND_TRANSLATION[overlay_data['Md  '][:value]].to_sym]
+      end
+
+      def overlay_data
+        @data['SoFi']
+      end
+
+      def color_data
+        overlay_data['Clr ']
+      end
     end
   end
 end

data/lib/psd/renderer/layer_styles.rb

@@ -1,5 +1,4 @@
-require_relative 'layer_styles/color_overlay'
-require_relative 'layer_styles/drop_shadow'
+require 'psd/renderer/layer_styles/color_overlay'
 
 class PSD
   class LayerStyles
@@ -31,12 +30,16 @@ class PSD
       'Lmns' => 'lum'
     }.freeze
 
+    SUPPORTED_STYLES = [
+      ColorOverlay
+    ]
+
     attr_reader :canvas, :node, :data
 
     def initialize(canvas)
       @canvas = canvas
       @node = @canvas.node
-      @data = @node.layer.info[:object_effects]
+      @data = @node.object_effects
 
       if @data.nil?
         @applied = true
@@ -48,9 +51,16 @@ class PSD
 
     def apply!
       return if @applied || data.nil?
+      return unless styles_enabled?
+
+      SUPPORTED_STYLES.each do |style|
+        next unless style.should_apply?(@canvas, data)
+        style.new(self).apply!
+      end
+    end
 
-      ColorOverlay.new(self).apply! if ColorOverlay.should_apply?(data)
-      DropShadow.new(self).apply!   if DropShadow.should_apply?(data)
+    def styles_enabled?
+      data['masterFXSwitch']
     end
   end
 end

data/lib/psd/renderer/mask.rb

@@ -3,11 +3,18 @@ class PSD
     class Mask
       attr_accessor :mask_data
 
-      def initialize(canvas)
+      def initialize(canvas, mask_layer = nil)
         @canvas = canvas
         @layer = canvas.node
+        @mask_layer = mask_layer || @layer
 
-        @mask_data = @layer.image.mask_data
+        @mask_data = @mask_layer.image.mask_data
+        @mask = @mask_layer.mask
+
+        @mask_width = @mask.width.to_i
+        @mask_height = @mask.height.to_i
+        @mask_left = @mask.left.to_i + @mask_layer.left_offset
+        @mask_top = @mask.top.to_i + @mask_layer.top_offset
 
         @doc_width = @layer.header.width.to_i
         @doc_height = @layer.header.height.to_i
@@ -15,29 +22,26 @@ class PSD
 
       def apply!
         PSD.logger.debug "Applying mask to #{@layer.name}"
-        
-        # Now we apply the mask
-        i = 0
-        @layer.mask.height.times do |y|
-          @layer.mask.width.times do |x|
-            doc_x = @layer.mask.left + x
-            doc_y = @layer.mask.top + y
-
-            layer_x = doc_x - @layer.left
-            layer_y = doc_y - @layer.top
-
-            next unless @canvas.canvas.include_xy?(layer_x, layer_y)
-            color = ChunkyPNG::Color.to_truecolor_alpha_bytes(@canvas[layer_x, layer_y])
-
-            # We're off the document canvas. Crop.
-            if doc_x < 0 || doc_x > @doc_width || doc_y < 0 || doc_y > @doc_height
+
+        @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
+
+            color = ChunkyPNG::Color.to_truecolor_alpha_bytes(@canvas.get_pixel(x, y))
+
+            if doc_x < 0 || doc_x >= @doc_width || doc_y < 0 || doc_y >= @doc_height
+              color[3] = 0
+            elsif mask_x < 0 || mask_x >= @mask_width || mask_y < 0 || mask_y >= @mask_height
               color[3] = 0
             else
-              color[3] = color[3] * @mask_data[i] / 255
-            end 
+              color[3] = color[3] * @mask_data[@mask_width * mask_y + mask_x] / 255
+            end
 
-            @canvas[layer_x, layer_y] = ChunkyPNG::Color.rgba(*color)
-            i += 1
+            @canvas.set_pixel x, y, ChunkyPNG::Color.rgba(*color)
           end
         end
       end

data/lib/psd/renderer/mask_canvas.rb

@@ -0,0 +1,12 @@
+require 'psd/renderer/canvas'
+
+class PSD
+  class Renderer
+    class MaskCanvas < Canvas
+      def initialize(node, width = nil, height = nil, opts = {})
+        super
+        apply_masks
+      end
+    end
+  end
+end

data/lib/psd/renderer/vector_shape.rb

@@ -0,0 +1,239 @@
+require 'psd/renderer/cairo_helpers'
+
+class PSD
+  class Renderer
+    class VectorShape
+      include CairoHelpers
+
+      def self.can_render?(canvas)
+        canvas.opts[:render_vectors] && !canvas.node.vector_mask.nil?
+      end
+
+      DPI = 72.0.freeze
+
+      def initialize(canvas)
+        @canvas = canvas
+        @node = @canvas.node
+        @path = @node.vector_mask.paths.map(&:to_hash)
+
+        @stroke_data = @node.vector_stroke ? @node.vector_stroke.data : {}
+        @fill_data = @node.vector_stroke_content ? @node.vector_stroke_content.data : {}
+
+        @paths = []
+      end
+
+      def render!
+        PSD.logger.debug "Beginning vector render for #{@node.name}"
+
+        find_points
+        render_shapes
+      end
+
+      private
+
+      def find_points
+        PSD.logger.debug "Formatting vector points..."
+
+        cur_path = nil
+        @path.each do |data|
+          next if [6, 7, 8].include? data[:record_type]
+          
+          if [0, 3].include? data[:record_type]
+            @paths << cur_path
+            cur_path = []
+            next
+          end
+
+          cur_path << data.tap do |d|
+            if [1, 2, 4, 5].include? data[:record_type]
+              [:preceding, :anchor, :leaving].each do |type|
+                d[type][:horiz] = (d[type][:horiz] * horiz_factor) - @node.left
+                d[type][:vert]  = (d[type][:vert] * vert_factor) - @node.top
+              end
+            end
+          end
+        end
+
+        @paths << cur_path
+        @paths.compact!
+
+        PSD.logger.debug "Vector shape has #{@paths.size} path(s)"
+      end
+
+      # TODO: stroke alignment
+      # Right now we assume the stroke style is always a overlap stroke.
+      def render_shapes
+        PSD.logger.debug "Rendering #{@paths.size} vector paths with cairo"
+
+        cairo_image_surface(@canvas.width + stroke_size, @canvas.height + stroke_size) do |cr|
+          cr.set_fill_rule Cairo::FILL_RULE_EVEN_ODD
+          cr.set_line_join stroke_join
+          cr.set_line_cap stroke_cap
+
+          cr.translate stroke_size / 2.0, stroke_size / 2.0
+
+          @paths.each do |path|
+            cr.move_to path[0][:anchor][:horiz], path[0][:anchor][:vert]
+
+            path.size.times do |i|
+              point_a = path[i]
+              point_b = path[i+1] || path[0]
+
+              cr.curve_to(
+                point_a[:leaving][:horiz],
+                point_a[:leaving][:vert],
+                point_b[:preceding][:horiz],
+                point_b[:preceding][:vert],
+                point_b[:anchor][:horiz],
+                point_b[:anchor][:vert]
+              )
+            end
+
+            cr.close_path if path.last[:closed]
+          end
+
+          cr.set_source_rgba fill_color
+          cr.fill_preserve
+
+          if has_stroke?
+            cr.set_source_rgba stroke_color
+            cr.set_line_width stroke_size
+            cr.stroke
+          end
+        end
+      end
+
+      # For debugging purposes only
+      def draw_debug(canvas)
+        @paths.each do |path|
+          path.each do |point|
+            canvas.circle(point[:anchor][:horiz].to_i, point[:anchor][:vert].to_i, 3, ChunkyPNG::Color::BLACK, ChunkyPNG::Color::BLACK)
+            [:leaving, :preceding].each do |type|
+              canvas.circle(point[type][:horiz].to_i, point[type][:vert].to_i, 3, ChunkyPNG::Color.rgb(255, 0, 0), ChunkyPNG::Color.rgb(255, 0, 0))
+              canvas.line(
+                point[:anchor][:horiz].to_i, point[:anchor][:vert].to_i,
+                point[type][:horiz].to_i, point[type][:vert].to_i,
+                ChunkyPNG::Color::BLACK
+              )
+            end
+          end
+        end
+      end
+
+      def apply_to_canvas(output)
+        # draw_debug(output)
+        output.resample_nearest_neighbor!(@canvas.width, @canvas.height)
+        @canvas.canvas.compose!(output, 0, 0)
+      end
+
+      def formatted_points
+        @formatted_points ||= @curve_points.map(&:to_a)
+      end
+
+      def horiz_factor
+        @horiz_factor ||= @node.root.width.to_f
+      end
+
+      def vert_factor
+        @vert_factor ||= @node.root.height.to_f
+      end
+
+      def stroke_color
+        @stroke_color ||= (
+          if @stroke_data['strokeEnabled']
+            colors = @stroke_data['strokeStyleContent']['Clr ']
+            [
+              colors['Rd  '] / 255.0,
+              colors['Grn '] / 255.0,
+              colors['Bl  '] / 255.0,
+              @stroke_data['strokeStyleOpacity'][:value] / 100.0
+            ]
+          else
+            [0.0, 0.0, 0.0, 0.0]
+          end
+        )
+      end
+
+      def fill_color
+        @fill_color ||= (
+          overlay = PSD::LayerStyles::ColorOverlay.for_canvas(@canvas)
+          
+          if overlay
+            [
+              overlay.r / 255.0,
+              overlay.g / 255.0,
+              overlay.b / 255.0,
+              overlay.a / 255.0
+            ]
+          elsif @stroke_data['fillEnabled']
+            colors = @fill_data['Clr ']
+            [
+              colors['Rd  '] / 255.0,
+              colors['Grn '] / 255.0,
+              colors['Bl  '] / 255.0,
+              @stroke_data['strokeStyleOpacity'][:value] / 100.0
+            ]
+          elsif !@node.solid_color.nil?
+            [
+              @node.solid_color.r / 255.0,
+              @node.solid_color.g / 255.0,
+              @node.solid_color.b / 255.0,
+              1.0
+            ]
+          else
+            [0.0, 0.0, 0.0, 0.0]
+          end
+        )
+      end
+
+      def stroke_size
+        @stroke_size ||= (
+          if @stroke_data['strokeStyleLineWidth']
+            value = @stroke_data['strokeStyleLineWidth'][:value]
+
+            # Convert to pixels
+            if @stroke_data['strokeStyleLineWidth'][:id] == '#Pnt'
+              value = @stroke_data['strokeStyleResolution'] * value / 72.27
+            end
+
+            value.to_i
+          else
+            0
+          end
+        )
+      end
+
+      def stroke_cap
+        @stroke_cap ||= (
+          if @stroke_data['strokeStyleLineCapType']
+            case @stroke_data['strokeStyleLineCapType']
+            when 'strokeStyleButtCap' then Cairo::LINE_CAP_BUTT
+            when 'strokeStyleRoundCap' then Cairo::LINE_CAP_ROUND
+            when 'strokeStyleSquareCap' then Cairo::LINE_CAP_SQUARE
+            end
+          else
+            Cairo::LINE_CAP_BUTT
+          end
+        )
+      end
+
+      def stroke_join
+        @stroke_join ||= (
+          if @stroke_data['strokeStyleLineJoinType']
+            case @stroke_data['strokeStyleLineJoinType']
+            when 'strokeStyleMiterJoin' then Cairo::LINE_JOIN_MITER
+            when 'strokeStyleRoundJoin' then Cairo::LINE_JOIN_ROUND
+            when 'strokeStyleBevelJoin' then Cairo::LINE_JOIN_BEVEL
+            end
+          else
+            Cairo::LINE_JOIN_MITER
+          end
+        )
+      end
+
+      def has_stroke?
+        stroke_size > 0
+      end
+    end
+  end
+end

data/lib/psd/renderer.rb

@@ -1,11 +1,20 @@
-require_relative 'renderer/canvas_management'
+require 'psd/renderer/blender'
+require 'psd/renderer/canvas'
+require 'psd/renderer/canvas_management'
+require 'psd/renderer/clipping_mask'
+require 'psd/renderer/compose'
+require 'psd/renderer/layer_styles'
+require 'psd/renderer/mask'
+require 'psd/renderer/mask_canvas'
 
 class PSD
   class Renderer
     include CanvasManagement
 
-    def initialize(node)
+    def initialize(node, opts = {})
       @root_node = node
+      @opts = opts
+      @render_hidden = opts.delete(:render_hidden)
 
       # Our canvas always starts as the full document size because
       # all measurements are relative to this size. We can later crop
@@ -23,7 +32,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,8 +43,10 @@ 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?
-        next unless child.visible?
+        # We skip over hidden nodes unless explicitly set otherwise.
+        # If rendering a single PSD::Node::Layer, this is automatically
+        # set so that hidden layers will render.
+        next if !@render_hidden && !child.visible?
 
         if child.group?
           push_node(child)
@@ -56,7 +67,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
@@ -88,4 +99,4 @@ class PSD
       @node_stack.last
     end
   end
-end
+end

data/lib/psd/resource_section.rb

@@ -1,10 +1,18 @@
 class PSD
   class Resource
-    class Section
+    module Section
       def self.factory(file, resource)
+        if path_resource?(resource)
+          section = Section::SavedPath.new(file, resource)
+          section.parse
+          return section.name
+        end
+
         Section.constants.each do |c|
+          next if c == :Base
+
           section = Section.const_get(c)
-          next unless section.id == resource.id
+          next unless section.resource_id == resource.id
 
           section.new(file, resource).parse
           return section.name
@@ -13,10 +21,9 @@ class PSD
         return nil
       end
 
-      def initialize(file, resource)
-        @file = file
-        @resource = resource
+      def self.path_resource?(resource)
+        resource.id >= 2000 && resource.id <= 2997
       end
     end
   end
-end
+end

data/lib/psd/resources/base.rb

@@ -0,0 +1,33 @@
+class PSD
+  class Resource
+    module Section
+      class Base
+        def self.resource_id(id = nil)
+          @resource_id = id unless id.nil?
+          @resource_id
+        end
+
+        def self.name(name = nil)
+          @name = name unless name.nil?
+          @name
+        end
+
+        def initialize(file, resource)
+          @file = file
+          @resource = resource
+        end
+
+        def resource_id; self.class.resource_id; end
+        def name; self.class.name; end
+      end
+    end
+  end
+end
+
+require 'psd/resources/guides'
+require 'psd/resources/layer_comps'
+require 'psd/resources/resolution_info'
+require 'psd/resources/saved_path'
+require 'psd/resources/slices'
+require 'psd/resources/work_path'
+require 'psd/resources/xmp_metadata'

data/lib/psd/resources/guides.rb

@@ -1,9 +1,11 @@
+require 'psd/resources/base'
+
 class PSD
   class Resource
-    class Section
-      class Guides < Section
-        def self.id; 1032; end
-        def self.name; :guides; end
+    module Section
+      class Guides < Base
+        resource_id 1032
+        name :guides
 
         def parse
           # Descriptor version

data/lib/psd/resources/layer_comps.rb

@@ -1,9 +1,11 @@
+require 'psd/resources/base'
+
 class PSD
   class Resource
-    class Section
-      class LayerComps < Section
-        def self.id; 1065; end
-        def self.name; :layer_comps; end
+    module Section
+      class LayerComps < Base
+        resource_id 1065
+        name :layer_comps
 
         def self.visibility_captured?(comp)
           comp[:captured_info] & 0b001 > 0

data/lib/psd/resources/resolution_info.rb

@@ -0,0 +1,48 @@
+require 'psd/resources/base'
+
+class PSD
+  class Resource
+    module Section
+      class ResolutionInfo < Base
+        RES_UNIT_NAMES = %w(pixel/inch pixel/cm).freeze
+        UNIT_NAMES = %w(in cm pt picas columns).freeze
+
+        resource_id 1005
+        name :resolution_info
+
+        attr_reader :h_res, :h_res_unit, :width_unit
+        attr_reader :v_res, :v_res_unit, :height_unit
+
+        def parse
+          # 32-bit fixed-point number (16.16)
+          @h_res = @file.read_uint.to_f / (1 << 16)
+          @h_res_unit = @file.read_ushort
+          @width_unit = @file.read_ushort
+
+          # 32-bit fixed-point number (16.16)
+          @v_res = @file.read_uint.to_f / (1 << 16)
+          @v_res_unit = @file.read_ushort
+          @height_unit = @file.read_ushort
+
+          @resource.data = self
+        end
+
+        def h_res_unit_name
+          RES_UNIT_NAMES.fetch(h_res_unit - 1, 'unknown')
+        end
+
+        def v_res_unit_name
+          RES_UNIT_NAMES.fetch(v_res_unit - 1, 'unknown')
+        end
+
+        def width_unit_name
+          UNIT_NAMES.fetch(width_unit - 1, 'unknown')
+        end
+
+        def height_unit_name
+          UNIT_NAMES.fetch(height_unit - 1, 'unknown')
+        end
+      end
+    end
+  end
+end

data/lib/psd/resources/saved_path.rb

@@ -0,0 +1,19 @@
+require 'psd/resources/base'
+
+class PSD
+  class Resource
+    module Section
+      class SavedPath < Base
+        def parse
+          paths = []
+          record_count = @resource.size / 26
+          record_count.times do
+            paths << PathRecord.new(@file)
+          end
+
+          @resource.data = paths
+        end
+      end
+    end
+  end
+end