cleaner imports, a new module 'camera', refactored default_scenes

Author: oseiskar

camera.py

@@ -0,0 +1,109 @@
+
+from utils import *
+
+def camera_rotmat(direction, up=(0, 0, 1)):
+    
+    # TODO camera roll
+    
+    direction = np.array(direction)
+    up = np.array(up)
+    
+    right = np.cross(direction, up)
+    up = np.cross(right, direction)
+    
+    rotmat = np.vstack((right, -up, direction))
+    
+    return normalize(rotmat).transpose()
+
+def rotmat_tilt_camera(xa, ya):
+    
+    rm2d = lambda a : np.array([[np.cos(a), -np.sin(a)], [np.sin(a), np.cos(a)]])
+    
+    rot3dy = np.identity(3)
+    rot3dy[1:, 1:] = rm2d(ya)
+    
+    rot3dx = np.identity(3)
+    
+    rot3dx[[[0], [2]], [0, 2]] = rm2d(xa)
+    
+    return np.dot(rot3dy, rot3dx)
+
+def camera_rays(wh, flat=False, wfov=60, direction=(0, 1, 0), up=(0, 0, 1)):
+    
+    w, h = wh
+    wfov = wfov/180.0*np.pi
+    aspect = h / float(w)
+    hfov = wfov * aspect
+    
+    rotmat = camera_rotmat(direction, up)
+    
+    #tilt = rotmat_tilt_camera(0.3,0.4)
+    #rotmat = np.dot(rotmat, tilt)
+    
+    if flat:
+        ra = np.tan(wfov * 0.5)
+        xr = np.linspace(-ra, ra, w)
+        yr = np.linspace(-ra*aspect, ra*aspect, h)
+        X, Y = np.meshgrid(xr, yr)
+        Z = np.ones(X.shape)
+    else:
+        pixel_angle = float(wfov)/w
+        xa = (np.arange(0, w)+0.5)*pixel_angle - wfov/2.0
+        ya = (np.arange(0, h)+0.5)*pixel_angle - hfov/2.0
+        Xa, Ya = np.meshgrid(xa, ya)
+        
+        X = np.sin(Xa)*np.cos(Ya)
+        Z = np.cos(Xa)*np.cos(Ya)
+        Y = np.sin(Ya)
+    
+    N = w*h
+    vecs = np.dstack((X, Y, Z))
+    vecs = np.reshape(vecs, (N, 3)).transpose()
+    vecs = np.dot(rotmat, vecs).transpose()
+    vecs = np.reshape(vecs, (h, w, 3))
+    
+    if flat:
+        vecs = normalize(vecs)
+    
+    return vecs
+
+def quasi_random_direction_sample(n, hemisphere=True):
+    """
+    "Vogel's method / Fermat's spiral",
+    adapted from http://blog.marmakoide.org/?p=1
+    
+    It appears that, in addition to the discussion in the above blog,
+    the first n of 2n of these points are evenly distributed in the real
+    projective space RP^2 which is very nice.
+    
+    Now ANY diffusion hemisphere is sampled with a regular even grid!
+    """
+    
+    if hemisphere:
+        n = n*2
+    
+    golden_angle = np.pi * (3 - np.sqrt(5))
+    theta = golden_angle * np.arange(n)
+    z = np.linspace(1 - 1.0 / n, 1.0 / n - 1, n)
+    radius = np.sqrt(1 - z * z)
+    
+    points = np.zeros((n, 3))
+    points[:, 0] = radius * np.cos(theta)
+    points[:, 1] = radius * np.sin(theta)
+    points[:, 2] = z
+    
+    if hemisphere:
+        n = n/2
+        points = points[:n, :]
+    
+    return points
+
+def random_dof_sample():
+    
+    insideDof = lambda x, y: (x**2 + y**2) < 1.0
+
+    while True:
+        dofx = (np.random.rand()-0.5)*2.0
+        dofy = (np.random.rand()-0.5)*2.0
+        if insideDof( dofx, dofy ):
+            return (dofx, dofy)

objects/octree.py

@@ -1,5 +1,4 @@
 from tracer import Tracer
-from utils import normalize
 import numpy
 
 class Octree(Tracer):

objects/polyhedra.py

@@ -1,6 +1,6 @@
 from objects import ConvexIntersection, HalfSpaceComponent, LayerComponent, FixedConvexIntersection
-import math
 from utils import vec_norm
+import math
 
 class Parallelepiped(ConvexIntersection):
 

objects/sphere.py

@@ -1,7 +1,6 @@
 from tracer import Tracer
 from objects import ConvexIntersection
 import numpy
-import math
 from transformations import Affine
 
 class Sphere(Tracer):
@@ -12,7 +11,7 @@ def __init__(self, pos, R):
 
     def surface_area(self):
         self._check_no_distortion()
-        return 4.0 * math.pi * self.R**2
+        return 4.0 * numpy.pi * self.R**2
 
     def random_surface_point_and_normal(self):
         self._check_no_distortion()

renderer.py

@@ -1,6 +1,7 @@
 
 from accelerator import Accelerator
 import numpy as np
+import camera
 import utils
 import itertools
 import math
@@ -80,7 +81,7 @@ def _init_misc(self):
         self.vec_param_buf = np.zeros((self.max_broadcast_vecs, 4), dtype=np.float32)
 
         # Randomization init
-        self.qdirs = utils.quasi_random_direction_sample(self.scene.samples_per_pixel)
+        self.qdirs = camera.quasi_random_direction_sample(self.scene.samples_per_pixel)
         self.qdirs = np.random.permutation(self.qdirs)
 
     def _init_camera_and_image(self):
@@ -273,13 +274,13 @@ def tent_filter_transformation(x):
         thetax = (sx-0.5)*self.pixel_angle*(1.0+overlap)
         thetay = (sy-0.5)*self.pixel_angle*(1.0+overlap)
 
-        dofx, dofy = utils.random_dof_sample()
+        dofx, dofy = camera.random_dof_sample()
 
         dof_pos = (dofx * self.rotmat[:, 0] + dofy * self.rotmat[:, 1]) * scene.camera_dof_fstop
 
         sharp_distance = scene.camera_sharp_distance
 
-        tilt = utils.rotmat_tilt_camera(thetax, thetay)
+        tilt = camera.rotmat_tilt_camera(thetax, thetay)
         mat = np.dot(np.dot(self.rotmat, tilt), self.rotmat.transpose())
         mat4 = np.zeros((4, 4))
         mat4[0:3, 0:3] = mat

scene.py

@@ -1,9 +1,5 @@
-
-from objects import *
-import utils
 import numpy as np
-import tracer
-from spectrum import Spectrum
+import camera
 
 class Object:
     """
@@ -25,7 +21,7 @@ class Scene:
     """
 
     def get_camera_rotmat(self):
-        return utils.camera_rotmat(self.camera_direction, self.camera_up)
+        return camera.camera_rotmat(self.camera_direction, self.camera_up)
 
     def get_objects(self, name):
         return [obj for obj in self.objects if obj.name == name]
@@ -46,13 +42,11 @@ def direct_camera_towards(self, target):
         self.camera_sharp_distance = np.linalg.norm(self.camera_direction)
 
     def get_camera_rays(self):
-        return utils.camera_rays(self.image_size, self.camera_flat_ccd, \
+        return camera.camera_rays(self.image_size, self.camera_flat_ccd, \
             self.camera_fov, self.camera_direction, self.camera_up)
 
     def get_number_of_camera_rays(self):
         return self.get_camera_rays().size / 3
 
     def add_object(self, tracer, material, name=None):
         self.objects.append(Object(tracer, material, name))
-
-from scenes.default_scenes import DefaultBoxScene, DefaultSpectrumBoxScene

scenes/default_scenes.py

@@ -5,7 +5,7 @@
 from objects import HalfSpace, Sphere
 import shader
 
-def default_materials():
+def default_rgb_materials():
     # --- Materials
     return {\
         'default': # "Air" / initial / default material
@@ -48,50 +48,81 @@ def default_materials():
               'diffuse': 0.02
             }
         }
-    
 
-# Default scene
-class DefaultBoxScene(Scene):
-    """
-    Default raytracer scene. Override attributes as required
-    """
+def default_spectrum_materials(spectrum):
 
-    # helpers...
+    materials = default_rgb_materials()
+        
+    # Have to replace RGB colors by proper spectra...
+    overrides = {
+        'green':
+            { 'diffuse': spectrum.gaussian(540, 30)*0.65 + 0.3 },
+        'red':
+            { 'diffuse': spectrum.gaussian(670, 30)*0.6 + 0.2 },
+        'light': # warm yellow-orange-light
+            { 'diffuse': 1.0, 'emission': spectrum.black_body(3200)*7.0 },
+        'sky':
+            { 'diffuse': 1.0, 'emission': spectrum.black_body(10000) },
+    }
 
-    @staticmethod
-    def make_world_box( material, dims, center=(0, 0, 0) ):
-        return [\
-            Object(HalfSpace( ( 1, 0, 0), dims[0]-center[0] ), material, 'wall'), \
-            Object(HalfSpace( (-1, 0, 0), dims[0]+center[0] ), material, 'wall'), \
-            Object(HalfSpace( ( 0, 1, 0), dims[1]-center[1] ), material, 'wall'), \
-            Object(HalfSpace( ( 0,-1, 0), dims[1]+center[1] ), material, 'wall'), \
-            Object(HalfSpace( ( 0, 0, 1), dims[2]-center[2] ), material, 'floor'), \
-            Object(HalfSpace( ( 0, 0,-1), dims[2]+center[2] ), material, 'ceiling')]
+    for k, mat in overrides.items():
+        materials[k] = mat
+
+    materials['wax']['volume_absorption'] = \
+        (1.0 - spectrum.gaussian(670, 100)) * 4.0
+        
+    # Also make the glass dispersive
+    materials['glass']['ior'] = spectrum.linear_dispersion_ior(1.5, 60.0)
 
+    return materials
+
+def default_settings(scene):
+
+    # --- Image settings
+    scene.image_size = (800, 600)
+    scene.brightness = 0.3
+    scene.gamma = 1.8
 
-    def initialize_materials(self):
-        self.materials = default_materials()
+    # --- Raytracer settings
+    scene.tent_filter = True
+    scene.quasirandom = False
+    scene.samples_per_pixel = 10000
+    scene.min_bounces = 2
+    scene.max_bounces = 4
+    scene.min_russian_prob = 0.15
+
+def make_world_box(material, dims, center=(0, 0, 0) ):
+    return [\
+        Object(HalfSpace( ( 1, 0, 0), dims[0]-center[0] ), material, 'wall'), \
+        Object(HalfSpace( (-1, 0, 0), dims[0]+center[0] ), material, 'wall'), \
+        Object(HalfSpace( ( 0, 1, 0), dims[1]-center[1] ), material, 'wall'), \
+        Object(HalfSpace( ( 0,-1, 0), dims[1]+center[1] ), material, 'wall'), \
+        Object(HalfSpace( ( 0, 0, 1), dims[2]-center[2] ), material, 'floor'), \
+        Object(HalfSpace( ( 0, 0,-1), dims[2]+center[2] ), material, 'ceiling')]
+
+class DefaultScene(Scene):
 
-    def __init__(self):
-        """Initialize default scene"""
+    def __init__(self, shader_class = shader.RgbShader):
+        default_settings(self)
+        self.shader = shader_class
 
-        # --- Image settings
-        self.image_size = (800, 600)
-        self.brightness = 0.3
-        self.gamma = 1.8
+        if shader_class == shader.SpectrumShader:
+            self.spectrum = Spectrum()
+            self.materials = default_spectrum_materials(self.spectrum)
+        else:
+            self.materials = default_rgb_materials()
 
-        # --- Raytracer settings
-        self.tent_filter = True
-        self.quasirandom = False
-        self.samples_per_pixel = 10000
-        self.min_bounces = 2
-        self.max_bounces = 4
-        self.min_russian_prob = 0.15
-        
-        self.initialize_materials()
+        self.set_up_objects_and_camera()
+
+class BoxScene(DefaultScene):
+    """
+    Default raytracer scene. Override attributes as required
+    """
+    
+    def set_up_objects_and_camera(self):
 
         # --- Objects
-        self.objects = DefaultBoxScene.make_world_box( 'white', (3, 5, 2), (0, 0, 2) )
+        self.objects = make_world_box( 'white', (3, 5, 2), (0, 0, 2) )
         self.objects[-1].material = "sky" # world box ceiling
         self.objects[-2].material = "green" # world box floor
         self.root_object = None
@@ -108,38 +139,3 @@ def __init__(self):
         camera_target = (0, 2, 0.5)
         self.camera_dof_fstop = 0.0
         self.direct_camera_towards(camera_target)
-        
-        self.shader = shader.RgbShader
-
-class DefaultSpectrumBoxScene(DefaultBoxScene):
-    
-    def __init__(self):
-        self.spectrum = Spectrum()
-        DefaultBoxScene.__init__(self)
-        self.shader = shader.SpectrumShader
-    
-    def initialize_materials(self):
-        
-        s = self.spectrum
-        self.materials = default_materials()
-        
-        # Have to replace RGB colors by proper spectra...
-        overrides = {
-            'green':
-                { 'diffuse': s.gaussian(540, 30)*0.65 + 0.3 },
-            'red':
-                { 'diffuse': s.gaussian(670, 30)*0.6 + 0.2 },
-            'light': # warm yellow-orange-light
-                { 'diffuse': 1.0, 'emission': s.black_body(3200)*7.0 },
-            'sky':
-                { 'diffuse': 1.0, 'emission': s.black_body(10000) },
-        }
-        
-        for k, mat in overrides.items():
-            self.materials[k] = mat
-        
-        self.materials['wax']['volume_absorption'] = \
-            (1.0 - s.gaussian(670, 100)) * 4.0
-            
-        # Also make the glass dispersive
-        self.materials['glass']['ior'] = s.linear_dispersion_ior(1.5, 60.0)

scenes/scene-dev.py

@@ -1,8 +1,10 @@
-from scene import *
-from utils import normalize, vec_norm
+from scenes.default_scenes import BoxScene
+from scene import Object
+from objects import *
+#from shader import SpectrumShader
 
-scene = DefaultSpectrumBoxScene()
-#scene = DefaultBoxScene()
+#scene = BoxScene(SpectrumShader)
+scene = BoxScene()
 
 for obj in scene.get_objects('wall'): obj.material = 'red'
 scene.get_object('floor').material = 'white'