photo-utils 0.2

data/lib/photo_utils/camera.rb

@@ -0,0 +1,82 @@
+module PhotoUtils
+
+  class Camera
+
+    CAMERAS_PATH = Path.new(ENV['HOME']) / '.cameras.rb'
+
+    def self.cameras
+      unless class_variable_defined?('@@cameras')
+        if CAMERAS_PATH.exist?
+          @@cameras = eval(CAMERAS_PATH.read)
+        end
+      end
+      @@cameras
+    end
+
+    def self.find(params)
+      if (sel = params[:name])
+        cameras.find { |c| sel === c.name }
+      else
+        raise "Don't know how to search for camera with params: #{params.inspect}"
+      end
+    end
+
+    def self.[](name)
+      find(name: name)
+    end
+
+    attr_accessor :name
+    attr_accessor :formats
+    attr_accessor :format
+    attr_accessor :min_shutter
+    attr_accessor :max_shutter
+    attr_accessor :shutter
+    attr_accessor :lenses
+    attr_accessor :lens
+
+    def initialize(params={})
+      if params[:format]
+        params[:formats] = [params.delete(:format)]
+      end
+      params.each { |k, v| send("#{k}=", v) }
+      @format ||= @formats.first
+      normal = @format.frame.diagonal
+      # set the lens to the one closest to normal (diagonal of frame)
+      @lens = @lenses.sort_by { |l| (normal - l.focal_length).abs }.first
+      @shutter = @max_shutter
+    end
+
+    def min_shutter=(t)
+      @min_shutter = t ? Time.new(t) : nil
+    end
+
+    def max_shutter=(t)
+      @max_shutter = t ? Time.new(t) : nil
+    end
+
+    def shutter=(t)
+      @shutter = t ? Time.new(t) : nil
+    end
+
+    def angle_of_view
+      raise "Need focal length and format size to determine angle of view" unless @lens && @lens.focal_length && @format
+      @format.angle_of_view(@lens.focal_length)
+    end
+
+    def print(io=STDOUT)
+      io.puts "#{@name}: format: #{@format}, shutter: #{@max_shutter} - #{@min_shutter}"
+      @lenses.sort_by(&:focal_length).each do |lens|
+        io.puts "\t%s %s: focal length: %s (35mm equiv: %s), aperture: %s~%s" % [
+          lens == self.lens ? '*' : ' ',
+          lens.name,
+          lens.focal_length.format_metric(1),
+          @format.focal_length_equivalent(lens.focal_length).format_metric(1),
+          lens.max_aperture,
+          lens.min_aperture,
+        ]
+      end
+    end
+
+  end
+
+end

data/lib/photo_utils/compensation.rb

@@ -0,0 +1,29 @@
+module PhotoUtils
+
+  class Compensation < Value
+
+    # amount specified in stops
+
+    def self.new_from_v(v)
+      new(v)
+    end
+
+    def format_value
+      "Cv:%s%s" % [
+        (self < 0) ? '-' : '+',
+        abs.format(10)
+      ]
+    end
+
+    def to_s(format=:value)
+      case format
+      when :value
+        format_value
+      else
+        raise "Unknown format: #{format.inspect}"
+      end
+    end
+
+  end
+
+end

data/lib/photo_utils/extensions/array.rb

@@ -0,0 +1,11 @@
+class Array
+
+  def sum
+    inject(nil) { |sum, x| sum ? sum + x : x }
+  end
+
+  def mean
+    sum / size
+  end
+
+end

data/lib/photo_utils/extensions/float.rb

@@ -0,0 +1,18 @@
+class Float
+
+  def prec(x)
+    if self == self.round
+      self
+    else
+      ('%.*f' % [x, self]).to_f
+    end
+  end
+
+  def format(precision=nil)
+    '%.*f' % [
+      (precision.nil? || self < precision) ? 1 : 0,
+      self,
+    ]
+  end
+
+end

data/lib/photo_utils/extensions/math.rb

@@ -0,0 +1,11 @@
+module Math
+
+  NaN           = 0.0/0
+  Infinity      = 1.0/0
+  MinusInfinity = -Infinity
+
+  def self.arcdeg(a)
+    a * (180 / PI)
+  end
+
+end

data/lib/photo_utils/extensions/numeric.rb

@@ -0,0 +1,23 @@
+require 'photo_utils'
+
+INCHES_PER_METER = 39.3700787402
+
+class Numeric
+
+  def feet
+    PhotoUtils::Length.new(self.to_f * 12 / INCHES_PER_METER * 1000)
+  end
+
+  def inches
+    PhotoUtils::Length.new(self.to_f / INCHES_PER_METER * 1000)
+  end
+
+  def meters
+    PhotoUtils::Length.new(self * 1000)
+  end
+
+  def mm
+    PhotoUtils::Length.new(self)
+  end
+
+end

data/lib/photo_utils/formats.rb

@@ -0,0 +1,146 @@
+module PhotoUtils
+
+  class Format
+
+    # http://photo.net/medium-format-photography-forum/00LZPS
+    # http://www.largeformatphotography.info/forum/showthread.php?t=2503
+    # http://www.kenrockwell.com/tech/format.htm#120
+    # http://www.mamiya.com/rb67-pro-sd-accessories-film-magazines,-holders-inserts-roll-film-magazines.html
+    # from http://en.wikipedia.org/wiki/Image_sensor_format
+
+    # name  height  width   aliases
+    FormatDescriptions = %q{
+      1/6                         2.4   1.8
+      1/4                         2.7   3.6
+      1/3.6                       3     4
+      1/3.2                       3.42  4.54
+      1/3                         3.6   4.8
+      1/2.7                       4.04  5.37
+      1/2.5                       4.29  5.76
+      1/2                         4.8   6.4
+      1/1.8                       5.32  7.18
+      1/1.7                       5.7   7.6     Canon PowerShot G9, Canon PowerShot G10
+      1/1.6                       6.01  8.08
+      2/3                         9.6   12.8
+      1                           9.6   12.8
+      4/3                         13    17.3
+
+      APS-C                       14.8  22.2    Canon EOS DIGITAL REBEL XT, Canon EOS DIGITAL REBEL XTi, Canon EOS DIGITAL REBEL XSi, Canon EOS 450D
+      APS-H                       19.1  28.7
+      R-D1                        15.6  23.7    Epson R-D1, Epson R-D1s, Epson R-D1g, Epson R-D1x
+
+      DX                          15.5  23.6    NIKON D70
+
+      Leica S2                    30    45
+
+      35		                      24		36      FF, Canon EOS 5D
+
+      6x4.5		                    56		42      645
+      6x4.5 short		              56		40.5
+      6x4.5 Mamiya RB/RZ67	      56		41.5
+      6x6                   		  56		56
+      6x6 short		                56		54
+      6x7		                      56		72
+      6x7 short		                56		69.5
+      6x7 Mamiya RB/RZ67		      56		69.5
+      6x7 Toyo		                56		67
+      6x7 Horseman		            56		68
+      6x7 Pentax		              55		70
+      6x7 Cambo-Sinar-Wista		    56		70
+      6x7 Linhof Super Rollex		  56		72
+      6x7 Linhof Rapid Rollex		  57		76
+      6x8		                      56		76
+      6x9		                      56		84
+      6x9 23 Graphic		          56		83
+      6x9 Cambo-Horseman-Wista	  56		82
+      6x9 Toyo		                56		84
+      6x9 Linhof		              56		85
+      6x9 Sinar		                57		88
+      6x10		                    56		92
+      6x12		                    56		112
+      6x12 Linhof		              57		120
+      6x17		                    56		168
+      6x17		                    56		168
+
+      Polaroid 660                73    95
+      Polaroid 660 on Mamiya RB/RZ67    73    73
+
+      Polaroid 550		            92		126
+      Polaroid 545		            95		122
+      4x5 Quickload		            95		120
+      4x5 Fidelity		            97		120     4x5
+
+      5x7                         127   178
+
+      8x10                        203   254
+    }
+
+    def self.load_formats
+      @@formats = {}
+      FormatDescriptions.split("\n").each do |line|
+        case line.sub(/#.*/, '').strip
+        when /^(.*?)\s{2,}([\d\.]+)\s+([\d\.]+)\s*(.*?)$/
+          name, height, width, aliases = $1, $2, $3, $4
+          frame = Frame.new(width.to_f, height.to_f)
+          format = Format.new(name: name, frame: frame)
+          @@formats[name] = format
+          aliases.split(/,\s*/).each { |a| @@formats[a] = format }
+        when ''
+          # ignore blank line
+        else
+          raise "Can't parse format line: #{line.inspect}"
+        end
+      end
+    end
+
+    def self.[](name)
+      load_formats unless class_variable_defined?('@@formats')
+      @@formats[name]
+    end
+
+    attr_accessor :name
+    attr_accessor :frame
+
+    def initialize(params={})
+      params.each { |k, v| send("#{k}=", v) }
+    end
+
+    def inspect
+      "<#{self.class} name=#{@name.inspect} frame=#{@frame.inspect}>"
+    end
+
+    def to_s(short=true)
+      if short
+        @name
+      else
+        "#{@name} (#{@frame})"
+      end
+    end
+
+    def focal_length_equivalent(focal_length, other=Format['35'])
+      f = focal_length * crop_factor(other)
+      Length.new(f)
+    end
+
+    def crop_factor(reference=Format['35'])
+      # http://en.wikipedia.org/wiki/Crop_factor
+      reference.frame.diagonal / @frame.diagonal
+    end
+
+    def angle_of_view(focal_length)
+      # http://imaginatorium.org/stuff/angle.htm
+      # http://en.wikipedia.org/wiki/Angle_of_view
+      a = Math.arcdeg(2 * Math.atan(@frame.diagonal / (2 * focal_length)))
+      Angle.new(a)
+    end
+
+    def field_of_view(focal_length, subject_distance)
+      # http://en.wikipedia.org/wiki/Field_of_view
+      Frame.new(
+        subject_distance * (@frame.height / focal_length),
+        subject_distance * (@frame.width  / focal_length))
+    end
+
+  end
+
+end

data/lib/photo_utils/frame.rb

@@ -0,0 +1,36 @@
+module PhotoUtils
+
+  # http://photo.net/medium-format-photography-forum/00QiiV
+
+  class Frame
+
+    attr_accessor :height
+    attr_accessor :width
+
+    def initialize(height, width)
+      # correct swapped values
+      width, height = height, width if height < width
+      @height = Length.new(height)
+      @width  = Length.new(width)
+    end
+
+    def inspect
+      "<#{self.class} height=#{@height.inspect} width=#{@width.inspect}>"
+    end
+
+    def to_s(format=:metric)
+      if @height == Math::Infinity && @width == Math::Infinity
+        "n/a"
+      else
+        "#{@height.to_s(format)} x #{@width.to_s(format)}"
+      end
+    end
+
+    def diagonal
+      d = Math.sqrt((@height ** 2) + (@width ** 2))
+      Length.new(d)
+    end
+
+  end
+
+end

data/lib/photo_utils/illuminance.rb

@@ -0,0 +1,48 @@
+module PhotoUtils
+
+  class Illuminance < Value
+
+    N = 2 ** Rational(-7, 4)
+    C = 224
+    NC = N * C
+
+    # amount specified in lux
+
+    def self.new_from_lux(lux)
+      new(lux)
+    end
+
+    def self.new_from_v(v)
+      new((2 ** v.to_f) * NC)
+    end
+
+    def to_v
+      Math.log2(self / NC)
+    end
+
+    def to_lux
+      to_f
+    end
+
+    def format_lux
+      to_lux.format(10) + ' lux'
+    end
+
+    def format_value
+      "Iv:#{to_v.format(10)}"
+    end
+
+    def to_s(format=:lux)
+      case format
+      when :lux
+        format_lux
+      when :value
+        format_value
+      else
+        raise "Unknown format: #{format.inspect}"
+      end
+    end
+
+  end
+
+end

data/lib/photo_utils/length.rb

@@ -0,0 +1,92 @@
+require 'delegate'
+
+module PhotoUtils
+
+  class Length < DelegateClass(Float)
+
+    def initialize(x)
+      case x
+      when Length
+        super(x)
+      when Numeric
+        super(x.to_f)
+      when '∞'
+        super(Math::Infinity)
+      when String
+        n = 0
+        s = x.dup
+        until s.empty?
+          if s.gsub!(/^\s*(\d+(\.\d+)?)\s*/, '')
+            n2 = $1.to_f
+            n2 = if s.gsub!(/^('|ft\b)/, '')
+              n2.feet
+            elsif s.gsub!(/^("|in\b)/, '')
+              n2.inches
+            elsif s.gsub!(/^\s*m\b/, '')
+              n2.meters
+            elsif s.gsub!(/^\s*(mm\b)?/, '')
+              n2.mm
+            else
+              raise "Can't parse unit: #{s.inspect}"
+            end
+            n += n2
+          else
+            raise "Can't parse number: #{s.inspect}"
+          end
+        end
+        super(n)
+      else
+        raise "Can't make length from #{x.class}: #{x.inspect}"
+      end
+    end
+
+    def format_imperial
+      inches = self * INCHES_PER_METER / 1000
+      if inches.floor >= 12
+        feet = (inches / 12).floor
+        inches %= 12
+      else
+        feet = 0
+      end
+      if inches > 0
+        inches = inches.ceil
+        if inches == 12
+          feet += 1
+          inches = 0
+        end
+      end
+      (feet > 0 ? "#{feet}'" : '') + (inches > 0 ? "#{inches}\"" : '')
+    end
+
+    def format_metric(precision=nil)
+      if self >= 1000
+        "#{(self / 1000).format(precision)}m"
+      else
+        "#{format(precision)}mm"
+      end
+    end
+
+    def to_s(format=:metric)
+      if self == Math::Infinity
+        '∞'
+      else
+        case format
+        when :imperial
+          format_imperial
+        when :metric
+          format_metric
+        end
+      end
+    end
+
+    def -(other)
+      self.class.new(super(other))
+    end
+
+    def abs
+      self.class.new(super)
+    end
+
+  end
+
+end