psd 0.3.2

data/lib/psd/header.rb

@@ -0,0 +1,61 @@
+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
+
+    # 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.
+    MODES = [
+      'Bitmap',
+      'GrayScale',
+      'IndexedColor',
+      'RGBColor',
+      'CMYKColor',
+      'HSLColor',
+      'HSBColor',
+      'Multichannel',
+      'Duotone',
+      'LabColor',
+      'Gray16',
+      'RGB48',
+      'Lab48',
+      'CMYK64',
+      'DeepMultichannel',
+      'Duotone16'
+    ]
+
+    # Get the human-readable color mode name.
+    def mode_name
+      if mode >= 0 && mode <= 15
+        MODES[mode]
+      else
+        "(#{mode})"
+      end
+    end
+
+    # Width of the entire document in pixels.
+    def width
+      cols
+    end
+
+    # Height of the entire document in pixels.
+    def height
+      rows
+    end
+  end
+end

data/lib/psd/helpers.rb

@@ -0,0 +1,35 @@
+class PSD
+  # Various helper methods that make accessing PSD data easier since it's
+  # split up among various sections.
+  module Helpers
+    # Width of the entire PSD document, in pixels.
+    def width
+      header.cols
+    end
+
+    # Height of the entire PSD document, in pixels.
+    def height
+      header.rows
+    end
+
+    # All of the layers in this document, including section divider layers.
+    def layers
+      layer_mask.layers
+    end
+
+    # All of the layers, but filters out the section dividers.
+    def actual_layers
+      layers.delete_if { |l| l.folder? || l.folder_end? }
+    end
+
+    # All of the folders in the document.
+    def folders
+      layers.select { |l| l.folder? }
+    end
+
+    # Constructs a tree of the current document for easy traversal and data access.
+    def tree
+      @root ||= PSD::Node::Root.new(self)
+    end
+  end
+end

data/lib/psd/image.rb

@@ -0,0 +1,107 @@
+class PSD
+  # Parses the full preview image at the end of the PSD document.
+  class Image
+    include Format::RAW
+    include Format::RLE
+    include Mode::CMYK
+    include Mode::Greyscale
+    include Mode::RGB
+    include Export::PNG
+
+    # All of the possible compression formats Photoshop uses.
+    COMPRESSIONS = [
+      'Raw',
+      'RLE',
+      'ZIP',
+      'ZIPPrediction'
+    ]
+
+    # Each color channel is represented by a unique ID
+    CHANNEL_INFO = [
+      {id: 0},
+      {id: 1},
+      {id: 2},
+      {id: -1}
+    ]
+
+    # Store a reference to the file and the header. We also do a few simple calculations
+    # to figure out the number of pixels in the image and the length of each channel.
+    def initialize(file, header)
+      @file = file
+      @header = header
+
+      @num_pixels = width * height
+      @num_pixels *= 2 if depth == 16
+
+      calculate_length
+      @channel_data = {} # Using a Hash over an NArray, because NArray has problems w/ Ruby 2.0. Hashes are faster than Arrays
+
+      @start_pos = @file.tell
+      @end_pos = @start_pos + @length
+
+      @pixel_data = []
+    end
+
+    # Begins parsing the image by first figuring out the compression format used, and then
+    # by reading the image data.
+    def parse
+      @compression = parse_compression!
+
+      # ZIP not implemented
+      if [2, 3].include?(@compression)
+        @file.seek @end_pos and return
+      end
+
+      parse_image_data!
+
+      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)
+      end
+    end
+
+    private
+
+    def calculate_length
+      @length = case depth
+      when 1 then (width + 7) / 8 * height
+      when 16 then width * height * 2
+      else width * height
+      end
+
+      @channel_length = @length
+      @length *= channels
+    end
+
+    def parse_compression!
+      @file.read_short
+    end
+
+    def parse_image_data!
+      case @compression
+      when 0 then parse_raw!
+      when 1 then parse_rle!
+      when 2, 3 then parse_zip!
+      else @file.seek(@end_pos)
+      end
+
+      process_image_data
+    end
+
+    def process_image_data
+      case mode
+      when 1 then combine_greyscale_channel
+      when 3 then combine_rgb_channel
+      when 4 then combine_cmyk_channel
+      end
+    end
+
+    def pixel_step
+      depth == 8 ? 1 : 2
+    end
+  end
+end

data/lib/psd/image_exports/png.rb

@@ -0,0 +1,36 @@
+require 'chunky_png'
+
+class PSD::Image
+  module Export
+    # PNG image export. This is the default export format.
+    module PNG
+      # Load the image pixels into a PNG file and return a reference to the
+      # data.
+      def to_png
+        png = ChunkyPNG::Image.new(width, height, ChunkyPNG::Color::TRANSPARENT)
+
+        i = 0
+        height.times do |y|
+          width.times do |x|
+            png[x,y] = ChunkyPNG::Color.rgba(
+              @pixel_data[i],
+              @pixel_data[i+1],
+              @pixel_data[i+2],
+              @pixel_data[i+3]
+            )
+
+            i += 4
+          end
+        end
+
+        png
+      end
+      alias :export :to_png
+
+      # Saves the PNG data to disk.
+      def save_as_png(file)
+        to_png.save(file)
+      end
+    end
+  end
+end

data/lib/psd/image_formats/raw.rb

@@ -0,0 +1,14 @@
+class PSD::Image
+  module Format
+    # Parses a RAW uncompressed image
+    module RAW
+      private
+
+      def parse_raw!(length = @length)
+        @length.times do |i|
+          @channel_data[i] = @file.read(1).unpack('C')[0]
+        end
+      end
+    end
+  end
+end

data/lib/psd/image_formats/rle.rb

@@ -0,0 +1,67 @@
+class PSD::Image
+  module Format
+    # Parses an RLE compressed image
+    module RLE
+      private
+
+      def parse_rle!
+        @byte_counts = parse_byte_counts!
+        parse_channel_data!
+      end
+
+      def parse_byte_counts!
+        byte_counts = []
+        channels.times do |i|
+          height.times do |j|
+            byte_counts << @file.read_short
+          end
+        end
+
+        return byte_counts
+      end
+
+      def parse_channel_data!
+        chan_pos = 0
+        line_index = 0
+
+        channels.times do |i|
+          chan_pos = decode_rle_channel(chan_pos, line_index)
+          line_index += height
+        end
+      end
+
+      def decode_rle_channel(chan_pos, line_index)
+        height.times do |j|
+          byte_count = @byte_counts[line_index]
+          line_index += 1
+          start = @file.tell
+
+          while @file.tell < start + byte_count
+            len = @file.read(1).bytes.to_a[0]
+
+            if len < 128
+              len += 1
+              (chan_pos...chan_pos+len).each do |k|
+                @channel_data[k] = @file.read(1).bytes.to_a[0]
+              end
+
+              chan_pos += len
+            elsif len > 128
+              len ^= 0xff
+              len += 2
+
+              val = @file.read(1).bytes.to_a[0]
+              (chan_pos...chan_pos+len).each do |k|
+                @channel_data[k] = val
+              end
+
+              chan_pos += len
+            end
+          end
+        end
+
+        return chan_pos
+      end
+    end
+  end
+end

data/lib/psd/image_modes/cmyk.rb

@@ -0,0 +1,27 @@
+class PSD::Image::Mode
+  module CMYK
+    private
+
+    def combine_cmyk_channel
+      (0...@num_pixels).step(pixel_step) do |i|
+        if channels == 5
+          a = @channel_data[i]
+          c = @channel_data[i + @channel_length]
+          m = @channel_data[i + @channel_length * 2]
+          y = @channel_data[i + @channel_length * 3]
+          k = @channel_data[i + @channel_length * 4]
+        else
+          a = 255
+          c = @channel_data[i]
+          m = @channel_data[i + @channel_length]
+          y = @channel_data[i + @channel_length * 2]
+          k = @channel_data[i + @channel_length * 3]
+        end
+
+        rgb = PSD::Color.cmyk_to_rgb(255 - c, 255 - m, 255 - y, 255 - k)
+
+        @pixel_data.push *rgb.values, a
+      end
+    end
+  end
+end

data/lib/psd/image_modes/greyscale.rb

@@ -0,0 +1,36 @@
+class PSD::Image::Mode
+  module Greyscale
+    private
+
+    def combine_greyscale8_channel
+      if channels == 2
+        # We have an alpha channel
+        @num_pixels.times do |i|
+          alpha = @channel_data[i]
+          grey = @channel_data[@channel_length + i]
+
+          @pixel_data.push grey, grey, grey, alpha
+        end
+      else
+        @num_pixels.times do |i|
+          @pixel_data.push *([@channel_data[i]] * 3), 255
+        end
+      end
+    end
+
+    def combine_greyscale_channel
+      if channels == 2
+        (0...@num_pixels).step(pixel_step) do |i|
+          alpha = @channel_data[i]
+          grey = @channel_data[@channel_length + i]
+
+          @pixel_data.push grey, grey, grey, alpha
+        end
+      else
+        (0...@num_pixels).step(pixel_step) do |i|
+          @pixel_data.push *([@channel_data[i]] * 3), 255
+        end
+      end
+    end
+  end
+end

data/lib/psd/image_modes/rgb.rb

@@ -0,0 +1,25 @@
+class PSD::Image::Mode
+  # Combines the channel data from the image into RGB pixel values
+  module RGB
+    private
+
+    def combine_rgb_channel
+      (0...@num_pixels).step(pixel_step) do |i|
+        pixel = {r: 0, g: 0, b: 0, a: 255}
+
+        PSD::Image::CHANNEL_INFO[0...channels].each_with_index do |chan, index|
+          val = @channel_data[i + (@channel_length * index)]
+
+          case chan[:id]
+          when -1 then  pixel[:a] = val
+          when 0 then   pixel[:r] = val
+          when 1 then   pixel[:g] = val
+          when 2 then   pixel[:b] = val
+          end
+        end
+
+        @pixel_data.push *pixel.values
+      end
+    end
+  end
+end

data/lib/psd/layer.rb

@@ -0,0 +1,342 @@
+class PSD
+  # Represents a single layer and all of the data associated with
+  # that layer.
+  class Layer
+    include Section
+
+    attr_reader :id, :mask, :blending_ranges, :adjustments, :channels_info
+    attr_reader :blend_mode, :layer_type, :blending_mode, :opacity, :fill_opacity
+    attr_reader :channels, :image
+
+    attr_accessor :group_layer
+    attr_accessor :top, :left, :bottom, :right, :rows, :cols, :ref_x, :ref_y, :node, :file
+
+    alias :info :adjustments
+    alias :width :cols
+    alias :height :rows
+
+    # All of the extra layer info sections that we know how to parse.
+    LAYER_INFO = {
+      type: TypeTool,
+      legacy_type: LegacyTypeTool,
+      layer_name_source: LayerNameSource,
+      object_effects: ObjectEffects,
+      name: UnicodeName,
+      section_divider: LayerSectionDivider,
+      reference_point: ReferencePoint,
+      layer_id: LayerID,
+      fill_opacity: FillOpacity,
+      placed_layer: PlacedLayer,
+      vector_mask: VectorMask
+    }
+
+    # Initializes all of the defaults for the layer.
+    def initialize(file)
+      @file = file
+      @image = nil
+      @mask = {}
+      @blending_ranges = {}
+      @adjustments = {}
+      @channels_info = []
+      @blend_mode = {}
+      @group_layer = nil
+
+      @layer_type = 'normal'
+      @blending_mode = 'normal'
+      @opacity = 255
+      @fill_opacity = 255
+
+      # Just used for tracking which layer adjustments we're parsing.
+      # Not essential.
+      @info_keys = []
+    end
+
+    # Parse the layer and all of it's sub-sections.
+    def parse(index=nil)
+      start_section
+
+      @idx = index
+
+      parse_info
+      parse_blend_modes
+
+      extra_len = @file.read_int
+      @layer_end = @file.tell + extra_len
+
+      parse_mask_data
+      parse_blending_ranges
+      parse_legacy_layer_name
+      parse_extra_data
+
+      @file.seek @layer_end # Skip over any filler zeros
+
+      end_section
+      return self
+    end
+
+    # Export the layer to file. May or may not work.
+    def export(outfile)
+      export_info(outfile)
+
+      @blend_mode.write(outfile)
+      @file.seek(@blend_mode.num_bytes, IO::SEEK_CUR)
+
+      export_mask_data(outfile)
+      export_blending_ranges(outfile)
+      export_legacy_layer_name(outfile)
+      export_extra_data(outfile)
+
+      outfile.write @file.read(end_of_section - @file.tell)
+    end
+
+    # We just delegate this to a normal method call.
+    def [](val)
+      self.send(val)
+    end
+
+    def parse_channel_image!(header) #:nodoc:
+      # @image = ChannelImage.new(@file, header, self)
+    end
+
+    # Does this layer represent the start of a folder section?
+    def folder?
+      return false unless @adjustments.has_key?(:section_divider)
+      @adjustments[:section_divider].is_folder
+    end
+
+    # Does this layer represent the end of a folder section?
+    def folder_end?
+      return false unless @adjustments.has_key?(:section_divider)
+      @adjustments[:section_divider].is_hidden
+    end
+
+    # Is this layer visible?
+    def visible?
+      @visible
+    end
+
+    # Is this layer hidden?
+    def hidden?
+      !@visible
+    end
+
+    # Attempt to translate this layer and modify the document.
+    def translate(x=0, y=0)
+      @left += x
+      @right += x
+      @top += y
+      @bottom += y
+
+      @path_components.each{ |p| p.translate(x,y) } if @path_components
+    end
+
+    # Attempt to scale the path components within this layer.
+    def scale_path_components(xr, yr)
+      return unless @path_components
+
+      @path_components.each{ |p| p.scale(xr, yr) }
+    end
+
+    # Helper that exports the text data in this layer, if any.
+    def text
+      return nil unless @adjustments[:type]
+      @adjustments[:type].to_hash
+    end
+
+    # Gets the name of this layer. If the PSD file is from an even remotely
+    # recent version of Photoshop, this data is stored as extra layer info and
+    # as a UTF-16 name. Otherwise, it's stored in a legacy block.
+    def name
+      if @adjustments.has_key?(:name)
+        return @adjustments[:name].data
+      end
+
+      return @legacy_name
+    end
+
+    # We delegate all missing method calls to the extra layer info to make it easier
+    # to access that data.
+    def method_missing(method, *args, &block)
+      return @adjustments[method] if @adjustments.has_key?(method)
+      super
+    end
+
+    private
+
+    def parse_info
+      start_section(:info)
+
+      @top = @file.read_int
+      @left = @file.read_int
+      @bottom = @file.read_int
+      @right = @file.read_int
+      @channels = @file.read_short
+
+      @rows = @bottom - @top
+      @cols = @right - @left
+
+      @channels.times do
+        channel_id = @file.read_short
+        channel_length = @file.read_int
+
+        @channels_info << {id: channel_id, length: channel_length}
+      end
+
+      end_section(:info)
+    end
+
+    def export_info(outfile)
+      [@top, @left, @bottom, @right].each { |val| outfile.write_int(val) }
+      outfile.write_short(@channels)
+
+      @channels_info.each do |channel_info|
+        outfile.write_short channel_info[:id]
+        outfile.write_int channel_info[:length]
+      end
+
+      @file.seek end_of_section(:info)
+    end
+
+    def export_mask_data(outfile)
+      outfile.write @file.read(@mask_end - @mask_begin + 4)
+    end
+
+    def export_blending_ranges(outfile)
+      length = 4 * 2 # greys
+      length += @blending_ranges[:num_channels] * 8
+      outfile.write_int length
+
+      outfile.write_short @blending_ranges[:grey][:source][:black]
+      outfile.write_short @blending_ranges[:grey][:source][:white]
+      outfile.write_short @blending_ranges[:grey][:dest][:black]
+      outfile.write_short @blending_ranges[:grey][:dest][:white]
+
+      @blending_ranges[:num_channels].times do |i|
+        outfile.write_short @blending_ranges[:channels][i][:source][:black]
+        outfile.write_short @blending_ranges[:channels][i][:source][:white]
+        outfile.write_short @blending_ranges[:channels][i][:dest][:black]
+        outfile.write_short @blending_ranges[:channels][i][:dest][:white]
+      end
+
+      @file.seek length + 4, IO::SEEK_CUR
+    end
+
+    def export_legacy_layer_name(outfile)
+      outfile.write @file.read(@legacy_name_end - @legacy_name_start)
+    end
+
+    def export_extra_data(outfile)
+      outfile.write @file.read(@extra_data_end - @extra_data_begin)
+      if @path_components && !@path_components.empty?
+        outfile.seek @vector_mask_begin
+        @file.seek @vector_mask_begin
+
+        write_vector_mask(outfile)
+        @file.seek outfile.tell
+      end
+    end
+
+    def parse_blend_modes
+      @blend_mode = BlendMode.read(@file)
+
+      @blending_mode = @blend_mode.mode
+      @opacity = @blend_mode.opacity
+      @visible = @blend_mode.visible
+    end
+
+    def parse_mask_data
+      @mask_begin = @file.tell
+      @mask = Mask.read(@file)
+      @mask_end = @file.tell
+    end
+
+    def parse_blending_ranges
+      length = @file.read_int
+
+      @blending_ranges[:grey] = {
+        source: {
+          black: @file.read_short,
+          white: @file.read_short
+        },
+        dest: {
+          black: @file.read_short,
+          white: @file.read_short
+        }
+      }
+
+      @blending_ranges[:num_channels] = (length - 8) / 8
+
+      @blending_ranges[:channels] = []
+      @blending_ranges[:num_channels].times do
+        @blending_ranges[:channels] << {
+          source: {
+            black: @file.read_short,
+            white: @file.read_short
+          },
+          dest: {
+            black: @file.read_short,
+            white: @file.read_short
+          }
+        }
+      end
+    end
+
+    # The old school layer names are encoded in MacRoman format,
+    # not UTF-8. Luckily Ruby kicks ass at character conversion.
+    def parse_legacy_layer_name
+      @legacy_name_start = @file.tell
+      len = Util.pad4 @file.read(1).unpack('C')[0]
+      @legacy_name = @file.read(len).encode('UTF-8', 'MacRoman').delete("\000")
+      @legacy_name_end = @file.tell
+    end
+
+    # This section is a bit tricky to parse because it represents all of the
+    # extra data that describes this layer.
+    def parse_extra_data
+      @extra_data_begin = @file.tell
+
+      while @file.tell < @layer_end
+        # Signature, don't need
+        @file.seek 4, IO::SEEK_CUR
+
+        # Key, very important
+        key = @file.read(4).unpack('A4')[0]
+        @info_keys << key
+
+        length = Util.pad2 @file.read_int
+        pos = @file.tell
+
+        info_parsed = false
+        LAYER_INFO.each do |name, info|
+          next unless info.key == key
+          
+          i = info.new(@file, length)
+          i.parse
+
+          @adjustments[name] = i
+          info_parsed = true
+          break
+        end
+
+        if !info_parsed
+          PSD.keys << key
+          # puts "SKIPPING #{key}, length = #{length}"
+          @file.seek length, IO::SEEK_CUR
+        end
+
+        @file.seek pos + length if @file.tell != (pos + length)
+      end
+
+      # puts "Layer = #{name}, Parsed = #{@info_keys - PSD.keys.uniq}, Unparsed = #{PSD.keys.uniq - @info_keys}"
+      @extra_data_end = @file.tell
+    end
+
+    def write_vector_mask(outfile)
+      outfile.write @file.read(8)
+      # outfile.write_int 3
+      # outfile.write_int @vector_tag
+
+      @path_components.each{ |pc| pc.write(outfile); @file.seek(26, IO::SEEK_CUR) }
+    end
+  end
+end