psd 2.1.2 → 3.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 62a564e222daa1c918ef3bdf9c2a4f99dfd59833
-  data.tar.gz: 93c28d4cba1c961cb28734da81f54e1617adcbdd
+SHA256:
+  metadata.gz: 1199316b606804a9a2c3812a1fcddc5e62d4171693ad201475ce833774bff52f
+  data.tar.gz: de991a2e3bb3c6eae0998d31baff59223510b6c07b0baebd41cea6e485656cab
 SHA512:
-  metadata.gz: 5eb251154704e8172420d3aa1d97851f739f516dcda1d659349719933f354e7443e3a4cebad498084ccf475505e5f97fef0a16f5cf15b25c4bdc3264401b9c59
-  data.tar.gz: 7b4c1554a65b7f491f197839b2a99fe383e97c6b1f79ee0528374c919e11abbf3d26293c1b27fc11ca11098b64594651d820d4e9a88e192a4ef4182f0d922106
+  metadata.gz: 3299a64c6b5b21dd38d844bea52ae6d42c1ddd864e8b9a9e0bdccc6690d0340beae15852c3c682d74ef1fe658813aff233c350b3daf2e9dad97cca8d228cc4e1
+  data.tar.gz: ad77e3095d489ad3799a61d95b35e37a72e48adb6fd76b89b0160cb425e4b87c23132b4a3c998c3179d1ad0c9a5910a8c88d4f7a16d6ffbe140a5d2c8d69dca4

data/.travis.yml

@@ -1,6 +1,8 @@
+sudo: false
 language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
   - 2.1.0
+  - 2.2.1
   - jruby-19mode

data/README.md

@@ -19,9 +19,8 @@ A general purpose Photoshop file parser written in Ruby. It allows you to work w
 
 PSD.rb is tested against:
 
-* MRI 1.9.3 & 2.0.0
+* MRI 1.9.3, 2.0.0, 2.1.0
 * JRuby (1.9.3 mode)
-* Rubinius (1.9.3 mode)
 
 If you use MRI Ruby and are interested in significantly speeding up PSD.rb with native code, check out [psd_native](https://github.com/layervault/psd_native).
 
@@ -76,15 +75,23 @@ end
 
 ### Traversing the Document
 
-To access the document as a tree structure, use `psd.tree` to get the root node. From there, you can traverse the tree using any of these methods:
+To access the document as a tree structure, use `psd.tree` to get the root node. From there, work with the tree using any of these methods:
 
 * `root`: get the root node from anywhere in the tree
+* `root?`: is this the root node?
 * `children`: get all immediate children of the node
+* `has_children?`: does this node have any children?
+* `childless?`: opposite of `has_children?`
 * `ancestors`: get all ancestors in the path of this node (excluding the root)
 * `siblings`: get all sibling tree nodes including the current one (e.g. all layers in a folder)
+* `next_sibling`: gets the sibling immediately following the current node
+* `prev_sibling`: gets the sibling immediately before the current node
+* `has_siblings?`: does this node have any siblings?
+* `only_child?`: opposite of `has_siblings?`
 * `descendants`: get all descendant nodes not including the current one
 * `subtree`: same as descendants but starts with the current node
-* `depth`: calculate the depth of the current node
+* `depth`: calculate the depth of the current node (root node is 0)
+* `path`: gets the path to the current node
 
 For any of the traversal methods, you can also retrieve folder or layer nodes only by appending `_layers` or `_groups` to the method. For example:
 
@@ -96,11 +103,12 @@ If you know the path to a group or layer within the tree, you can search by that
 
 ``` ruby
 psd.tree.children_at_path("Version A/Matte")
+psd.tree.children_at_path(["Version A", "Matte"])
 ```
 
 ### Layer Comps
 
-You can also filter nodes based on a layer comp. To generate a new tree consisting only of the layers that are enabled in a certain layer comp:
+You can also filter nodes based on a layer comp. To generate a new tree with layer visibility and position set according to the layer comp data:
 
 ``` ruby
 # Get information about all the available layer comps
@@ -111,7 +119,7 @@ tree = psd.tree.filter_by_comp('Version A')
 puts tree.children.map(&:name)
 ```
 
-This returns a new node tree and does not alter the original so you won't lose any data.
+This returns a new node tree and does not alter the original.
 
 ### Accessing Layer Data
 
@@ -197,32 +205,64 @@ png = psd.image.to_png # reference to PNG data
 psd.image.save_as_png 'path/to/output.png' # writes PNG to disk
 ```
 
-### Debugging
+This uses the full rasterized preview provided by Photoshop. It does not use the built-in rendering engine (described below). If the file was not saved with Compatibility Mode enabled, this will return an empty image.
 
-If you run into any problems parsing a PSD, you can enable debug logging via the `PSD_DEBUG` environment variable. For example:
+### Preview Building
 
-``` bash
-PSD_DEBUG=true bundle exec examples/parse.rb
+You can build previews of any subset or version of the PSD document using the built-in renderer. This is useful for generating previews of layer comps or exporting individual layer groups as images.
+
+``` ruby
+# Save a layer comp
+psd.tree.filter_by_comp("Version A").save_as_png('./Version A.png')
+
+# Generate PNG of individual layer group
+psd.tree.children_at_path("Group 1").first.to_png
 ```
 
-You can also give a path to a file instead. If you need to enable debugging programatically:
+### Slices
+
+Because slices are relative to the full document, you can access them directly on the `psd` object. Use `psd.slices` to get an array of all slices in the document.
 
 ``` ruby
-PSD.debug = true
+slices = psd.slices
+slices.first.name #=> "Logo"
+slices.first.left #=> 20
+slices.first.width #=> 200
 ```
 
-### Preview Building
+You can also search for slices if you know their name or ID. Because slice names do not need to be unique, `slices_by_name` will always return an array of all matches.
 
-**This is currently an experimental feature. It works "well enough" but is not perfect yet.**
+``` ruby
+psd.slice_by_id(2)
+psd.slices_by_name('Logo')
+```
 
-You can build previews of any subset or version of the PSD document. This is useful for generating previews of layer comps or exporting individual layer groups as images.
+When you create a slice based off of a layer, Photoshop stores this relation in the file. If you have a slice that was created this way, you can easily get the associated layer.
 
 ``` ruby
-# Save a layer comp
-psd.tree.filter_by_comp("Version A").save_as_png('./Version A.png')
+slice = psd.slices_by_name('Logo').first
+slice.associated_layer #=> <PSD::Node::Layer>
+```
 
-# Generate PNG of individual layer group
-psd.tree.children_at_path("Group 1").first.to_png
+Finally, you can export slices as PNGs.
+
+``` ruby
+psd.slices.first.to_png #=> ChunkyPNG canvas
+psd.slices_by_name('Logo').first.save_as_png('Logo.png') #=> writes Logo.png
+```
+
+### Debugging
+
+If you run into any problems parsing a PSD, you can enable debug logging via the `PSD_DEBUG` environment variable. For example:
+
+``` bash
+PSD_DEBUG=true bundle exec examples/parse.rb
+```
+
+If you need to enable debugging programatically:
+
+``` ruby
+PSD.debug = true
 ```
 
 ## To-do
@@ -230,6 +270,6 @@ psd.tree.children_at_path("Group 1").first.to_png
 There are a few features that are currently missing from PSD.rb.
 
 * More image modes + depths for image exporting
-* A few layer info blocks
 * Support for rendering all layer styles
+* Support for layer comp adjusted layer styles
 * Render engine fixes for groups with lowered opacity

data/lib/psd/blend_mode.rb

@@ -1,14 +1,6 @@
 class PSD
-  # Describes the blend mode for a single layer or folder.
-  class BlendMode < BinData::Record
-    endian  :big
-
-    string  :sig, read_length: 4
-    string  :blend_key, read_length: 4, trim_value: true
-    uint8   :opacity
-    uint8   :clipping
-    bit8    :flags
-    skip    length: 1
+  class BlendMode
+    attr_reader :blend_key, :opacity, :clipping
 
     # All of the blend modes are stored in the PSD file with a specific key.
     # This is the mapping of that key to its readable name.
@@ -24,57 +16,73 @@ class PSD
       scrn: 'screen',
       diss: 'dissolve',
       over: 'overlay',
-      hLit: 'hard light',
-      sLit: 'soft light',
+      hLit: 'hard_light',
+      sLit: 'soft_light',
       diff: 'difference',
       smud: 'exclusion',
-      div:  'color dodge',
-      idiv: 'color burn',
-      lbrn: 'linear burn',
-      lddg: 'linear dodge',
-      vLit: 'vivid light',
-      lLit: 'linear light',
-      pLit: 'pin light',
-      hMix: 'hard mix',
+      div:  'color_dodge',
+      idiv: 'color_burn',
+      lbrn: 'linear_burn',
+      lddg: 'linear_dodge',
+      vLit: 'vivid_light',
+      lLit: 'linear_light',
+      pLit: 'pin_light',
+      hMix: 'hard_mix',
       pass: 'passthru',
-      dkCl: 'darker color',
-      lgCl: 'lighter color',
+      dkCl: 'darker_color',
+      lgCl: 'lighter_color',
       fsub: 'subtract',
       fdiv: 'divide'
-    }
+    }.freeze
 
-    # Get the readable name for this blend mode.
-    def mode
-      BLEND_MODES[blend_key.strip.to_sym]
+    def initialize(file)
+      @file = file
+      
+      @blend_key = nil
+      @opacity = nil
+      @clipping = nil
+      @flags = nil
     end
 
-    # Set the blend mode with the readable name.
-    def mode=(val)
-      blend_key = BLEND_MODES.invert[val.strip.downcase]
+    def parse!
+      @file.seek 4, IO::SEEK_CUR
+
+      @blend_key = @file.read_string(4).strip
+      @opacity = @file.read_byte
+      @clipping = @file.read_byte
+      @flags = @file.read_byte
+
+      @file.seek 1, IO::SEEK_CUR
     end
 
-    # Opacity is stored as an integer between 0-255. This converts the opacity
-    # to a percentage value to match the Photoshop interface.
+    def mode
+      BLEND_MODES[@blend_key.to_sym]
+    end
+    alias_method :blending_mode, :mode
+
     def opacity_percentage
-      opacity * 100 / 255
+      @opacity_percentage ||= @opacity * 100 / 255
+    end
+
+    def clipped?
+      @clipping == 1
     end
 
     def transparency_protected
-      flags & 0x01
+      @flags & 0x01
     end
 
-    # Is this layer/folder visible?
     def visible
-      !((flags & (0x01 << 1)) > 0)
+      !((@flags & (0x01 << 1)) > 0)
     end
 
     def obsolete
-      (flags & (0x01 << 2)) > 0
+      (@flags & (0x01 << 2)) > 0
     end
 
     def pixel_data_irrelevant
-      return nil unless (flags & (0x01 << 3)) > 0
-      (flags & (0x01 << 4)) > 0
+      return nil unless (@flags & (0x01 << 3)) > 0
+      (@flags & (0x01 << 4)) > 0
     end
   end
 end

data/lib/psd/channel_image.rb

@@ -1,4 +1,6 @@
-require_relative 'image'
+require 'psd/image'
+require 'psd/image_formats/layer_rle'
+require 'psd/image_formats/layer_raw'
 
 class PSD
   # Represents an image for a single layer, which differs slightly in format from
@@ -18,7 +20,7 @@ class PSD
       super(file, header)
 
       @channels_info = @layer.channels_info
-      @has_mask = @layer.mask.width * @layer.mask.height > 0
+      @has_mask = @channels_info.any? { |chan| chan[:id] == -2 }
       @opacity = @layer.opacity / 255.0
       @mask_data = []
     end
@@ -47,7 +49,7 @@ class PSD
 
         # If the ID of this current channel is -2, then we assume the dimensions
         # of the layer mask.
-        if ch_info[:id] == -2
+        if ch_info[:id] < -1
           @width = @layer.mask.width
           @height = @layer.mask.height
         else
@@ -97,8 +99,12 @@ class PSD
     def parse_user_mask
       return unless has_mask?
 
-      channel = @channels_info.select { |c| c[:id] == -2 }.first
-      index = @channels_info.index { |c| c[:id] == -2 }
+      mask_id = -2
+
+      PSD.logger.debug "Using mask in channel #{mask_id}"
+
+      channel = @channels_info.select { |c| c[:id] == mask_id }.first
+      index = @channels_info.index { |c| c[:id] == mask_id }
       return if channel.nil?
 
       start = @channel_length * index

data/lib/psd/color.rb

@@ -6,8 +6,17 @@ class PSD
   module Color
     extend self
 
-      # This is a relic of libpsd that will likely go away in a future version. It
-      # stored the entire color value in a 32-bit address space for speed.
+    COLOR_SPACE = {
+      0 => :rgb,
+      1 => :hsb,
+      2 => :cmyk,
+      7 => :lab,
+      8 => :grayscale
+    }
+
+    # In some places in the PSD file, colors are stored with a short that
+    # describes the color space, and the following 4 bytes that store the
+    # color data.
     def color_space_to_argb(color_space, color_component)
       color = case color_space
       when 0
@@ -20,7 +29,7 @@ class PSD
           color_component[1] / 100.0, color_component[2] / 100.0,
           color_component[3] / 100.0
       when 7
-        lab_to_color *color_component
+        alab_to_color *color_component
       else
         0x00FFFFFF
       end
@@ -101,7 +110,7 @@ class PSD
 
     def alab_to_color(alpha, l, a, b)
       xyz = lab_to_xyz(l, a, b)
-      axyz_to_color alpha, xyz[:x], xyz[:y], xyz[:z]
+      axyz_to_color alpha, xyz[0], xyz[1], xyz[2]
     end
 
     def lab_to_xyz(l, a, b)
@@ -122,4 +131,4 @@ class PSD
       }.map { |k, v| [k, Util.clamp(v, 0, 255)] }]
     end
   end
-end
+end

data/lib/psd/descriptor.rb

@@ -84,13 +84,27 @@ class PSD
     def parse_identifier; @file.read_int; end
     def parse_index; @file.read_int; end
     def parse_offset; @file.read_int; end
-    def parse_property; parse_id; end
+    
+    def parse_property
+      {
+        class: parse_class,
+        id: parse_id
+      }
+    end
 
-    # Discard the first ID becasue it's the same as the key
-    # parsed from the Key/Item. Also, YOLO.
     def parse_enum
-      parse_id
-      parse_id
+      {
+        type: parse_id,
+        value: parse_id
+      }
+    end
+
+    def parse_enum_reference
+      {
+        class: parse_class,
+        type: parse_id,
+        value: parse_id
+      }
     end
 
     def parse_alias
@@ -149,18 +163,27 @@ class PSD
     end
 
     def parse_reference
-      form = @file.read_string(4)
-      klass = parse_class
-
-      case form
-      when 'Clss' then nil
-      when 'Enmr' then parse_enum
-      when 'Idnt' then parse_identifier
-      when 'indx' then parse_index
-      when 'name' then @file.read_unicode_string
-      when 'rele' then parse_offset
-      when 'prop' then parse_property
+      num_items = @file.read_int
+      items = []
+      
+      num_items.times do
+        type = @file.read_string(4)
+        PSD.logger.debug "Reference type = #{type}"
+
+        value = case type
+        when 'prop' then parse_property
+        when 'Clss' then parse_class
+        when 'Enmr' then parse_enum_reference
+        when 'Idnt' then parse_identifier
+        when 'indx' then parse_index
+        when 'name' then @file.read_unicode_string
+        when 'rele' then parse_offset
+        end
+
+        items << {type: type, value: value}
       end
+
+      items
     end
 
     def parse_unit_double

data/lib/psd/file.rb

@@ -82,7 +82,10 @@ class PSD
     # Reads a unicode string, which is double the length of a normal string and encoded as UTF-16.
     def read_unicode_string(length=nil)
       length ||= read_int if length.nil?
-      !length.nil? && length > 0 ? read(length * 2).encode('UTF-8', 'UTF-16BE').delete("\000") : ''
+      return '' if length.nil? || length <= 0
+      read(length * 2)
+        .encode('UTF-8', 'UTF-16BE', universal_newline: true)
+        .delete("\000")
     end
 
     # Reads a boolean value.
@@ -93,12 +96,12 @@ class PSD
     # Reads a 32-bit color space value.
     def read_space_color
       color_space = read_short
-      color_component = []
-      4.times do |i|
-        color_component.push(read_short >> 8)
+      color_components = []
+      4.times.map do |i|
+        color_components.push(read_short >> 8)
       end
 
-      Color.color_space_to_argb(color_space, color_component)
+      { color_mode: color_space, color_components: color_components }
     end
   end
-end
+end

data/lib/psd/header.rb

@@ -1,22 +1,6 @@
 class PSD
-  # Describes the Header for the PSD file, which is the first section of the file.
-  class Header < BinData::Record
-    endian :big
-
-    string  :sig, read_length: 4
-    uint16  :version
-
-    # Reserved bytes
-    skip    length: 6
-
-    uint16  :channels
-    uint32  :rows
-    uint32  :cols
-    uint16  :depth
-    uint16  :mode
-
-    uint32  :color_data_len
-    skip    length: :color_data_len
+  class Header
+    attr_reader :sig, :version, :channels, :rows, :cols, :depth, :mode
 
     # All of the color modes are stored internally as a short from 0-15.
     # This is a mapping of that value to a human-readable name.
@@ -37,25 +21,46 @@ class PSD
       'CMYK64',
       'DeepMultichannel',
       'Duotone16'
-    ]
+    ].freeze
 
-    # Get the human-readable color mode name.
-    def mode_name
-      if mode >= 0 && mode <= 15
-        MODES[mode]
-      else
-        "(#{mode})"
-      end
+    alias_method :width, :cols
+    alias_method :height, :rows
+
+    def initialize(file)
+      @file = file
+
+      @sig = nil
+      @version = nil
+      @channels = nil
+      @rows = nil
+      @cols = nil
+      @depth = nil
+      @mode = nil
     end
 
-    # Width of the entire document in pixels.
-    def width
-      cols
+    def parse!
+      @sig = @file.read_string(4)
+      @version = @file.read_ushort
+
+      # Reserved bytes, must be 0
+      @file.seek 6, IO::SEEK_CUR
+
+      @channels = @file.read_ushort
+      @rows = @file.read_uint
+      @cols = @file.read_uint
+      @depth = @file.read_ushort
+      @mode = @file.read_ushort
+
+      color_data_len = @file.read_uint
+      @file.seek color_data_len, IO::SEEK_CUR
+    end
+
+    def mode_name
+      MODES[@mode]
     end
 
-    # Height of the entire document in pixels.
-    def height
-      rows
+    def big?
+      version == 2
     end
 
     def rgb?
@@ -66,4 +71,4 @@ class PSD
       mode == 4
     end
   end
-end
+end

data/lib/psd/helpers.rb

@@ -45,7 +45,7 @@ class PSD
     end
 
     def slices
-      resource(:slices).to_a
+      @slices ||= resource(:slices).to_a.map { |s| Slice.new(self, s) }
     end
   end
-end
+end

data/lib/psd/image.rb

@@ -1,6 +1,14 @@
+require 'psd/image_formats/raw'
+require 'psd/image_formats/rle'
+require 'psd/image_modes/cmyk'
+require 'psd/image_modes/greyscale'
+require 'psd/image_modes/rgb'
+require 'psd/image_exports/png'
+
 class PSD
   # Parses the full preview image at the end of the PSD document.
   class Image
+    extend Forwardable
     include ImageFormat::RAW
     include ImageFormat::RLE
     include ImageMode::CMYK
@@ -11,6 +19,9 @@ class PSD
     attr_reader :pixel_data, :opacity, :has_mask
     alias :has_mask? :has_mask
 
+    # We delegate a few useful methods to the header.
+    def_delegators :@header, :height, :width, :channels, :depth, :mode
+
     # All of the possible compression formats Photoshop uses.
     COMPRESSIONS = [
       'Raw',
@@ -29,6 +40,8 @@ class PSD
       @num_pixels *= 2 if depth == 16
 
       calculate_length
+      set_channels_info
+
       @channel_data = []
       @pixel_data = []
       @opacity = 1.0
@@ -38,15 +51,6 @@ class PSD
       @end_pos = @start_pos + @length
 
       PSD.logger.debug "Image: #{width}x#{height}, length = #{@length}, mode = #{@header.mode_name}, position = #{@start_pos}"
-
-      # Each color channel is represented by a unique ID
-      @channels_info = [
-        {id: 0},
-        {id: 1},
-        {id: 2}
-      ]
-
-      @channels_info << {id: -1} if channels == 4
     end
 
     # Begins parsing the image by first figuring out the compression format used, and then
@@ -67,15 +71,16 @@ class PSD
       return self
     end
 
-    # We delegate a few useful methods to the header.
-    [:height, :width, :channels, :depth, :mode].each do |attribute|
-      define_method attribute do
-        @header.send(attribute)
+    private
+
+    def set_channels_info
+      case mode
+      when 1 then set_greyscale_channels
+      when 3 then set_rgb_channels
+      when 4 then set_cmyk_channels
       end
     end
 
-    private
-
     def calculate_length
       @length = case depth
       when 1 then (width + 7) / 8 * height
@@ -120,4 +125,4 @@ class PSD
       @pixel_data[i]
     end
   end
-end
+end

data/lib/psd/image_formats/layer_rle.rb

@@ -7,7 +7,7 @@ class PSD
       def parse_byte_counts!
         byte_counts = []
         height.times do
-          byte_counts << @file.read_short
+          byte_counts << (@header.big? ? @file.read_int : @file.read_short)
         end
 
         return byte_counts
@@ -21,4 +21,4 @@ class PSD
       end
     end
   end
-end
+end