def determine_specular_contribution(l_dir, l_dot_n, normal, eye_position, off_pt, light, sphere_finish, ray, inter_list): reflection_vect = vector_math.difference_vector( l_dir, vector_math.scale_vector(normal, 2 * l_dot_n)) v_dir = vector_math.normalize_vector( vector_math.vector_from_to(eye_position, off_pt)) spec_intensity = vector_math.dot_vector(reflection_vect, v_dir) def compute_spec(color_comp): return (color_comp * sphere_finish.specular * (spec_intensity**(1 / sphere_finish.roughness))) if spec_intensity > 0: r_comp = compute_spec(light.color.r) g_comp = compute_spec(light.color.g) b_comp = compute_spec(light.color.b) if inter_list == []: return [r_comp, g_comp, b_comp] else: dist_pt_to_light = distance(off_pt, light.pt) nearest_point = find_nearest(inter_list, ray) if distance(off_pt, nearest_point) < dist_pt_to_light: return [0, 0, 0] else: return [r_comp, g_comp, b_comp] else: return [0, 0, 0]
def determine_specular_contribution(l_dir,l_dot_n,normal,eye_position, off_pt,light,sphere_finish,ray, inter_list): reflection_vect = vector_math.difference_vector(l_dir, vector_math.scale_vector(normal, 2 * l_dot_n)) v_dir = vector_math.normalize_vector( vector_math.vector_from_to(eye_position,off_pt)) spec_intensity = vector_math.dot_vector(reflection_vect,v_dir) def compute_spec(color_comp): return (color_comp * sphere_finish.specular * (spec_intensity ** (1 / sphere_finish.roughness))) if spec_intensity > 0: r_comp = compute_spec(light.color.r) g_comp = compute_spec(light.color.g) b_comp = compute_spec(light.color.b) if inter_list == []: return [r_comp,g_comp,b_comp] else: dist_pt_to_light = distance(off_pt,light.pt) nearest_point = find_nearest(inter_list,ray) if distance(off_pt,nearest_point) < dist_pt_to_light: return [0,0,0] else: return [r_comp,g_comp,b_comp] else: return [0,0,0]
def test_difference_vector_2(self): v1 = data.Vector(1.0, 2.0, 3.0) v2 = data.Vector(1.0, 2.0, 3.0) v3 = vector_math.difference_vector(v1, v2) self.assertAlmostEqual(v3.x, 0.0) self.assertAlmostEqual(v3.y, 0.0) self.assertAlmostEqual(v3.z, 0.0)
def getSpecular(ray, intersection_list, light, point): closest = findClosestSphere(ray, intersection_list) csphere = closest[0] cpoint = closest[1] n_vector = collisions.sphere_normal_at_point(csphere, cpoint) scaled_vector = vector_math.scale_vector(n_vector, 0.01) p_e = vector_math.translate_point(cpoint, scaled_vector) light_vector = vector_math.vector_from_to(p_e, light.pt) L_dir = vector_math.normalize_vector(light_vector) light_dot_product = vector_math.dot_vector(n_vector, L_dir) #gets spec values n_scale = vector_math.scale_vector(n_vector, (2 * light_dot_product)) reflection = vector_math.difference_vector(L_dir, n_scale) pe_eyevec = vector_math.normalize_vector( vector_math.difference_point(p_e, point)) specularIntensity = vector_math.dot_vector(pe_eyevec, reflection) if specularIntensity > 0: sphere_spec = csphere.finish.specular sphere_rough = csphere.finish.roughness specCont_r = (light.color.r * sphere_spec) * (specularIntensity**( 1 / float(sphere_rough))) specCont_g = (light.color.g * sphere_spec) * (specularIntensity**( 1 / float(sphere_rough))) specCont_b = (light.color.b * sphere_spec) * (specularIntensity**( 1 / float(sphere_rough))) else: specCont_r = 0 specCont_g = 0 specCont_b = 0 return (specCont_r, specCont_g, specCont_b)
def cast_ray(ray, sphere_list, color, light): """Find the rendered color at the nearest intersection point along ray""" nearest = closest_intersect(ray, sphere_list) if not nearest: # No intersection, return white return Color(1.0, 1.0, 1.0) point, sphere = nearest # Compute initial ambient colors r = sphere.color.r * sphere.finish.ambient * color.r g = sphere.color.g * sphere.finish.ambient * color.g b = sphere.color.b * sphere.finish.ambient * color.b # Calculate diffuse value normal = sphere_normal_at_point(sphere, point) to_light = normalize_vector(vector_from_to(point, light.pt)) l_dot = dot_vector(normal, to_light) diffuse = sphere.finish.diffuse * l_dot if diffuse < 0: diffuse = 0 else: # Check for shadows new_point = translate_point(point, scale_vector(normal, 0.01)) light_ray = Ray(new_point, to_light) shadow_intersect = closest_intersect(light_ray, sphere_list) if (shadow_intersect and length_vector_sq(vector_from_to(new_point, shadow_intersect[0])) < length_vector_sq(vector_from_to(new_point, light.pt))): diffuse = 0 # Add diffuse to existing colors r += sphere.color.r * diffuse * light.color.r g += sphere.color.g * diffuse * light.color.g b += sphere.color.b * diffuse * light.color.b # Compute specular intensity if diffuse > 0: reflection = difference_vector(to_light, scale_vector(normal, 2 * l_dot)) intensity = dot_vector(reflection, normalize_vector(ray.dir)) power = 1. / sphere.finish.roughness if intensity > 0: r += light.color.r * sphere.finish.specular * intensity ** power g += light.color.g * sphere.finish.specular * intensity ** power b += light.color.b * sphere.finish.specular * intensity ** power # Max out colors at 1.0 if r > 1: r = 1 if g > 1: g = 1 if b > 1: b = 1 return Color(r, g, b)
def cast_ray(ray, sphere_list, amb, light, eye_point): result_color = data.Color(1.0, 1.0, 1.0) # test for closest sphere to the eye collision_tuple = find_closest_collision(ray, sphere_list) if collision_tuple: # some useful variables sphere_hit = collision_tuple[0] sphere_hit_point = collision_tuple[1] # basic color before manipulation result_r = sphere_hit.color.r * sphere_hit.finish.amb * amb.r result_g = sphere_hit.color.g * sphere_hit.finish.amb * amb.g result_b = sphere_hit.color.b * sphere_hit.finish.amb * amb.b # computing light intensity sphere_vector = vector_math.vector_from_to(sphere_hit.center, sphere_hit_point) sphere_normal = vector_math.normalize_vector(sphere_vector) scaled_normal = vector_math.scale_vector(sphere_normal, 0.01) hit_point = vector_math.translate_point(sphere_hit_point, scaled_normal) light_vector = vector_math.vector_from_to(hit_point, light.pt) light_normal = vector_math.normalize_vector(light_vector) light_scale = vector_math.dot_vector(sphere_normal, light_normal) if light_scale > 0: sphere_normal_ray = data.Ray(hit_point, light_normal) possible_obstruction = find_closest_collision(sphere_normal_ray, sphere_list) if possible_obstruction == None or distance(hit_point, possible_obstruction[1]) > distance( hit_point, light.pt ): result_r += sphere_hit.color.r * light_scale * light.color.r * sphere_hit.finish.diff result_g += sphere_hit.color.g * light_scale * light.color.g * sphere_hit.finish.diff result_b += sphere_hit.color.b * light_scale * light.color.b * sphere_hit.finish.diff # computing specular intensity tmp_vector = vector_math.scale_vector(sphere_normal, 2 * light_scale) reflection_vector = vector_math.difference_vector(light_normal, tmp_vector) eye_vector = vector_math.vector_from_to(eye_point, hit_point) eye_normal = vector_math.normalize_vector(eye_vector) spec_scale = vector_math.dot_vector(reflection_vector, eye_normal) if spec_scale > 0: result_r += light.color.r * sphere_hit.finish.spec * spec_scale ** (1 / float(sphere_hit.finish.rough)) result_g += light.color.g * sphere_hit.finish.spec * spec_scale ** (1 / float(sphere_hit.finish.rough)) result_b += light.color.b * sphere_hit.finish.spec * spec_scale ** (1 / float(sphere_hit.finish.rough)) result_color = data.Color(result_r, result_g, result_b) return result_color
def find_specular_intensity(spherepair, light, eye_point, l_dot_n): light_dir = vector_math.normalize_vector(vector_math.difference_point( light.pt, spherepair[1])) sphere_normal = collisions.sphere_normal_at_point(spherepair[0], spherepair[1]) reflection_vector = vector_math.difference_vector(light_dir, vector_math.scale_vector(sphere_normal, 2 * l_dot_n)) view_dir = vector_math.normalize_vector(vector_math.difference_point( spherepair[1], eye_point)) specular_intensity = vector_math.dot_vector(view_dir, reflection_vector) return specular_intensity
def get_specular_intensity(lDir, lDirection, N, pE, light, sphere): reflection_vector = vector_math.difference_vector(lDir, vector_math.scale_vector(N, lDirection * 2)) vDir = vector_math.vector_from_to(data.Point(0.0,0.0,-14.0), pE) vDir = vector_math.normalize_vector(vDir) intensity = vector_math.dot_vector(reflection_vector, vDir) if intensity > 0: r = light.color.r * sphere.finish.specular * intensity**(1 / sphere.finish.roughness) g = light.color.g * sphere.finish.specular * intensity**(1 / sphere.finish.roughness) b = light.color.b * sphere.finish.specular * intensity**(1 / sphere.finish.roughness) color = data.Color(r,g,b) else: color = data.Color(0,0,0) return color
def get_specular_intensity(lDir, lDirection, N, pE, light, sphere): reflection_vector = vector_math.difference_vector( lDir, vector_math.scale_vector(N, lDirection * 2)) vDir = vector_math.vector_from_to(data.Point(0.0, 0.0, -14.0), pE) vDir = vector_math.normalize_vector(vDir) intensity = vector_math.dot_vector(reflection_vector, vDir) if intensity > 0: r = light.color.r * sphere.finish.specular * intensity**( 1 / sphere.finish.roughness) g = light.color.g * sphere.finish.specular * intensity**( 1 / sphere.finish.roughness) b = light.color.b * sphere.finish.specular * intensity**( 1 / sphere.finish.roughness) color = data.Color(r, g, b) else: color = data.Color(0, 0, 0) return color
def cast_ray(ray, sphere_list, ambient, light, point): a = collisions.find_intersection_points(sphere_list, ray) if a == []: return data.Color(1.0, 1.0, 1.0) sphere_look = a[0] for x in a: if distance(ray.pt, x[1]) < distance(ray.pt, sphere_look[1]): sphere_look = x red = sphere_look[0].color.r * sphere_look[0].finish.ambient * ambient.r green = sphere_look[0].color.g * sphere_look[0].finish.ambient * ambient.g blue = sphere_look[0].color.b * sphere_look[0].finish.ambient * ambient.b n = collisions.sphere_normal_at_point(sphere_look[0], sphere_look[1]) pe = vector_math.translate_point(sphere_look[1], vector_math.scale_vector(n, .01)) visible_ray = data.Ray(pe, vector_math.vector_from_to(pe, light.point)) ldir = vector_math.normalize_vector(visible_ray.dir) visible = vector_math.dot_vector(ldir, n) n = collisions.sphere_normal_at_point(sphere_look[0], sphere_look[1]) ldir_dot_n = vector_math.dot_vector(ldir, n) reflection_vector = vector_math.difference_vector( vector_math.scale_vector(n, ldir_dot_n * 2), ldir) vdir = vector_math.normalize_vector(vector_math.vector_from_to(point, pe)) specular_intensity = vector_math.dot_vector(reflection_vector, vdir) if visible > 0: if collisions.find_intersection_points(sphere_list, visible_ray) == []: red += (visible * light.color.r * sphere_look[0].color.r * sphere_look[0].finish.diffuse) green += (visible * light.color.g * sphere_look[0].color.g * sphere_look[0].finish.diffuse) blue += (visible * light.color.b * sphere_look[0].color.b * sphere_look[0].finish.diffuse) if specular_intensity > 0: spec_intensity_calc = specular_intensity**( 1 / sphere_look[0].finish.roughness) red += light.color.r * sphere_look[ 0].finish.specular * spec_intensity_calc green += light.color.g * sphere_look[ 0].finish.specular * spec_intensity_calc blue += light.color.b * sphere_look[ 0].finish.specular * spec_intensity_calc return data.Color(red, green, blue)
def comp(sphere_list,inter,light,sphere,int,eye_point): n = collisions.sphere_normal_at_point(sphere,int) scaled_normal = vector_math.scale_vector(n,.01) Pe = vector_math.translate_point(inter[0][1],scaled_normal) vr_light = vector_math.vector_from_to(Pe,light.pt) L_dir = vector_math.normalize_vector(vr_light) dot_product = vector_math.dot_vector(n,L_dir) reflection_vr = vector_math.difference_vector(L_dir,vector_math.scale_vector(n,(2 * dot_product))) V_dir = vector_math.normalize_vector(vector_math.vector_from_to(eye_point,Pe)) intensity = vector_math.dot_vector(reflection_vr,V_dir) ray = data.Ray(Pe,L_dir) inter2 = collisions.find_intersection_points(sphere_list,ray) if dot_product>0 and inter2 == []: diff_r = sphere.color.r*sphere.finish.diffuse*dot_product*light.color.r diff_g = sphere.color.g*sphere.finish.diffuse*dot_product*light.color.g diff_b = sphere.color.b*sphere.finish.diffuse*dot_product*light.color.b spec_r = light.color.r*sphere.finish.specular*math.pow(intensity,(1/sphere.finish.roughness)) spec_g = light.color.g*sphere.finish.specular*math.pow(intensity,(1/sphere.finish.roughness)) spec_b = light.color.b*sphere.finish.specular*math.pow(intensity,(1/sphere.finish.roughness)) return data.Color(diff_r,diff_g,diff_b),data.Color(spec_r,spec_g,spec_b) else : return data.Color(0,0,0), data.Color(0,0,0)
def test_difference_vector_2(self): vector3 = data.Vector(-20, -45, -99) vector4 = data.Vector(-12, 0, 45) difference_vector = data.Vector(-8, -45, -144) self.assertEqual(vector_math.difference_vector(vector3, vector4), difference_vector)
def cast_ray(ray, sphere_list, light = light_obj, ambient = data.Color(), eye_point = data.Point(0, 0, -14)): # intersections contains a list of tuples of spheres and points, ex: [(Sphere_1, Point_1), (Sphere_2, Point_2), ...] intersections = collisions.find_intersection_points(sphere_list, ray) if len(intersections) == 0: return data.Color(1.0, 1.0, 1.0) else: # initializing variable that stores the index and the distance of the tuple with the smallest distance index_of_nearest_sphere = 0 distance_of_nearest_sphere = vector_math.distance_between(intersections[0][1], ray.pt) # loop through all_intersection_point and find the index of the tuple that contains the sphere & intersection with the smallest distance from ray's point for index in range(0, len(intersections)): distance_between_points = vector_math.distance_between(intersections[index][1], ray.pt) if distance_between_points < distance_of_nearest_sphere: index_of_nearest_sphere = index distance_of_nearest_sphere = distance_between_points # storing the sphere and intersection point in to variables for later usage nearest_sphere = intersections[index_of_nearest_sphere][0] nearest_intersection = intersections[index_of_nearest_sphere][1] # ==== color calculation based on ambient light, diffusion, light color and location ==== # Impricision of floats can create collision issues with the sphere where the point lies when using the computed intersection # A point "pe" that is 0.01 above te intersection point will be used instead sphere_normal_vector = collisions.sphere_normal_at_point(nearest_sphere, nearest_intersection) pe_translate_direction_vector = vector_math.scale_vector(sphere_normal_vector, 0.01) # new point PE is now found pe = vector_math.translate_point(nearest_intersection, pe_translate_direction_vector) # === determine whether diffusivity is applicable -- determine if there are any obstruction of light vectors === # comput vector from pe to light point then compute normalized vector from pe to to light point l_dir = vector_math.normalize_vector(vector_math.vector_from_to(pe, light.pt)) n_dot_l_dir = vector_math.dot_vector(sphere_normal_vector, l_dir) # === computing the specular_intensity === reflection_vector = vector_math.difference_vector(l_dir ,vector_math.scale_vector(sphere_normal_vector, 2 * n_dot_l_dir)) #creating the direction vector that points from eye_point to pe v_dir = vector_math.normalize_vector(vector_math.vector_from_to(eye_point, pe)) #Vdir # specular_intensity is defined to be the dot product of reflection_vector and the direction vector from eye_point to pe specular_intensity = vector_math.dot_vector(v_dir, reflection_vector) ambient_color = compute_ambient_color(nearest_sphere, ambient) if n_dot_l_dir > 0: ray_to_point = data.Ray(pe,l_dir) inter = collisions.find_intersection_points(sphere_list, ray_to_point) if len(inter) == 0: diffuse_color = compute_diffuse_color(n_dot_l_dir, light, intersections[index_of_nearest_sphere][0]) if specular_intensity > 0: specular_color = compute_specular_color(light, nearest_sphere, specular_intensity) return add_color(add_color(specular_color, diffuse_color), ambient_color) else: return add_color(diffuse_color, ambient_color) else: return ambient_color elif specular_intensity > 0: specular_color = compute_specular_color(light, nearest_sphere, specular_intensity) return add_color(specular_color, ambient_color) else: return ambient_color
def test_defference_vector_2(self): vector1 = data.Vector(-1, -4, 2) vector2 = data.Vector(3, -6, 2) newvec = vector_math.difference_vector(vector1, vector2) self.assertEqual(newvec, data.Vector(-4, 2, 0))
def test_difference_vector_1(self): vector1 = data.Vector(2, 5, 2) vector2 = data.Vector(0, 4, 0.1) newvec = vector_math.difference_vector(vector1, vector2) self.assertEqual(newvec, data.Vector(2, 1, 1.9))
def test_difference_vector_again(self): dv = vector_math.difference_vector(data.Vector(0, 2, -4), data.Vector(0, 3, 0)) self.assertEqual(dv, data.Vector(0, -1, -4))
def test_difference_vector(self): dv = vector_math.difference_vector(data.Vector(2.2, -4, 7), data.Vector(6, -2, 3)) self.assertEqual(dv, data.Vector(-3.8, -2, 4))
def test_difference_vector_1(self): vector1 = data.Vector(15, 16, 17) vector2 = data.Vector(4, 5, 6) difference_vector = data.Vector(11, 11, 11) self.assertEqual(vector_math.difference_vector(vector1, vector2), difference_vector)
def test_vectorDiff_2(self): v1 = data.Vector(4,5,6) v2 = data.Vector(3,2,1) equals = data.Vector(1,3,5) self.assertEqual(vector_math.difference_vector(v1,v2) == equals, True) pass
def test_vectorDiff_1(self): v1 = data.Vector(1,2,3) v2 = data.Vector(1,2,3) equals = data.Point(0,0,0) self.assertEqual(vector_math.difference_vector(v1, v2) == equals, True) pass