psd 1.5.0 → 2.0.0

data/lib/psd/renderer/layer_styles.rb

@@ -0,0 +1,56 @@
+require_relative 'layer_styles/color_overlay'
+require_relative 'layer_styles/drop_shadow'
+
+class PSD
+  class LayerStyles
+    # Blend modes in layer effects use different keys
+    # than normal layer blend modes. Thanks Adobe.
+    BLEND_TRANSLATION = {
+      'Nrml' => 'norm',
+      'Dslv' => 'diss',
+      'Drkn' => 'dark',
+      'Mltp' => 'mul',
+      'CBrn' => 'idiv',
+      'linearBurn' => 'lbrn',
+      'Lghn' => 'lite',
+      'Scrn' => 'scrn',
+      'CDdg' => 'div',
+      'linearDodge' => 'lddg',
+      'Ovrl' => 'over',
+      'SftL' => 'sLit',
+      'HrdL' => 'hLit',
+      'vividLight' => 'vLit',
+      'linearLight' => 'lLit',
+      'pinLight' => 'pLit',
+      'hardMix' => 'hMix',
+      'Dfrn' => 'diff',
+      'Xclu' => 'smud',
+      'H   ' => 'hue',
+      'Strt' => 'sat',
+      'Clr ' => 'colr',
+      'Lmns' => 'lum'
+    }.freeze
+
+    attr_reader :canvas, :node, :data
+
+    def initialize(canvas)
+      @canvas = canvas
+      @node = @canvas.node
+      @data = @node.layer.info[:object_effects]
+
+      if @data.nil?
+        @applied = true
+      else
+        @data = @data.data
+        @applied = false
+      end
+    end
+
+    def apply!
+      return if @applied || data.nil?
+
+      ColorOverlay.new(self).apply! if ColorOverlay.should_apply?(data)
+      DropShadow.new(self).apply!   if DropShadow.should_apply?(data)
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+class PSD
+  class LayerStyles
+    class ColorOverlay
+      def self.should_apply?(data)
+        data.has_key?('SoFi')
+      end
+
+      def initialize(styles)
+        @canvas = styles.canvas
+        @node = styles.node
+        @data = styles.data
+      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|
+            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)
+          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 ']
+      end
+
+      def r
+        @r ||= color_data['Rd  '].round
+      end
+
+      def g
+        @g ||= color_data['Grn '].round
+      end
+
+      def b
+        @b ||= color_data['Bl  '].round
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+class PSD
+  class LayerStyles
+    # Not ready yet.
+    class DropShadow
+      def self.should_apply?(data)
+        #data.has_key?('DrSh')
+        false
+      end
+
+      def initialize(styles)
+      end
+
+      def apply!
+      end
+
+      private
+
+      def apply_drop_shadow
+
+      end
+
+      def drop_shadow
+        data['DrSh']
+      end
+
+      def drop_shadow_blend_mode
+        drop_shadow['Md  ']
+      end
+
+      def drop_shadow_opacity
+        drop_shadow['Opct'][:value]
+      end
+
+      def drop_shadow_light_angle
+        drop_shadow['lagl'][:value]
+      end
+
+      def drop_shadow_use_global_light?
+        drop_shadow['uglg']
+      end
+
+      def drop_shadow_distance
+        drop_shadow['Dstn'][:value]
+      end
+
+      def drop_shadow_spread
+        drop_shadow['Ckmt'][:value]
+      end
+
+      def drop_shadow_size
+        drop_shadow['blur'][:value]
+      end
+
+      def drop_shadow_noise
+        drop_shadow['Nose'][:value]
+      end
+
+      def drop_shadow_antialiased?
+        drop_shadow['AntA']
+      end
+
+      def drop_shadow_contour
+        drop_shadow['TrnS']['Nm  ']
+      end
+
+      def drop_shadow_contour_curve
+        drop_shadow['TrnS']['Crv ']
+      end
+
+      def drop_shadow_knock_out?
+        drop_shadow['layerConceals']
+      end
+    end
+  end
+end

data/lib/psd/renderer/mask.rb

@@ -0,0 +1,68 @@
+class PSD
+  class Renderer
+    class Mask
+      attr_accessor :pixel_data, :mask_data, :layer_width, :layer_height
+
+      def initialize(canvas, options = {})
+        @canvas = canvas
+        @layer = canvas.node
+        @options = options
+
+        @pixel_data = @canvas.pixels
+        @mask_data = @layer.image.mask_data
+
+        @layer_width = (@layer.folder? ? @layer.mask.width : @layer.width).to_i
+        @layer_height = (@layer.folder? ? @layer.mask.height : @layer.height).to_i
+      end
+
+      def apply!
+        PSD.logger.debug "Applying mask to #{@layer.name}"
+        
+        # We generate the preview at the document size instead to make applying the mask
+        # significantly easier.
+        width = @layer.header.width.to_i
+        height = @layer.header.height.to_i
+        png = ChunkyPNG::Canvas.new(width, height, ChunkyPNG::Color::TRANSPARENT)
+
+        i = 0
+        @layer_height.times do |y|
+          @layer_width.times do |x|
+            offset_x = x + @layer.left
+            offset_y = y + @layer.top
+
+            i +=1 and next if offset_x < 0 || offset_y < 0 || offset_x >= png.width || offset_y >= png.height
+
+            png[offset_x, offset_y] = @pixel_data[i]
+            i += 1
+          end
+        end
+        
+        # Now we apply the mask
+        i = 0
+        @layer.mask.height.times do |y|
+          @layer.mask.width.times do |x|
+            offset_x = @layer.mask.left + x
+            offset_y = @layer.mask.top + y
+
+            i += 1 and next if offset_x < 0 || offset_y < 0 || offset_x >= png.width || offset_y >= png.height
+
+            color = ChunkyPNG::Color.to_truecolor_alpha_bytes(png[offset_x, offset_y])
+            color[3] = color[3] * @mask_data[i] / 255
+
+            png[offset_x, offset_y] = ChunkyPNG::Color.rgba(*color)
+            i += 1
+          end
+        end
+
+        crop_left = PSD::Util.clamp(@layer.left, 0, png.width)
+        crop_top = PSD::Util.clamp(@layer.top, 0, png.height)
+        crop_width = PSD::Util.clamp(@layer_width, 0, png.width - crop_left)
+        crop_height = PSD::Util.clamp(@layer_height, 0, png.height - crop_top)
+
+        png.crop!(crop_left, crop_top, crop_width, crop_height)
+
+        @canvas.canvas = png
+      end
+    end
+  end
+end

data/lib/psd/resources/guides.rb

@@ -0,0 +1,35 @@
+class PSD
+  class Resource
+    class Section
+      class Guides < Section
+        def self.id; 1032; end
+        def self.name; :guides; end
+
+        def parse
+          # Descriptor version
+          @file.seek 4, IO::SEEK_CUR
+
+          # Future implementation of document-specific grids
+          @file.seek 8, IO::SEEK_CUR
+
+          num_guides = @file.read_int
+
+          @data = []
+
+          num_guides.times do
+            location = @file.read_int / 32
+            direction = @file.read_byte == 0 ? "vertical" : "horizontal"
+
+            @data.push({ :location => location, :direction => direction })
+          end
+
+          @resource.data = self
+        end
+
+        def to_a
+          @data
+        end
+      end
+    end
+  end
+end

data/lib/psd/version.rb

@@ -1,3 +1,3 @@
 class PSD
-  VERSION = "1.5.0"
+  VERSION = "2.0.0"
 end

data/psd.gemspec

@@ -18,11 +18,11 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency "rake"
-  gem.add_dependency "bindata"
+  gem.add_dependency 'rake'
+  gem.add_dependency 'bindata'
   gem.add_dependency 'psd-enginedata', '~> 1.0'
 
-  gem.add_dependency(RUBY_ENGINE =~ /jruby/ ? 'chunky_png' : 'oily_png')
+  gem.add_dependency 'chunky_png'
 
   gem.test_files = Dir.glob("spec/**/*")
   gem.add_development_dependency 'rspec'

data/spec/guides_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe 'Guides' do
+  describe "Handle file with slice properly" do
+    it "should successfully parse the PSD file that has guides" do
+      psd = PSD.new('spec/files/guides.psd')
+      psd.parse!
+
+      # File should parse
+      expect(psd).to be_parsed
+
+      # Guides should not be nil
+      expect(psd.resources[:guides]).to_not be_nil
+
+      # Each guide should have a position and direction
+      psd.resources[:guides].data.to_a.each do |guide|
+        expect(guide).to_not be_nil
+        expect(guide[:location]).to_not be_nil
+        expect(guide[:direction]).to_not be_nil
+      end
+    end
+  end
+
+  describe "Handle file without guides properly" do
+    it "should successfully parse a PSD file which does not have guides" do
+      psd = PSD.new('spec/files/simplest.psd')
+      psd.parse!
+
+      expect(psd).to be_parsed
+
+      expect(psd.resources[:guides].data.to_a.size).to be 0
+    end
+  end
+end

data/spec/hierarchy_spec.rb

@@ -91,11 +91,12 @@ describe "Hierarchy" do
         expect { @tree.filter_by_comp('WAT') }.to raise_error("Layer comp not found")
       end
 
-      it "should correctly filter and produce a new tree when filtering by layer comp" do
+      it "should correctly set visibility when filtering by layer comp" do
         tree = @tree.filter_by_comp('Version A')
         expect(tree).to be_an_instance_of(PSD::Node::Root)
-        expect(tree.children.size).to eq(1)
-        expect(tree.children[0].name).to eq("Version A")
+        expect(tree.children.size).to eq(3)
+        expect(tree.children_at_path('Version A').first).to be_visible
+        expect(tree.children_at_path('Version B').first).to_not be_visible
       end
 
       it "should return a new tree when filtering by layer comps" do
@@ -125,4 +126,27 @@ describe "Hierarchy" do
       expect(@psd.tree.children[0].top).to eq 450
     end
   end
+  
+  describe "Size Calculation With Empty Layer in Subgroups" do
+    before(:each) do
+      @psd = PSD.new('spec/files/empty-layer-subgroups.psd')
+      @psd.parse!
+    end
+
+    it 'should correctly identify empty nodes' do
+      expect(@psd.tree.children_at_path('group/not empty').first).to_not be_empty
+      expect(@psd.tree.children_at_path('group/Group 2').first).to be_empty
+      expect(@psd.tree.children_at_path('group/Group 2/Group 1').first).to be_empty
+      expect(@psd.tree.children_at_path('group/Group 2/subgroup 1/subgroup 2').first).to be_empty
+      expect(@psd.tree.children_at_path('group/Group 2/subgroup 1/subgroup 2/empty layer').first).to be_empty
+      expect(@psd.tree.children[0]).to_not be_empty
+    end
+
+    it "should correctly calculate the size of a group" do
+      expect(@psd.tree.children[0].width).to eq 264
+      expect(@psd.tree.children[0].height).to eq 198
+      expect(@psd.tree.children[0].left).to eq 448
+      expect(@psd.tree.children[0].top).to eq 356
+    end
+  end  
 end

data/spec/image_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe 'Image Exporting' do
-  let(:psd) { PSD.new('spec/files/pixel.psd') }
+  let!(:psd) { PSD.new('spec/files/pixel.psd') }
 
   describe "the full preview image" do
     it "should successfully parse the image data" do
@@ -33,52 +33,53 @@ describe 'Image Exporting' do
     end
   end
 
-  describe "layer images" do
-    it "should successfully parse the image data" do
-      psd.options[:parse_layer_images] = true
+  describe "Renderer" do
+    before(:each) do
       psd.parse!
+    end
 
-      image = psd.tree.children.first.image
-      expect(image.width).to eq(1)
-      expect(image.height).to eq(1)
+    it "should be available via any tree node" do
+      [psd.tree, psd.tree.children.first].each do |node|
+        expect(node).to respond_to(:renderer)
+        expect(node).to respond_to(:to_png)
+        expect(node).to respond_to(:save_as_png)
+      end
+    end
 
-      expect(image.pixel_data).to eq([ChunkyPNG::Color.rgba(0, 100, 200, 255)])
+    it "returns a Renderer object" do
+      [psd.tree, psd.tree.children.first].each do |node|
+        expect(node.renderer).to be_an_instance_of(PSD::Renderer)
+      end
     end
 
-    describe "as PNG" do
-      it "should produce a valid PNG object" do
-        psd.options[:parse_layer_images] = true
-        psd.parse!
+    it "produces a correct PNG" do
+      expect(psd.tree.to_png).to be_an_instance_of(ChunkyPNG::Canvas)
+      expect(psd.tree.to_png.pixels).to eq([ChunkyPNG::Color.rgba(0, 100, 200, 255)])
+      expect(psd.tree.to_png[0, 0]).to eq(ChunkyPNG::Color.rgba(0, 100, 200, 255))
+    end
 
-        png = psd.tree.children.first.image.to_png
-        expect(png).to be_an_instance_of(ChunkyPNG::Canvas)
-        expect(png.width).to eq(1)
-        expect(png.height).to eq(1)
-        expect(
-          ChunkyPNG::Color.to_truecolor_alpha_bytes(png[0,0])
-        ).to eq([0, 100, 200, 255])
+    describe "Canvas" do
+      before do
+        @node = psd.tree.children.first
+        @canvas = PSD::Renderer::Canvas.new(@node)
       end
 
-      it "memorizes the png instance" do
-        psd.options[:parse_layer_images] = true
-        psd.parse!
+      it 'is initialized properly' do
+        expect(@canvas.node).to be @node
+        expect(@canvas.width).to eq @node.width
+        expect(@canvas.height).to eq @node.height
 
-        node = psd.tree.children.first
-        png  = node.image.to_png
+        expect(@canvas.opacity).to eq @node.opacity
+        expect(@canvas.fill_opacity).to eq @node.fill_opacity
 
-        expect(png).to be_an_instance_of(ChunkyPNG::Canvas)
-        expect(node.image.to_png.__id__).to eq(png.__id__)
+        expect(@canvas.canvas).to be_an_instance_of(ChunkyPNG::Canvas)
+        expect(@canvas.instance_variable_get(:@pixel_data)).to be_nil
+        expect(@canvas.canvas.pixels.length).to be 1
       end
 
-      it "memorizes the png_with_mask instance" do
-        psd = PSD.new('spec/files/path.psd', parse_layer_images: true)
-        psd.parse!
-
-        node = psd.tree.children.first
-        png  = node.image.to_png_with_mask
-
-        expect(png).to be_an_instance_of(ChunkyPNG::Canvas)
-        expect(node.image.to_png_with_mask.__id__).to eq(png.__id__)
+      it 'delegates array methods to internal canvas' do
+        expect(@canvas[0, 0]).to eq ChunkyPNG::Color.rgba(0, 100, 200, 255)
+        expect(@canvas).to respond_to(:[]=)
       end
     end
   end