psd 2.1.2 → 3.1.2

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
+    ].freeze
+
     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/layer_styles/color_overlay.rb

@@ -1,8 +1,27 @@
 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? &&
+        !PSD::Renderer::VectorShape.can_render?(canvas)
+      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 +31,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 +60,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/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