photo-utils 0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 70d478e0579f15d1fdba607ac85c84827ba8cea2
+  data.tar.gz: 53980404437217abd59062595727a0734aeb8fef
+SHA512:
+  metadata.gz: 94bc1d34be20f01ff721d12a681a5487d6278f17a50d9edddb0d1a1472f08195d532ce6d9d61b4d00cfd7e8c8579ea117c4a7c3af2c0bb91b653aed0dcad248e
+  data.tar.gz: fc13ab1c3f0876db872371ee1bbf6082889333702faa349a6ed5f75e4c8474dee0cb9b4a3dd5d7b8e0d8135e4d5ef3382c51a4203085e0e91bd6bbccee5e0403

data/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+Gemfile.lock
+pkg/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in photo-utils.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1 @@
+FIXME

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/TODO.txt

@@ -0,0 +1,34 @@
+    
+  - Create FieldCalculator class:
+    - Set subject distance/height/width/depth
+    - Does DoF calculations
+  
+  - Create generic camera models:
+    - 35mm w/50mm lens
+    - 6x6 w/80mm lens
+    - 4x5 w/127mm lens
+    - APS-C w/? lens
+  
+  - Create Subject class
+    - Height/width.
+    - Near/far depth of field.
+    
+  - Add print size to Scene
+    - Calculate best CoC according to print size
+    
+  - Create Medium class?
+    - eg, film, plate, instant, CCD/CMOS
+    - With #sensitivity.
+
+  - Add common brightness values to Brightness class.
+    - eg, open shade, bright sun, etc.
+      
+  - Add lighting formulas:
+    http://www.lightsearch.com/resources/lightguides/formulas.html
+    http://www.birket.com/technical-library/143/
+    
+  - Add flash calculation
+    
+    http://www.scantips.com/lights/flashbasics1c.html
+    http://www.portraitlighting.net/inversesquare_law.htm
+    http://en.wikipedia.org/wiki/Guide_number

data/bin/photo-util

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.join(File.realpath(File.dirname($0)), '..', 'lib'))
+
+require 'photo_utils'
+require 'photo_utils/tools/reciprocity'
+require 'photo_utils/tools/focal_length'
+require 'photo_utils/tools/test'
+require 'photo_utils/tools/dof_table'
+require 'photo_utils/tools/dof'
+require 'photo_utils/tools/compare'
+require 'photo_utils/tools/blur'
+require 'photo_utils/tools/film_test'
+require 'photo_utils/tools/brightness'
+require 'photo_utils/tools/cameras'
+require 'photo_utils/tools/calc_aperture'
+require 'photo_utils/tools/chart_dof'
+
+options = {}
+appname = File.basename($0)
+
+commands = {
+  'reciprocity'   => PhotoUtils::Tools::Reciprocity,
+  'focal-length'  => PhotoUtils::Tools::FocalLength,
+  'test'          => PhotoUtils::Tools::Test,
+  'dof-table'     => PhotoUtils::Tools::DOFTable,
+  'dof'           => PhotoUtils::Tools::DOF,
+  'compare'       => PhotoUtils::Tools::Compare,
+  'blur'          => PhotoUtils::Tools::Blur,
+  'film-test'     => PhotoUtils::Tools::FilmTest,
+  'brightness'    => PhotoUtils::Tools::Brightness,
+  'cameras'       => PhotoUtils::Tools::Cameras,
+  'calc-aperture' => PhotoUtils::Tools::CalcAperture,
+  'chart-dof'     => PhotoUtils::Tools::ChartDOF,
+}
+
+cmd = ARGV.shift or raise "Usage"
+cmd_class = commands[cmd] or raise "Usage"
+cmd_class.new.run(ARGV)

data/lib/photo_utils.rb

@@ -0,0 +1,28 @@
+require 'pp'
+require 'hashstruct'
+require 'builder'
+require 'path'
+
+require 'photo_utils/extensions/math'
+require 'photo_utils/extensions/array'
+require 'photo_utils/extensions/float'
+require 'photo_utils/extensions/numeric'
+
+require 'photo_utils/length'
+require 'photo_utils/angle'
+require 'photo_utils/value'
+
+require 'photo_utils/aperture'
+require 'photo_utils/brightness'
+require 'photo_utils/compensation'
+require 'photo_utils/illuminance'
+require 'photo_utils/sensitivity'
+require 'photo_utils/time'
+
+require 'photo_utils/apex'
+require 'photo_utils/lens'
+require 'photo_utils/camera'
+require 'photo_utils/frame'
+require 'photo_utils/formats'
+require 'photo_utils/scene'
+require 'photo_utils/scene_view'

data/lib/photo_utils/angle.rb

@@ -0,0 +1,17 @@
+require 'delegate'
+
+module PhotoUtils
+
+  class Angle < DelegateClass(Float)
+
+    def initialize(n)
+      super(n.to_f)
+    end
+
+    def to_s
+      "#{format}°"
+    end
+
+  end
+
+end

data/lib/photo_utils/aperture.rb

@@ -0,0 +1,62 @@
+module PhotoUtils
+
+  class Aperture < Value
+
+    def self.new_from_fstop(f)
+      new(f)
+    end
+
+    def self.new_from_v(v)
+      new(Math.sqrt(2 ** v.to_f))
+    end
+
+    def to_v
+      Math.log2(self ** 2)
+    end
+
+    def format_fstop(stop_steps=3)
+      rounded_f = Aperture.new_from_v((to_v.to_f * stop_steps).to_i / stop_steps.to_f).format(10)
+      frac = rounded_f.to_f - rounded_f.to_i
+      if frac != 0
+        "f/#{rounded_f.to_f}"
+      else
+        "f/#{rounded_f.to_i}"
+      end
+    end
+
+    def format_us
+      # Av 8 is equivalent to f/16 and US 16
+      steps = to_v.to_i - 8
+      us = 16
+      if steps < 0
+        steps.abs.times { us /= 2 }
+      else
+        steps.times { us *= 2 }
+      end
+      "US #{us}"
+    end
+
+    def format_value
+      "Av:#{to_v.format(10)}"
+    end
+
+    def to_s(format=:fstop, stop_steps=3)
+      case format
+      when :us
+        format_us
+      when :fstop
+        format_fstop(stop_steps)
+      when :value
+        format_value
+      else
+        raise "Unknown format: #{format.inspect}"
+      end
+    end
+
+    def absolute(focal_length)
+      focal_length / self
+    end
+
+  end
+
+end

data/lib/photo_utils/apex.rb

@@ -0,0 +1,210 @@
+module PhotoUtils
+
+  class Exposure
+
+=begin
+
+    http://doug.kerr.home.att.net/pumpkin/APEX.pdf
+    http://en.wikipedia.org/wiki/APEX_system
+    http://en.wikipedia.org/wiki/Exposure_value
+    http://en.wikipedia.org/wiki/Light_meter#Exposure_meter_calibration
+
+    basic APEX formula:
+      Ev = Tv + Av = Sv + Bv
+
+    logarithmic to linear equations:
+      2^Av = N^2 (N is f-Number)
+      2^Tv = 1/T (T in seconds)
+      2^Sv = S/π (S is ASA film speed, now ISO)
+      2^Bv = Bl (Bl in foot-lamberts) = B/π (B in candles per square foot)
+
+    base values:
+      Tv = 0 for a time (shutter speed) of one second.
+      Av = 0 for an aperture of f/1.
+      Sv = 0 for a film speed of ISO 3.125 arithmetic (and hence Sv = 5 for ISO 100).
+      Bv = 0 for a scene brightness of 1 foot-lambert.
+
+    calculate time from exposure and aperture
+      Tv = Ev - Av
+
+    calculate time from brightness, sensitivity, and aperture
+      Tv = (Sv + Bv) - Av
+
+    calculate brightness from Ev and sensitivity
+      Bv = Ev - Sv
+
+    calculate Ev from aperture, time, and film speed
+      Ev = (Tv + Av) - Sv
+
+=end
+
+    attr_accessor :aperture
+    attr_accessor :time
+    attr_accessor :sensitivity
+    attr_accessor :light
+    attr_accessor :compensation
+
+    def initialize(params={})
+      params.each do |key, value|
+        send("#{key}=", value)
+      end
+    end
+
+    def aperture=(n)
+      @aperture = n ? Aperture.new(n) : nil
+    end
+
+    def time=(n)
+      @time = n ? Time.new(n) : nil
+    end
+
+    def sensitivity=(n)
+      @sensitivity = n ? Sensitivity.new(n) : nil
+    end
+
+    def light=(n)
+      @light = case n
+      when Brightness, Illuminance
+        n
+      when Numeric
+        Brightness.new(n)
+      when nil
+        nil
+      else
+        raise
+      end
+    end
+
+    def compensation=(n)
+      @compensation = n ? Compensation.new_from_v(n) : nil
+    end
+
+    def aperture
+      if @aperture
+        @aperture
+      elsif @sensitivity && @light && @time
+        Aperture.new_from_v(sv + lv - tv + cv)
+      else
+        raise "Need sensitivity/light/time to compute aperture"
+      end
+    end
+
+    def time
+      if @time
+        @time
+      elsif @sensitivity && @light && @aperture
+        Time.new_from_v(sv + lv - av + cv)
+      else
+        raise "Need sensitivity/light/aperture to compute time"
+      end
+    end
+
+    def sensitivity
+      if @sensitivity
+        @sensitivity
+      elsif @aperture && @time && @light
+        Sensitivity.new_from_v(av + tv - bv + cv)
+      else
+        raise "Need aperture/time/light to compute sensitivity"
+      end
+    end
+
+    def brightness
+      if @light
+        Brightness.new_from_v(lv)
+      elsif @aperture && @time && @sensitivity
+        Brightness.new_from_v(av + tv - sv + cv)
+      else
+        raise "Need aperture/time/sensitivity to compute brightness"
+      end
+    end
+
+    def illuminance
+      if @light
+        Illuminance.new_from_v(lv)
+      elsif @aperture && @time && @sensitivity
+        Illuminance.new_from_v(av + tv - sv + cv)
+      else
+        raise "Need aperture/time/sensitivity to compute illuminance"
+      end
+    end
+
+    def exposure
+      if @aperture && @time
+        av + tv
+      elsif @sensitivity && @light
+        sv + lv + cv
+      else
+        raise "Need aperture/time or sensitivity/light to compute exposure"
+      end
+    end
+
+    def av
+      aperture.to_v
+    end
+
+    def tv
+      time.to_v
+    end
+
+    def sv
+      sensitivity.to_v
+    end
+
+    def bv
+      brightness.to_v
+    end
+
+    def iv
+      illuminance.to_v
+    end
+
+    def lv
+      light.to_v
+    end
+
+    def cv
+      @compensation ? @compensation.to_f : 0
+    end
+
+    def ev
+      exposure
+    end
+
+    def ev100
+      ev - sv - Sensitivity.new(100).to_v
+    end
+
+    def stepped_exposures(steps=7, increment=0.3)
+      n = increment * (steps / 2)
+      (-n..n).step(increment).map do |adjustment|
+        new_exposure = dup
+        new_exposure.compensation = (@compensation ? @compensation : 0) + adjustment
+        new_exposure
+      end
+    end
+
+    def to_s
+      "%s = %s + %s = %s + %s" % [
+        "Ev:#{ev.format(10)}",
+        aperture.format_value,
+        time.format_value,
+        sensitivity.format_value,
+        light.format_value,
+      ]
+    end
+
+    def print(io=STDOUT)
+      io.puts "EXPOSURE:"
+      io.puts "            light: #{light} (#{light.format_value})"
+      io.puts "      sensitivity: #{sensitivity} (#{sensitivity.format_value})"
+      io.puts "         aperture: #{aperture} (#{aperture.format_value})"
+      io.puts "             time: #{time} (#{time.format_value})"
+      io.puts "     compensation: #{@compensation ? compensation.format_value : '--'}"
+      io.puts "         exposure: #{to_s}"
+      io.puts
+    end
+
+  end
+
+end

data/lib/photo_utils/brightness.rb

@@ -0,0 +1,49 @@
+module PhotoUtils
+
+  class Brightness < Value
+
+    # N = 2 ** Rational(-7, 4)
+    N = 0.3
+    K = 11.4
+    NK = N * K
+
+    # amount specified in cd/m2
+
+    def self.new_from_v(v)
+      new((2 ** v.to_f) * NK)
+    end
+
+    def self.new_from_cdm2(n)
+      new(n)
+    end
+
+    def to_v
+      Math.log2(self.to_f / NK)
+    end
+
+    def to_cdm2
+      to_f
+    end
+
+    def format_cdm2
+      to_cdm2.format(10) + ' cd/m2'
+    end
+
+    def format_value
+      "Bv:#{to_v.format}"
+    end
+
+    def to_s(format=:cdm2)
+      case format
+      when :cdm2
+        format_cdm2
+      when :value
+        format_value
+      else
+        raise "Unknown format: #{format.inspect}"
+      end
+    end
+
+  end
+
+end