Beispiel #1
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]
Beispiel #2
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]
Beispiel #3
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)
Beispiel #4
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)
Beispiel #5
0
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)
Beispiel #6
0
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
Beispiel #7
0
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
Beispiel #8
0
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
Beispiel #9
0
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
Beispiel #10
0
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)
Beispiel #11
0
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)
Beispiel #12
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
Beispiel #14
0
 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))
Beispiel #15
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))
Beispiel #16
0
 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))
Beispiel #17
0
 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))
Beispiel #18
0
 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