CSCI 420代写、代写R编程设计

日期：2022-11-16 07:31

CSCI 420: Homework 3 DUE DATE: 11/25/2022 23:59

Ray Tracing

Overview

In this assignment, you will be building a ray tracer. Your

ray tracer will be able to handle opaque surfaces

with lighting and shadows. Provided for you will be starter

code that will load scene data from a file. Please refer to

the lecture slides about lighting and raytracing first.

Motivation

Step 1: Uniformly send out rays from the camera location. Since the camera does not have to move, you can

assume that its location is (0,0,0). You should use backwards ray tracing where rays are sent from the camera,

one ray per pixel. The final images should be 640x480, but for debugging you should use smaller resolutions

with faster rendering times. For example, if you halve each dimension, you would send out 1/4th of the number

of rays. You can use the field of view of 60 degrees.

Step 2: Write the intersection code. The mathematical solutions for the intersection code are provided

in the lecture notes.

Step 3: Implement the illumination equations (provided below).

Step 4: Create still images showing off your ray tracer.

The source code gives you two methods of plotting a pixel. You can either only plot to the screen, or both to the

screen and a JPEG file. You control this behavior by providing the second command line argument to your

program. When the second argument is provided, output is generated both to screen and the filename given by

the second argument. If you do not provide a second argument, plotting will be to screen only.

Illumination

At each intersection point, you need to first determine if it is in shadow, separately for each light source. You do

this by launching a shadow ray to each of the lights. If the point is in shadow, its color with respect to that light

should be (0,0,0), that is, black. If the point is not in shadow, use Phong shading to determine the color of the

point with respect to that light:

I = lightColor * (kd * (L dot N) + ks * (R dot V) ^ α) - - Please also refer to slides for Phong Shading

(for each color channel separately; note that if L dot N < 0, you should clamp L dot N to zero; same for

R dot V)

The final color of the point is the sum of the contributions from all lights, plus the global ambient color. You only

add the global ambient color once, regardless of how many lights the scene has, and regardless of how many

lights are visible from the point. Note that it could happen that a point is in shadow with respect to all lights. In

this case, the final color will be the global ambient color. Or a point could be in shadow with respect to some

lights, but not others. Or, all lights may be visible from a point. If the final color is greater than 1.0, you should

of course clamp it to 1.0.

In order to compute I, you must determine the normal N at the intersection point. For triangles, you should

interpolate the x,y,z coordinates of the normals given at each vertex, and then normalize the length. Use

barycentric coordinates for interpolation of triangles. You should interpolate not just the normals, but also

diffuse, specular and shininess coefficients. For spheres, the normal is simple to calculate based on the center

of the sphere and the point location.

Background color: Use the white color (floating point (1.0, 1.0, 1.0), char (255, 255, 255)).

Functionality Requirements:

This is the list of requirements for this assignment:

Triangle intersection (20 points)

Sphere intersection (20 points)

Triangle Phong shading (15 points)

Sphere Phong shading (15 points)

Shadows rays (15 points)

Still images (15 points)

* There is no creativity score in this assignment

Extra credit (up to 10 points)

Recursive reflection (5 pts)

Good antialiasing (5 pts)

Soft shadows (5 pts)

Animation (3 pts)

Animation + Motion blur (10 pts)

For recursive reflection, you need to call your ray tracer recursively. Of course, you still need to fire the shadow

rays and compute a local Phong color, exactly as in non-recursive ray tracing described above. The final color

should equal (1 - ks) * localPhongColor + ks * colorOfReflectedRay.

Starter Code:

The starter code for Visual Studio 2017, Mac, and Linux are on Blackboard. (Note that Linux and Mac starter

codes are the same, and the default setting is for Linux. Please modify library in the assign3.cpp header and

Makefile for MacOS.) The program takes a command line argument that specifies the filename containing the

scene description. It fills global structures containing triangles, spheres, and lights. (If you need Pic library,

please use the previous assignment links.)

Remember to include your name in the header first

/*

CSCI 420

Assignment 3 Raytracer

Name:

*/

Still Image Requirement:

To validate your implemented ray-tracer, you are required to hand in still pictures in the form of JPEG files. We

provide 5 scenes in the attached example.zip. It contains scene description file (*.scene, see later section for

the format) and associated pre-rendered image (*.jpg) You’ll need to use the scene description files in your

program and render all 5 scenes to satisfy the basic requirements. The provided pre-rendered image is

generated with basic ray-tracing functions. Please refer to those pre-rendered image as references to check

your implementation. Name your rendered scenes as “test1-result.jpg”, “test2-result.jpg”, “table-result.jpg”, and

so on and put them under your root folder so we can find your results easily.

If you implement extra credits, in additional to basic 5 scenes, submit additional images (up to 5 additional and

pick the scenes that can best showcase your features) for your extra credits. If you choose to do an animation

in the extra credit, you should submit a video showing your animation.

Submission Instructions

Submit your codes, rendered images (basic 5 results + extra), and README. README file should describe

the functionality of your ray tracer and list the scene description file(s) that show off your features. An template

(ReadMe.txt) is included. Upload the entire submission as one zip file to the Blackboard.

Scene Description Format

The first line is the number of objects in the file. There are three types of objects supported: lights, triangles,

and spheres. Color values range from 0-1. You can use our provided scenes, or create your own scenes.

Ambient Light (3 floats).

Then you can have lights, spheres or triangles.

sphere

position (3 floats)

radius (1 float)

diffuse color (3 floats)

specular color (3 floats)

shininess (1 float)

triangle

then the following, repeated three times (once for every vertex)

■position (3 floats)

■normal (3 floats)

■diffuse color (3 floats)

■specular color (3 floats)

■shininess (1 float)

light

position (3 floats)

color (3 floats)

Example Scene Files

The following is an example of a scene description format. It sets a gray sphere of radius 1 at (0,0,-3). It sets a

white light source at the origin.

2

amb: 0.3 0.3 0.3

sphere

pos: 0.0 0.0 -3.0

rad: 1

dif: 0.3 0.3 0.3

spe: 0.5 0.5 0.5

shi: 1

light

pos: 0 0 0

col: 1 1 1

Here is the file corresponding to the above example: [attached example: test1.scene]

Examples for submission

Basic test scene with a triangle, ground plane and sphere: [attached example: test2.scene]

Five spheres: [attached example: spheres.scene]

A table and two boxes: [attached example: table.scene]

SIGGRAPH: [attached example: SIGGRAPH.scene]

FAQ

1. Why do my spheres look somewhat squashed (like an "egg") ?

To some degree, spheres will look like eggs (ellipsoids), when they are not centered on the screen. This is due

to perspective distortion and is normal and to be expected. However, the distortion should not be severe. See

the example solution with the five spheres in the attachments: you can see that the two outermost spheres are

slightly ellipsoidal in the resulting 2D image. Compare their shape to the shape of the center sphere (which

looks like a circle). These are correct results.. some amount of ellipsoidal That said, squashing can occur also

if the aspect ratio is set incorrectly, or if the four corners of the image plane were not computed correctly, or if

the rays were generated incorrectly. These would be wrong results.

Note that the tan function in math.h takes RADIANS as argument, not degrees.

/* tan example */

#include

#include

#define PI 3.14159265

int main ()

{

double param, result;

param = 45.0;

result = tan (param*PI/180);

printf ("The tangent of %lf degrees is %lf.\n", param, result );

return 0;

}

2. Which normals to use for ray-triangle intersection?

The scene file provides a normal for every triangle vertex. However, those normals should NOT be used for

ray-triangle intersection. For the intersection calculation, you need to compute the normal of the plane

containing the triangle. You do so by taking a cross product of two edges:

A

|\

| \

| \

------

B C

Normal for ray-plane intersection = (B-A)x(C-A) (and you must normalize this vector)

The vertex normals provided in the scene file must be used for Phong shading, i.e., when evaluating I =

lightColor * (kd * (L dot N) + ks * (R dot V) ^ α) . You must interpolate the vertex normals given inscene file to

the specific location of the ray-triangle intersection (using barycentric coordinates). You then use the resulting

interpolated normal N in the above equation (also to compute R). This will give smooth specular highlights.

3. If L dot N, or R dot V are negative, should I clamp them to zero?

If the angle between the view vector (V) and the reflected vector (R) is greater than 90 degrees, R dot V

will be negative. In this case, the deviation between the reflection direction and the view direction is

huge, i.e., we are very far from that case where the reflected and view direction nearly align and where

we get specular highlights. So, there is no specular reflection in this case, and we can just clamp R dot

V to zero.

Similarly for the diffuse component. If L dot N < 0, the light is below the horizon, so we clamp L dot N to 0.