photo-utils 0.2

data/lib/photo_utils/lens.rb

@@ -0,0 +1,50 @@
+module PhotoUtils
+
+  class Lens
+
+    attr_accessor :name
+    attr_reader   :focal_length
+    attr_accessor :min_aperture
+    attr_accessor :max_aperture
+    attr_accessor :aperture
+
+    def initialize(params={})
+      params.each { |k, v| send("#{k}=", v) }
+      @aperture = @max_aperture
+    end
+
+    def inspect
+      "<#{self.class}: name=#{@name.inspect}, focal_length=#{@focal_length.inspect}, min_aperture=#{@min_aperture.inspect}, max_aperture=#{@max_aperture.inspect}, aperture=#{@aperture.inspect}>"
+    end
+
+    def to_s
+      if @name
+        "#{@name} (#{@focal_length})"
+      else
+        @focal_length.to_s
+      end
+    end
+
+    def name
+      @name || @focal_length.to_s
+    end
+
+    def focal_length=(f)
+      @focal_length = Length.new(f)
+    end
+
+    def min_aperture=(a)
+      @min_aperture = Aperture.new(a)
+    end
+
+    def max_aperture=(a)
+      @max_aperture = Aperture.new(a)
+    end
+
+    def aperture=(a)
+      @aperture = Aperture.new(a)
+    end
+
+  end
+
+end

data/lib/photo_utils/scene.rb

@@ -0,0 +1,180 @@
+module PhotoUtils
+
+  class Scene
+
+    attr_accessor :description
+    attr_accessor :subject_distance
+    attr_accessor :background_distance
+    attr_accessor :camera
+    attr_accessor :sensitivity
+    attr_accessor :brightness
+
+    def initialize
+      {
+        background_distance: Math::Infinity,
+        sensitivity: 100,
+        brightness: 100,
+      }.each { |k, v| send("#{k}=", v) }
+    end
+
+    def sensitivity=(s)
+      @sensitivity = Sensitivity.new(s)
+    end
+
+    def brightness=(b)
+      @brightness = Brightness.new(b)
+    end
+
+    def subject_distance=(s)
+      @subject_distance = Length.new(s)
+    end
+
+    def background_distance=(s)
+      @background_distance = Length.new(s)
+    end
+
+    def circle_of_confusion
+      # http://en.wikipedia.org/wiki/Circle_of_confusion
+      @camera.format.frame.diagonal / 1750
+    end
+
+    def aperture_for_depth_of_field(near_limit, far_limit)
+      a = ((@camera.lens.focal_length ** 2) / circle_of_confusion) * ((far_limit - near_limit) / (2 * near_limit * far_limit))
+      Aperture.new(a)
+    end
+
+    def hyperfocal_distance
+      # http://en.wikipedia.org/wiki/Hyperfocal_distance
+      raise "Need focal length, aperture, and circle of confusion to determine hyperfocal distance" \
+        unless @camera.lens.focal_length && @camera.lens.aperture && circle_of_confusion
+      h = ((@camera.lens.focal_length ** 2) / (@camera.lens.aperture * circle_of_confusion)) + @camera.lens.focal_length
+      Length.new(h)
+    end
+
+    def depth_of_field
+      h = hyperfocal_distance
+      s = subject_distance
+      dof = HashStruct.new
+      dof.near = (h * s) / (h + s)
+      if s < h
+        dof.far = (h * s) / (h - s)
+      else
+        dof.far = Math::Infinity
+      end
+      dof.near = Length.new(dof.near)
+      dof.far  = Length.new(dof.far)
+      dof
+    end
+
+    def near_distance_from_subject
+      d = subject_distance - depth_of_field.near
+      Length.new(d)
+    end
+
+    def far_distance_from_subject
+      d = (depth_of_field.far == Math::Infinity) ? Math::Infinity : (depth_of_field.far - subject_distance)
+      Length.new(d)
+    end
+
+    def total_depth_of_field
+      d = (depth_of_field.far == Math::Infinity) ? Math::Infinity : (depth_of_field.far - depth_of_field.near)
+      Length.new(d)
+    end
+
+    def field_of_view(distance)
+      raise "Need focal length and format size to determine field of view" unless @camera.lens.focal_length && @camera.format
+      @camera.format.field_of_view(@camera.lens.focal_length, distance)
+    end
+
+    def magnification
+      # http://en.wikipedia.org/wiki/Depth_of_field#Hyperfocal_magnification
+      @camera.lens.focal_length / (subject_distance - @camera.lens.focal_length)
+    end
+
+    def subject_distance_for_field_of_view(fov)
+      d_w = fov.width  / @camera.format.frame.width  * @camera.lens.focal_length
+      d_h = fov.height / @camera.format.frame.height * @camera.lens.focal_length
+      [d_w, d_h].max
+    end
+
+    # AKA bellows factor
+
+    def working_aperture
+      # http://en.wikipedia.org/wiki/F-number#Working_f-number
+      Aperture.new((1 - magnification) * @camera.lens.aperture)
+    end
+
+    def blur_at_distance(d)
+      # http://en.wikipedia.org/wiki/Depth_of_field#Foreground_and_background_blur
+      xd = (d - subject_distance).abs
+      b = (@camera.lens.focal_length * magnification) / @camera.lens.aperture
+      if d < subject_distance
+        b *= xd / (subject_distance - xd)
+      else
+        b *= xd / (subject_distance + xd)
+      end
+      # diameter of blur disk, in mm
+      Length.new(b.mm)
+    end
+
+    def absolute_aperture
+      @camera.lens.aperture.absolute(@camera.lens.focal_length)
+    end
+
+    def exposure
+      Exposure.new(
+        light: @brightness,
+        sensitivity: @sensitivity,
+        aperture: @camera.lens.aperture,
+        time: @camera.shutter)
+    end
+
+    def set_exposure
+      exp = exposure
+      @camera.lens.aperture = exp.aperture
+      @camera.shutter = exp.time
+    end
+
+    def print_camera(io=STDOUT)
+      io.puts "CAMERA:"
+      io.puts "             name: #{@camera.name}"
+      io.puts "           format: #{@camera.format} (35mm crop factor: #{@camera.format.crop_factor.format(10)})"
+      io.puts "    shutter range: #{@camera.max_shutter} ~ #{@camera.min_shutter}"
+      io.puts "   aperture range: #{@camera.lens.max_aperture} ~ #{@camera.lens.min_aperture}"
+      io.puts "             lens: #{@camera.lens.name} - #{@camera.lens.focal_length} (#{
+        %w{35 6x4.5 6x6 6x7 5x7}.map { |f| "#{f}: #{@camera.format.focal_length_equivalent(@camera.lens.focal_length, Format[f])}" }.join(', ')
+      })"
+      io.puts "    angle of view: #{@camera.angle_of_view}"
+      io.puts "          shutter: #{@camera.shutter}"
+      io.puts "         aperture: #{@camera.lens.aperture}"
+      io.puts
+    end
+
+    def print_exposure(io=STDOUT)
+      exposure.print(io)
+    end
+
+    def print_depth_of_field(io=STDOUT)
+      io.puts "FIELD:"
+      io.puts "     subject dist: #{subject_distance.to_s(:imperial)}"
+      io.puts "      subject FOV: #{field_of_view(subject_distance).to_s(:imperial)}"
+      io.puts "      subject mag: #{'%.2f' % magnification}x"
+      io.puts "      subject DOF: #{total_depth_of_field.to_s(:imperial)} (-#{near_distance_from_subject.to_s(:imperial)}/+#{far_distance_from_subject.to_s(:imperial)})"
+      io.puts "  background dist: #{background_distance.to_s(:imperial)}"
+      if background_distance != Math::Infinity
+        io.puts "   background FOV: #{field_of_view(background_distance).to_s(:imperial)}"
+        io.puts "  background blur: #{blur_at_distance(background_distance).to_s(:metric)}"
+      end
+      io.puts "  hyperfocal dist: #{hyperfocal_distance.to_s(:imperial)}"
+      io.puts " working aperture: #{working_aperture}"
+      io.puts
+    end
+
+    def print(io=STDOUT)
+      print_depth_of_field(io)
+      print_exposure(io)
+    end
+
+  end
+
+end

data/lib/photo_utils/scene_view.rb

@@ -0,0 +1,134 @@
+require 'photo_utils'
+
+module PhotoUtils
+
+  class SceneView
+
+    attr_accessor :scene
+    attr_accessor :width
+    attr_accessor :height
+    attr_accessor :max_distance
+    attr_accessor :camera_width
+    attr_accessor :camera_height
+    attr_accessor :scale
+
+    def initialize(scene, options={})
+      @scene = scene
+      @width = options[:width] || 900
+      @height = options[:height] || 50
+      @max_distance = options[:max_distance] || @scene.depth_of_field.far
+      @camera_width  = options[:camera_width]  || @scene.focal_length
+      @camera_height = options[:camera_height] || [@scene.absolute_aperture, @scene.format.height].max
+      @scale = (@width.to_f - @height) / (@camera_width + @max_distance)
+      @camera_scale = [
+        @height.to_f / @camera_width,
+        @height.to_f / @camera_height
+      ].min
+    end
+
+    def to_svg
+      xml = Builder::XmlMarkup.new(indent: 2)
+      xml.svg(width: @width, height: @height) do
+        xml.defs do
+          1.upto(9).each do |std_dev|
+            xml.filter(id: "gb#{std_dev}") do
+              xml.feGaussianBlur(in: 'SourceGraphic', stdDeviation: std_dev)
+            end
+          end
+        end
+        xml.g(transform: "translate(#{@height},0)") do
+          draw_camera(xml)
+          draw_dof(xml)
+          draw_subject(xml)
+          # draw_hyperfocal(xml)
+        end
+      end
+      xml.target!
+    end
+
+    def draw_camera(xml)
+      fh2 = (@scene.format.height / 2) * @camera_scale
+      aa2 = (@scene.absolute_aperture / 2) * @camera_scale
+      points = [
+        [0, -fh2],
+        [@scene.focal_length * @camera_scale, -aa2],
+        [@scene.focal_length * @camera_scale, aa2],
+        [0, fh2],
+      ]
+      xml.g(transform: "translate(0,#{@height / 2})") do
+        xml.polygon(
+          x: -@height,
+          y: 0,
+          points: points.map { |p| p.join(',') }.join(' '),
+          fill: 'black')
+      end
+    end
+
+    def draw_dof(xml)
+      # blur
+
+      if true
+
+        step = @max_distance / 20
+        step.step(@max_distance, step).map { |d| Length.new(d) }.each do |d|
+          blur = @scene.blur_at_distance(d)
+          if blur == 0
+            std_dev = 0
+          else
+            ratio = @scene.circle_of_confusion / blur
+            std_dev = [9 - (ratio * 10).to_i, 0].max
+          end
+          xml.circle(
+            cx: d * @scale,
+            cy: @height / 2,
+            r: (step * @scale) / 2 / 2,
+            fill: 'black',
+            filter: (std_dev > 0) ? "url(\#gb#{std_dev})" : ())
+        end
+
+      else
+        step = (@max_distance / @width) * 10
+        0.step(@max_distance, step).map { |d| Length.new(d) }.each do |distance|
+          blur = @scene.blur_at_distance(distance)
+          opacity = [1, @scene.circle_of_confusion / blur].min
+          xml.rect(
+            x: distance * @scale,
+            y: (@height - (@scene.field_of_view(distance).height * @scale)) / 2,
+            width: step * @scale,
+            height: @scene.field_of_view(distance).height * @scale,
+            fill: 'blue',
+            'fill-opacity' => opacity)
+        end
+      end
+
+      # depth of focus area
+      xml.rect(
+        x: @scene.depth_of_field.near * @scale,
+        y: 0,
+        width: @scene.total_depth_of_field * @scale,
+        height: @height,
+        stroke: 'blue',
+        fill: 'none')
+    end
+
+    def draw_subject(xml)
+      xml.rect(
+        x: @scene.subject_distance * @scale,
+        y: 0,
+        width: 1,
+        height: @height,
+        fill: 'red')
+    end
+
+    def draw_hyperfocal(xml)
+      xml.line(
+        x1: @scene.hyperfocal_distance * scale,
+        y1: 0,
+        x2: @scene.hyperfocal_distance * scale,
+        y2: @height,
+        stroke: 'green')
+    end
+
+  end
+
+end

data/lib/photo_utils/sensitivity.rb

@@ -0,0 +1,44 @@
+module PhotoUtils
+
+  class Sensitivity < Value
+
+    C = 3.125
+
+    def self.new_from_iso(n)
+      new(n)
+    end
+
+    def self.new_from_v(v)
+      new(C * (2 ** v.to_f))
+    end
+
+    def to_v
+      Math.log2(self / C)
+    end
+
+    def to_iso
+      to_f
+    end
+
+    def format_iso
+      'ISO ' + to_iso.format(10)
+    end
+
+    def format_value
+      "Sv:#{to_v.format}"
+    end
+
+    def to_s(format=:iso)
+      case format
+      when :iso
+        format_iso
+      when :value
+        format_value
+      else
+        raise "Unknown format: #{format.inspect}"
+      end
+    end
+
+  end
+
+end

data/lib/photo_utils/time.rb

@@ -0,0 +1,53 @@
+module PhotoUtils
+
+  class Time < Value
+
+    def self.new_from_seconds(s)
+      new(s)
+    end
+
+    def self.new_from_v(v)
+      new(2 ** -v.to_f)
+    end
+
+    def to_v
+      -Math.log2(self.to_f)
+    end
+
+    def to_seconds
+      to_f
+    end
+
+    def format_seconds
+      if (seconds = to_seconds) < 1
+        '1/' + (1/self).format(1)
+      else
+        seconds.format
+      end + 's'
+    end
+
+    def format_value
+      "Tv:#{to_v.format(10)}"
+    end
+
+    def to_s(format=:seconds)
+      case format
+      when :seconds
+        format_seconds
+      when :value
+        format_value
+      else
+        raise "Unknown format: #{format.inspect}"
+      end
+    end
+
+    # http://www.apug.org/forums/forum37/22334-fuji-neopan-400-reciprocity-failure-data.html
+
+    def reciprocity
+      tc = self + (0.3 * (self ** 1.62))
+      Time.new(tc)
+    end
+
+  end
+
+end