Remove the unused load() function from Geometry class.

1 files changed, 0 insertions, 117 deletions

diff --git a/geometry.py b/geometry.py
index d80b730..5c513d4 100644
--- a/geometry.py
+++ b/geometry.py
@@ -346,120 +346,3 @@ class Geometry(object):
             if unique_bit_shifted_zvalues.size == 1:
                 break
 
-    def load(self, module):
-        """
-        Load the bounding volume hierarchy onto the GPU module,
-        bind it to the appropriate textures, and return a list
-        of the texture references.
-        """
-
-        if not hasattr(self, 'mesh'):
-            raise RuntimeError('cannot load before a call to build().')
-
-        set_wavelength_range = module.get_function('set_wavelength_range')
-
-        set_wavelength_range(np.float32(standard_wavelengths[0]), np.float32(standard_wavelengths[-1]), np.float32(standard_wavelengths[1]-standard_wavelengths[0]), np.uint32(standard_wavelengths.size), block=(1,1,1), grid=(1,1))
-
-        set_material = module.get_function('set_material')
-        for i, material in enumerate(self.unique_materials):
-            if material is None:
-                if color is False:
-                    raise Exception('one or more triangles is missing a material.')
-                continue
-
-            refractive_index = np.interp(standard_wavelengths, material.refractive_index[:,0], material.refractive_index[:,1]).astype(np.float32)
-            absorption_length = np.interp(standard_wavelengths, material.absorption_length[:,0], material.absorption_length[:,1]).astype(np.float32)
-            scattering_length = np.interp(standard_wavelengths, material.scattering_length[:,0], material.scattering_length[:,1]).astype(np.float32) 
-
-            material.refractive_index_gpu = cuda.to_device(refractive_index)
-            material.absorption_length_gpu = cuda.to_device(absorption_length)
-            material.scattering_length_gpu = cuda.to_device(scattering_length)
-
-            set_material(np.int32(i), material.refractive_index_gpu, material.absorption_length_gpu, material.scattering_length_gpu, block=(1,1,1), grid=(1,1))
-
-        set_surface = module.get_function('set_surface')
-        for i, surface in enumerate(self.unique_surfaces):
-            if surface is None:
-                continue
-
-            detect = np.interp(standard_wavelengths, surface.detect[:,0], surface.detect[:,1]).astype(np.float32)
-            absorb = np.interp(standard_wavelengths, surface.absorb[:,0], surface.absorb[:,1]).astype(np.float32)
-            reflect_diffuse = np.interp(standard_wavelengths, surface.reflect_diffuse[:,0], surface.reflect_diffuse[:,1]).astype(np.float32)
-            reflect_specular = np.interp(standard_wavelengths, surface.reflect_specular[:,0], surface.reflect_specular[:,1]).astype(np.float32)
-
-            surface.detect_gpu = cuda.to_device(detect)
-            surface.absorb_gpu = cuda.to_device(absorb)
-            surface.reflect_diffuse_gpu = cuda.to_device(reflect_diffuse)
-            surface.reflect_specular_gpu = cuda.to_device(reflect_specular)
-
-            set_surface(np.int32(i), surface.detect_gpu, surface.absorb_gpu, surface.reflect_diffuse_gpu, surface.reflect_specular_gpu, block=(1,1,1), grid=(1,1))
-
-        vertices = np.empty(len(self.mesh.vertices), dtype=gpuarray.vec.float3)
-        vertices['x'] = self.mesh.vertices[:,0]
-        vertices['y'] = self.mesh.vertices[:,1]
-        vertices['z'] = self.mesh.vertices[:,2]
-
-        triangles = \
-            np.empty(len(self.mesh.triangles), dtype=gpuarray.vec.uint4)
-        triangles['x'] = self.mesh.triangles[:,0]
-        triangles['y'] = self.mesh.triangles[:,1]
-        triangles['z'] = self.mesh.triangles[:,2]
-        triangles['w'] = ((self.material1_index & 0xff) << 24) | ((self.material2_index & 0xff) << 16) | ((self.surface_index & 0xff) << 8)
-
-        lower_bounds = np.empty(self.lower_bounds.shape[0], dtype=gpuarray.vec.float4)
-        lower_bounds['x'] = self.lower_bounds[:,0]
-        lower_bounds['y'] = self.lower_bounds[:,1]
-        lower_bounds['z'] = self.lower_bounds[:,2]
-
-        upper_bounds = np.empty(self.upper_bounds.shape[0], dtype=gpuarray.vec.float4)
-        upper_bounds['x'] = self.upper_bounds[:,0]
-        upper_bounds['y'] = self.upper_bounds[:,1]
-        upper_bounds['z'] = self.upper_bounds[:,2]
-
-        self.vertices_gpu = cuda.to_device(vertices)
-        self.triangles_gpu = cuda.to_device(triangles)
-        self.colors_gpu = gpuarray.to_gpu(self.colors.astype(np.uint32))
-        self.lower_bounds_gpu = cuda.to_device(lower_bounds)
-        self.upper_bounds_gpu = cuda.to_device(upper_bounds)
-        self.node_map_gpu = cuda.to_device(self.node_map)
-        self.node_length_gpu = cuda.to_device(self.node_length)
-
-        def format_size(size):
-            if size < 1e3:
-                return '%.1f%s' % (size, ' ')
-            elif size < 1e6:
-                return '%.1f%s' % (size/1e3, 'K')
-            elif size < 1e9:
-                return '%.1f%s' % (size/1e6, 'M')
-            else:
-                return '%.1f%s' % (size/1e9, 'G')
-
-        def format_array(name, array):
-            return '%-15s %6s %6s' % (name, format_size(len(array)), format_size(array.nbytes))
-
-        print 'Device Usage:'
-        print format_array('vertices', vertices)
-        print format_array('triangles', triangles)
-        print format_array('lower_bounds', self.lower_bounds)
-        print format_array('upper_bounds', self.upper_bounds)
-        print format_array('node_map', self.node_map)
-        print format_array('node_length', self.node_length)
-        print '%-15s %6s %6s' % ('total', '', format_size(vertices.nbytes + triangles.nbytes + self.lower_bounds.nbytes + self.upper_bounds.nbytes + self.node_map.nbytes + self.node_length.nbytes))
-
-        set_global_mesh_variables = module.get_function('set_global_mesh_variables')
-        set_global_mesh_variables(self.triangles_gpu, self.vertices_gpu, self.colors_gpu, np.uint32(self.node_map.size-1), np.uint32(self.first_node), block=(1,1,1), grid=(1,1))
-
-        self.lower_bounds_tex = module.get_texref('lower_bounds')
-        self.upper_bounds_tex = module.get_texref('upper_bounds')
-        self.node_map_tex = module.get_texref('node_map')
-        self.node_length_tex = module.get_texref('node_length')
-
-        self.lower_bounds_tex.set_address(self.lower_bounds_gpu, lower_bounds.nbytes)
-        self.upper_bounds_tex.set_address(self.upper_bounds_gpu, upper_bounds.nbytes)
-        self.node_map_tex.set_address(self.node_map_gpu, self.node_map.nbytes)
-        self.node_length_tex.set_address(self.node_length_gpu, self.node_length.nbytes)
-
-        self.lower_bounds_tex.set_format(cuda.array_format.FLOAT, 4)
-        self.upper_bounds_tex.set_format(cuda.array_format.FLOAT, 4)
-        self.node_map_tex.set_format(cuda.array_format.UNSIGNED_INT32, 1)
-        self.node_length_tex.set_format(cuda.array_format.UNSIGNED_INT32, 1)