Ray Tracing

• This is from an online book chapter
• This is one of the methods that can be used to create "photo-realistic" images.
• some examples
• The first stages are much like what we have been discussing:
  • Build a scene out of primitives.
  • Provide propertities to the objects in the scene.
  • Add lights
  • And a camera
  • Using the transformation matricies (as before) move the scene to camera space (but no need to project)
• The near viewplane represents the "canvas" on which we will be drawing the image. (We need to know the resolution at this point)
• We cast a ray, from the camera through the image into the scene.
• 
• For each ray
  • Detect if and where the ray intersects with each object.
  • Find the closest object.
  • Compute the color at the position where this intersection occurs.
• This might be computationally expensive (n objects x m pixels)
• The ray
  • We know the origin (eye position), e
  • And the pixel location (s)
  • So a ray is really s-e
  • And we can interpolate p(t) = e+t(s-e), for t=0 (eye) to ∞
  • Let d = s-e, so the equation becomes p(t) = e+td
• Ray/object intersection
  • Sphere:
    • Located at (x_c, y_c), radius R
    • (x-x_c)² + (y-y_c)²+ (z-z_c)²-R² = 0
    • or (p-c)²-R² = 0
    • So we need some p(t) = e + td that satisfies this equation.
    • (e+td -c)²-R² = 0
    • We know e,d,c and R, so t is the only unknown.
    • (e+td -c)² = (td + (e-c))²
    • d²t² + 2d(e-c)t + (e-c)²
    • So the final equation is d²t² + 2d(e-c)t + (e-c)² - R² = 0
    • Which is in the form at²+bt+c = 0;
    • So we can use the quadratic equation to
      • Determine if there are positive values for t
      • or does the ray intersect the sphere?
      • Determine what the values are: t₁ and t₂
      • Ie where is the closest intersction point?
      • if (t₁ < t₂) then t₁ else t₂
  • Other interscections can be done in a similar manner.
• Color at a point
  • We employ the illumination model from chapter 5 with the following changes:
    • To determine the "color" at a point shoot a ray, from that point, to every light source.
    • If the light source blocked (ie an object intersection before the light source) then this point is in the shadow, and that light has not contribution to the color.
    • Just add in the ambient color.
    • This is a "shadow ray"
    • But this adds object intersections * light sources * objects into cost.
  • Specular reflection takes on an entirely new dimension.
    • we can now "trace" the light back to the source.
    • But if we hit another surface before a light source
      • We can use the "light" from that surface.
      • Which can determine illumination as before (or as now)
      • 
      • This allows us to add reflections to our image.
  • Refraction becomes possible now too.
    • Refracted light follows Snell's Law
    • Possibly multiple times.
    • Look at these exmaples
    • In any case, we just generate more rays.
    • Use the alpha value to combine the light at a point.
    • And now we can look through things.
  • You can also generate reflected rays at an edge of a transparent object.
  • But that makes a lot of rays.
• Bounding boxes, spheres, etc tend to reduce complex computations.
• By the way, this can be parallelized, EASILY
• The POV ray tracer
  • Just a small look at the POV raytracer.
  • This has been in existance for a very long time. (1980s)
  • It has a language to specify scenes.
  • And a ray tracing engine
  • A simple progrm might be:

    // This is a simple red sphere
    
    // first, the camera position
    camera {
      location <2,5,-10>
      look_at <0,0,0>
    }
    
    // now, some light
    light_source {
      <0,-10,0>
      color rgb <1,1,1>
    }
    
    // the sphere
    sphere {
      <0,0,0>, 5
      pigment { color rgb <1,0,0> }
    }
    
    	

  • Which yields
  • Or a little more complex:

    #include "colors.inc"
    
    camera {
      location <-2, 3, -10>
      look_at <0, 5, 0>
    }
    
    plane { // the floor
      y, 0  // along the x-z plane (y is the normal vector)
      pigment { checker color Black color White } // checkered pattern
    }
    
    sphere {
      <0, 5, 0>, 2
      pigment { color White }
      finish {
        reflection 0.9
        phong 1
      }
    }
    
    light_source { <10, 10, -10> color White }
    
    light_source { <-10, 5, -15> color White }
    	

  •