stereobase.py

Created on June 17, 2019

1.8 KB

For 3D photography, calculate the stereo base for dual left and right cameras or sequential left and right eye photos from a single camera. The calculated base (mm) gives the most comfortable viewing experience for the stereo photo. Use different formulas for normal, close-up, or macro photography. Reference: http://nzphoto.tripod.com/stereo/3dtake/fbercowitz.htm

## 3D Photography: Stereo base calculation
# For dual camera stereo configuration 
# or single camera sequential L/R base separation
# Assumes 35mm equivalent lens focal length 
# P parallax for standard 35mm film - 36mm x 24 mm
#   P = 1.2 for 1/30 of 36mm width, 3.33% deviation
#   Assumes 3.33% is maximum deviation for comfortable viewing
#  This is the standard 1/30 rule.
# F lens focal length mm
# N near subject distance mm
# L background distance mm
# B stero base mm, the cameras interaxial distance

# Reference: http://nzphoto.tripod.com/stereo/3dtake/fbercowitz.htm

# Bercovitz formula for dual camera separation
def base(F, N, L, P=1.2):
  B=P*((L*N)/(L-N))*(1/F-(L+N)/(2*L*N))
  return B

# same as base()
def b(F, N, L, P=1.2):
  B=P/(L-N)*(L*N/F-(L+N)/2)
  return B

def near(F, B, L, P=1.2):
  t=B/P
  N = (L*(t + 0.5))/(t+L/F-0.5)
  return N
  
def far(F, B, N, P=1.2):
  t=B/P
  L = N*(t-0.5)/(t-N/F+0.5)
  return L

def focal(B, N, L, P=1.2):
  F = (L*N)/(B*(L-N)/P + (L+N)/2)
  return F
  
# Davis modification of Bercovitz formula for close-up photography
# assumes background is close to the subject
def base_closeup(F, N, L, P=1.2):
    if L<2*N:
        L = 2*N
    B=P*((L*N)/(L-N))*(1/F-(L+N)/(2*L*N))
    return B

# Wattie modification of Bercovitz formula for correct roundness
# for macro photography
# V is viewing distance mm typically 600mm for 15 inch diagonal notebook
# I is Interocular distance mm, average 63mm
def base_macro(F, N, L, V, I=63, P=1.2):
  B=P*((L*N)/(L-N))*(1/F-(L+N)/(2*L*N))
  W = N*I/V
  if W < B:
    return W
  else:
    return B

def base_meindre(F, N, L, P=1.2):
  B = (P/F)*((L*N)/(L-N))
  return B

def near_meindre(F, B, L, P=1.2):
  t = F*B/P
  N = (t*L)/(t + L)
  return N

# shortcut for close-up
def bc(F, N, L, P=1.2):
  return base_closeup(F, N, L)