cul_image_props 0.1.0

data/lib/cul_image_props/image/properties/exif.rb

@@ -0,0 +1,189 @@
+require 'cul_image_props/image/magic'
+require 'cul_image_props/image/properties/exif/types'
+require 'cul_image_props/image/properties/exif/constants'
+module Cul
+module Image
+module Properties
+module Exif
+
+
+# process an image file (expects an open file object)
+# this is the function that has to deal with all the arbitrary nasty bits
+# of the EXIF standard
+def self.process_file(f, opts={})
+    def_opts = { :stop_tag => 'UNDEF', :details => true, :strict => false }
+    opts = def_opts.merge(opts)
+    stop_tag = opts[:stop_tag]
+    details = opts[:details]
+    strict = opts[:strict]
+
+    # by default do not fake an EXIF beginning
+    fake_exif = 0
+
+    # determine whether it's a JPEG or TIFF
+    data = f.read(12)
+    jfif = {}
+    if [Cul::Image::Magic::TIFF_MOTOROLA_BE, Cul::Image::Magic::TIFF_INTEL_LE].include? data[0, 4]
+        f.seek(0)
+        endian = data[0,1]
+        offset = 0
+    elsif data[0,2] == Cul::Image::Magic::JPEG
+        # it's a JPEG file
+        base = 0
+        while data[2] == "\xFF" and ['JFIF', 'JFXX', 'OLYM', 'Phot'].include? data[6, 4]
+            length = data[4,2].unpack('n')[0]
+            f.read(length-8)
+            # fake an EXIF beginning of file
+            data = "\xFF\x00"+f.read(10)
+            fake_exif = 1
+            base = base + length
+        end
+        # Big ugly patch to deal with APP2 (or other) data coming before APP1
+        f.seek(0)
+        data = f.read(base+8000) # in theory, this could be insufficient --gd
+
+        base = 2
+        fptr = base
+        while true
+            if data[fptr,2]=="\xFF\xE1"
+                if data[fptr+4,4] == "Exif"
+                    base = fptr-2
+                    break
+                end
+                fptr += 2
+                fptr += data[fptr+2,2].unpack('n')[0]
+            elsif data[fptr,2]=="\xFF\xE2"
+                fptr += 2
+                fptr += data[fptr+2,2].unpack('n')[0]
+            elsif data[fptr,2]=="\xFF\xE0"
+                offset = fptr
+                fptr += 2
+                fptr += data[fptr,2].unpack('n')[0]
+
+                exif = EXIF_TAGS[0x0128]
+                label = 'Image ' + exif.name
+                if (data[offset+11] == 0x00)
+                    jfif[label] = IFD_Tag.new(exif.value[1],label,3,[0],offset+11,1)
+                elsif (data[offset+11] == 0x01)
+                    jfif[label] = IFD_Tag.new(exif.value[2],label,3,[0],offset+11,1)
+                elsif (data[offset+11] == 0x02)
+                    jfif[label] = IFD_Tag.new(exif.value[3],label,3,[0],offset+11,1)
+                else
+                    jfif[label] = IFD_Tag.new("Unknown",label,3,[0],offset+11,1)
+                end
+                xres= data[offset+12,2].unpack('n')[0]
+                yres= data[offset+14,2].unpack('n')[0]
+                exif = EXIF_TAGS[0x011a]
+                label = 'Image ' + EXIF_TAGS[0x011a].name
+                jfif[label] = IFD_Tag.new(xres.to_s,label,5,[xres],offset+12,2)
+                label = 'Image ' + EXIF_TAGS[0x011b].name
+                jfif[label] = IFD_Tag.new(yres.to_s,label,5,[yres],offset+13,2)
+            else
+                if(data.length < fptr + 2)
+                    break
+                end
+                # scan for the next APP header, /\xFF(^[\x00])/
+                _next = data.index("\xff",fptr + 2)
+                _next = nil if !_next.nil? and _next + 2 >= data.length
+                while (!_next.nil? and data[_next + 1] == 0x00)
+                    _next = data.index("\xff",_next + 2)
+                    _next = nil if !_next.nil? and _next + 2 >= data.length
+                end
+                unless (_next.nil?)
+                   fptr = _next
+                else
+                   break
+                end
+            end
+        end
+        f.seek(base+12)
+        if data[2+base] == 0xFF and data[6+base, 4] == 'Exif'
+            # detected EXIF header
+            offset = base+12 # f.tell()
+            endian = f.read(1)
+        else
+            # no EXIF information
+            unless fake_exif
+                return {}
+            else
+                return jfif
+            end
+        end
+    else
+        # file format not recognized
+        return {}
+    end
+    # deal with the EXIF info we found
+
+    hdr = EXIF_header.new(f, endian, offset, fake_exif, strict)
+    jfif.each { |tag|
+        unless hdr.tags.include? tag
+            hdr.tags[tag] = jfif[tag]
+        end
+    }
+    ifd_list = hdr.list_IFDs()
+    ctr = 0
+    ifd_list.each { |i|
+        if ctr == 0
+            ifd_name = 'Image'
+        elsif ctr == 1
+            ifd_name = 'Thumbnail'
+            thumb_ifd = i
+        else
+            ifd_name = 'IFD %d' % ctr
+        end
+        hdr.dump_IFD(i, ifd_name, {:dict=>EXIF_TAGS, :relative=>false, :stop_tag=>stop_tag})
+        # EXIF IFD
+        exif_off = hdr.tags[ifd_name +' ExifOffset']
+        if exif_off
+            hdr.dump_IFD(exif_off.values[0], 'EXIF', {:dict=>EXIF_TAGS, :relative=>false, :stop_tag =>stop_tag})
+            # Interoperability IFD contained in EXIF IFD
+            intr_off = hdr.tags['EXIF SubIFD InteroperabilityOffset']
+            if intr_off
+                hdr.dump_IFD(intr_off.values[0], 'EXIF Interoperability',
+                             :dict=>INTR_TAGS, :relative=>false, :stop_tag =>stop_tag)
+            end
+        end
+        # GPS IFD
+        gps_off = hdr.tags[ifd_name+' GPSInfo']
+        if gps_off
+            hdr.dump_IFD(gps_off.values[0], 'GPS', {:dict=>GPS_TAGS, :relative=>false, :stop_tag =>stop_tag})
+        end
+        ctr += 1
+    }
+    # extract uncompressed TIFF thumbnail
+    thumb = hdr.tags['Thumbnail Compression']
+    if thumb and thumb.printable == 'Uncompressed TIFF'
+        hdr.extract_TIFF_thumbnail(thumb_ifd)
+    end
+    # JPEG thumbnail (thankfully the JPEG data is stored as a unit)
+    thumb_off = hdr.tags['Thumbnail JPEGInterchangeFormat']
+    if thumb_off
+        f.seek(offset+thumb_off.values[0])
+        size = hdr.tags['Thumbnail JPEGInterchangeFormatLength'].values[0]
+        hdr.tags['JPEGThumbnail'] = f.read(size)
+    end
+
+    # deal with MakerNote contained in EXIF IFD
+    # (Some apps use MakerNote tags but do not use a format for which we
+    # have a description, do not process these).
+    if hdr.tags.include? 'EXIF MakerNote' and hdr.tags.include? 'Image Make' and detailed
+        hdr.decode_maker_note()
+    end
+
+    # Sometimes in a TIFF file, a JPEG thumbnail is hidden in the MakerNote
+    # since it's not allowed in a uncompressed TIFF IFD
+    unless hdr.tags.include? 'JPEGThumbnail'
+        thumb_off=hdr.tags['MakerNote JPEGThumbnail']
+        if thumb_off
+            f.seek(offset+thumb_off.values[0])
+            hdr.tags['JPEGThumbnail']=file.read(thumb_off.field_length)
+        end
+    end
+    return hdr.tags
+end
+
+end
+end
+end
+end

data/lib/cul_image_props/image/properties/types.rb

@@ -0,0 +1,318 @@
+require 'nokogiri'
+require 'cul_image_props/image/properties/exif'
+module Cul
+module Image
+module Properties
+
+class Namespace
+  def initialize(href, prefix)
+    @href = href
+    @prefix = prefix
+  end
+  def href
+    @href
+  end
+  def prefix
+    @prefix
+  end
+end
+
+ASSESS = Namespace.new("http://purl.oclc.org/NET/CUL/RESOURCE/STILLIMAGE/ASSESSMENT/","si-assess")
+BASIC = Namespace.new("http://purl.oclc.org/NET/CUL/RESOURCE/STILLIMAGE/BASIC/","si-basic")
+DCMI = Namespace.new("http://purl.org/dc/terms/","dcmi")
+
+class Base
+  attr_accessor :nodeset
+  BASE_XML = Nokogiri::XML.parse(<<-xml
+<rdf:Description xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+ xmlns:si-assess="http://purl.oclc.org/NET/CUL/RESOURCE/STILLIMAGE/ASSESSMENT/"
+ xmlns:si-basic="http://purl.oclc.org/NET/CUL/RESOURCE/STILLIMAGE/BASIC/"
+ xmlns:dcmi="http://purl.org/dc/terms/"></rdf:Description>
+xml
+)
+  def initialize(srcfile=nil)
+    @src = srcfile
+    @src.rewind
+    @ng_xml = BASE_XML.clone
+  end
+  def nodeset
+    @ng_xml.root.element_children
+  end
+  def [](key)
+    result = nil
+    nodeset.each { |node|
+      if (node.namespace.href + node.name) == key
+        if node.attribute('resource').nil?
+          result = node.text
+        else
+          result = node.attribute('resource').value
+        end
+      end
+    }
+    result
+  end
+  def add_dt_prop(prefix, name, value)
+    prop = @ng_xml.create_element(name)
+    @ng_xml.root.namespace_definitions.each { |ns| prop.namespace = ns if ns.prefix == prefix }
+    prop.add_child(@ng_xml.create_text_node(value.to_s))
+    @ng_xml.root.add_child( prop )
+  end
+
+  def sampling_unit=(name)
+    prop = @ng_xml.create_element("samplingFrequencyUnit")
+    @ng_xml.root.namespace_definitions.each { |ns| prop.namespace = ns if ns.prefix == "si-assess" }
+    @ng_xml.root.add_child( prop )
+    prop.set_attribute("rdf:resource", prop.namespace.href + name)
+  end
+
+  def x_sampling_freq=(value)
+    add_dt_prop("si-assess", "xSamplingFrequency", value)
+  end
+
+  def y_sampling_freq=(value)
+    add_dt_prop("si-assess", "ySamplingFrequency", value)
+  end
+
+  def width=(value)
+    add_dt_prop("si-basic", "imageWidth", value)
+  end
+
+  def length=(value)
+    add_dt_prop("si-basic", "imageLength", value)
+  end
+
+  def extent=(value)
+    add_dt_prop("dcmi", "extent", value)
+  end
+end
+
+class Bmp < Base
+  def initialize(srcfile=nil)
+    super
+    header_bytes = @src.read(18)
+    raise "Source file is not a bitmap" unless header_bytes[0...2] == Cul::Image::Magic::BMP
+    size = header_bytes[-4,4].unpack('V')[0]
+    header_bytes = header_bytes + @src.read(size)
+    dims = header_bytes[0x12...0x1a].unpack('VV')
+    sampling = header_bytes[0x26...0x2e].unpack('VV')
+    self.sampling_unit='CentimeterSampling'
+    self.width= dims[0]
+    self.length= dims[1]
+    self.extent= srcfile.stat.size unless srcfile.nil?
+    self.x_sampling_freq= (sampling[0]) # / 100).ceil
+    self.y_sampling_freq= (sampling[1]) # / 100).ceil
+  end
+end
+
+class Gif < Base
+  def initialize(srcfile=nil)
+    super
+    header_bytes = @src.read(13)
+    raise "Source file is not a gif" unless header_bytes[0...4] == Cul::Image::Magic::GIF
+    self.width= header_bytes[6,2].unpack('v')[0]
+    self.length= header_bytes[8,2].unpack('v')[0]
+    self.extent= srcfile.stat.size unless srcfile.nil?
+  end
+end
+
+class Jpeg < Base
+  def initialize(srcfile=nil)
+    super
+    header_bytes = @src.read(2)
+    raise "Source file is not a jpeg" unless header_bytes[0...2] == Cul::Image::Magic::JPEG
+    xpix = 0
+    ypix = 0
+    while (!@src.eof?)
+      if "\xFF" == @src.read(1)
+        mrkr = "\xFF" + @src.read(1)
+        blen = @src.read(2).unpack('n')[0]
+        if Cul::Image::Magic::JPEG_FRAME_MARKERS.include? mrkr  # SOFn, Start of frame for scans
+          @src.read(1) #skip bits per sample
+          self.length= @src.read(2).unpack('n')[0]
+          self.width= @src.read(2).unpack('n')[0]
+          @src.seek(0, IO::SEEK_END)
+        else
+          @src.seek(blen - 2, IO::SEEK_CUR)
+        end
+      else
+        @src.seek(0, IO::SEEK_END)
+      end
+    end
+
+    @src.rewind
+    tags = Cul::Image::Properties::Exif.process_file(@src)
+    if tags.include? 'Image ImageWidth'
+      self.width= tags['Image ImageWidth'].values[0]
+    end
+    if tags.include? 'Image ImageLength'
+      self.length= tags['Image ImageLength'].values[0]
+    end
+    if tags.include? 'Image XResolution'
+      self.x_sampling_freq= tags['Image XResolution'].values[0]
+    end
+    if tags.include? 'Image YResolution'
+      self.y_sampling_freq= tags['Image YResolution'].values[0]
+    end
+    if tags.include? 'Image ResolutionUnit'
+      if (tags['Image ResolutionUnit'].values[0] == 3)
+        self.sampling_unit='CentimeterSampling'
+      elsif (tags['Image ResolutionUnit'].values[0] == 2)
+        self.sampling_unit='InchSampling'
+      else
+        self.sampling_unit='NoAbsoluteSampling'
+      end
+    end
+    self.extent= srcfile.stat.size unless srcfile.nil?
+  end
+end
+
+class Png < Base
+  def initialize(srcfile=nil)
+    super
+    header_bytes = @src.read(8)
+    raise "Source file is not a png" unless header_bytes[0...8] == Cul::Image::Magic::PNG
+    until @src.eof?
+      clen = @src.read(4).unpack('N')[0]
+      ctype = @src.read(4)
+      case ctype
+      when 'pHYs'
+        pHYs(clen)
+      when 'IHDR'
+        IHDR(clen)
+      when 'tEXt'
+        tEXt(clen)
+      when 'IEND'
+        IEND(clen)
+      else
+        @src.seek(clen+4, IO::SEEK_CUR)
+      end
+    end
+    self.extent= srcfile.stat.size unless srcfile.nil?
+  end
+  def pHYs(len)
+    val = @src.read(9)
+    xres = val[0,4].unpack('N')[0]
+    yres = val[4,4].unpack('N')[0]
+    unit = val[8]
+    if unit == 1 # resolution unit is METER
+      xres = (xres / 100).ceil
+      yres = (yres / 100).ceil
+      self.sampling_unit='CentimeterSampling'
+    else
+      self.sampling_unit='NoAbsoluteSampling'
+    end
+    self.x_sampling_freq= xres
+    self.y_sampling_freq= yres
+    @src.seek(len - 5, IO::SEEK_CUR) # remaining block + end tag
+  end
+  def IHDR(len)
+    val = @src.read(8)
+    self.width= val[0,4].unpack('N')[0]
+    self.length= val[4,4].unpack('N')[0]
+    @src.seek(len - 4, IO::SEEK_CUR) # remaining block + end tag
+  end
+  def tEXt(len)
+    @src.seek(len + 4, IO::SEEK_CUR) # remaining block + end tag
+  end
+  def IEND(len)
+    @src.seek(0, IO::SEEK_END)
+  end
+end
+
+module Exif
+  def read_header(srcfile, endian, offset)
+    return ExifHeader(srcfile, endian, offset)
+  end
+end
+
+module LittleEndian
+  def byte(str, signed=false)
+    if signed
+      return str[0,1].unpack('c')[0]
+    else
+      return str[0,1].unpack('C')[0]
+    end
+  end
+  def short(str, signed=false)
+    result = str[0,2].unpack('v')[0]
+    if signed
+      return ~ result unless result < 32768
+    end
+    return result
+  end
+  def int(str, signed=false)
+    result = str[0,4].unpack('V')[0]
+    if signed
+      return ~ result unless result < 2147483648
+    end
+    return result
+  end
+end
+
+module BigEndian
+  def byte(str, signed=false)
+    if signed
+      return str[0,1].unpack('c')[0]
+    else
+      return str[0,1].unpack('C')[0]
+    end
+  end
+  def short(str, signed=false)
+    result = str[0,2].unpack('n')[0]
+    if signed
+      return ~ result unless result < 32768
+    end
+    return result
+  end
+  def int(str, signed=false)
+    result = str[0,4].unpack('N')[0]
+    if signed
+      return ~ result unless result < 2147483648
+    end
+    return result
+  end
+end
+
+class Tiff < Base
+  def initialize(srcfile=nil)
+    super
+    header_bytes = @src.read(14)
+    case header_bytes[0...4]
+    when Cul::Image::Magic::TIFF_INTEL_LE
+      @endian = header_bytes[12]
+    when Cul::Image::Magic::TIFF_MOTOROLA_BE
+      @endian = header_bytes[12]
+    else
+      raise "Source file is not a tiff" 
+    end
+    @src.rewind
+    tags = Cul::Image::Properties::Exif.process_file(srcfile)
+    if tags.include? 'Image ImageWidth'
+      self.width= tags['Image ImageWidth'].values[0]
+    end
+    if tags.include? 'Image ImageLength'
+      self.length= tags['Image ImageLength'].values[0]
+    end
+    if tags.include? 'Image XResolution'
+      self.x_sampling_freq= tags['Image XResolution'].values[0].inspect
+    end
+    if tags.include? 'Image YResolution'
+      self.y_sampling_freq= tags['Image YResolution'].values[0].inspect
+    end
+    if tags.include? 'Image ResolutionUnit'
+      if (tags['Image ResolutionUnit'].values[0] == 3)
+        self.sampling_unit='CentimeterSampling'
+      elsif (tags['Image ResolutionUnit'].values[0] == 2)
+        self.sampling_unit='InchSampling'
+      else
+        self.sampling_unit='NoAbsoluteSampling'
+      end
+    end
+    # do stuff with tags
+    self.extent= srcfile.stat.size unless srcfile.nil?
+  end
+end
+
+end
+end
+end

data/lib/cul_image_props/image/properties/version.rb

@@ -0,0 +1,7 @@
+module Cul
+module Image
+module Properties
+VERSION = "0.1.0"
+end
+end
+end

data/lib/cul_image_props/image/properties.rb

@@ -0,0 +1,51 @@
+require 'cul_image_props/image/properties/version'
+require 'cul_image_props/image/properties/types'
+require 'cul_image_props/image/magic'
+require 'open-uri'
+
+module Cul
+module Image
+module Properties
+  def self.identify(src)
+    if src.is_a? String
+      src = open(src)
+    end
+    filesize = src.stat.size
+    result = nil
+    magic_bytes = ''
+    buf = ''
+    src.read(2,buf)
+    magic_bytes << buf
+    case magic_bytes
+    when Cul::Image::Magic::BMP
+      result = Cul::Image::Properties::Bmp.new(src)
+    when Cul::Image::Magic::JPEG
+      result = Cul::Image::Properties::Jpeg.new(src)
+    end
+
+    if result.nil?
+      src.read(2,buf)
+      magic_bytes << buf
+      case magic_bytes
+      when Cul::Image::Magic::TIFF_MOTOROLA_BE
+        result = Cul::Image::Properties::Tiff.new(src)
+      when Cul::Image::Magic::TIFF_INTEL_LE
+        result = Cul::Image::Properties::Tiff.new(src)
+      when Cul::Image::Magic::GIF
+        result = Cul::Image::Properties::Gif.new(src)
+      end
+    end
+    if result.nil?
+      src.read(4,buf)
+      magic_bytes << buf
+      if magic_bytes == Cul::Image::Magic::PNG
+        result = Cul::Image::Properties::Png.new(src)
+      else
+        puts magic_bytes.unpack('H2H2H2H2H2H2H2H2').inspect
+      end
+    end
+    return result
+  end
+end
+end
+end

data/lib/cul_image_props/image.rb

@@ -0,0 +1,5 @@
+require 'cul_image_props/image/properties'
+module Cul
+module Image
+end
+end

data/lib/cul_image_props.rb

@@ -0,0 +1,11 @@
+require 'cul_image_props/image/properties/version'
+require 'cul_image_props/image'
+module Cul
+module Image
+module Properties
+  def self.version
+    Cul::Image::Properties::VERSION
+  end
+end
+end
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification 
+name: cul_image_props
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Benjamin Armintor
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-14 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 43
+        segments: 
+        - 0
+        - 9
+        - 8
+        version: 0.9.8
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: Library for extracting basic image properties
+email: armintor@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/cul_image_props/image/magic.rb
+- lib/cul_image_props/image/properties/exif/constants.rb
+- lib/cul_image_props/image/properties/exif/types.rb
+- lib/cul_image_props/image/properties/exif.rb
+- lib/cul_image_props/image/properties/types.rb
+- lib/cul_image_props/image/properties/version.rb
+- lib/cul_image_props/image/properties.rb
+- lib/cul_image_props/image.rb
+- lib/cul_image_props.rb
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.13
+signing_key: 
+specification_version: 3
+summary: Library for extracting basic image properties
+test_files: []
+