Suppose you have a ray of light that hits a flat surface such as a mirror and is
ID: 3818919 • Letter: S
Question
Suppose you have a ray of light that hits a flat surface such as a mirror and is reflected. What is the
direction of reflection? This is a problem that arises in areas such as optics and computer graphics. To
solve it, we need to know the original direction of the light ray, and the orientation of the surface. Let
the direction be given by a vector v = (vx , vy, vz), and let the surface orientation be specified by an
outward normal vector n = (nx , ny , nz) of the surface1.
To compute the reflection vector we first check if v is heading towards the surface. If it is not, then it
will not reflect off the surface. This check is done by using the dot product
v · n = vxnx + vyny + vznz .
Your first task in this part is to write a function:
double dotProduct(double vx, double vy, double vz, double nx, double ny, double nz)
that computes the dot product. If the dot product is greater than or equal to zero, the ray of light is
headed away from (or parallel to) the surface, and so no reflection occurs. So we only compute the
reflection vector if the dot product is less than zero. In this case, the next step is to normalize the
surface normal vector by dividing each component by the vector’s length2; this ensures the resulting
vector has unit length. Write a function:
void normalize(double& wx, double& wy, double& wz)
that, given any vector (w x , w y , w z ), computes its length, divides each component by that length,
and then uses call by reference to return those components. The final step is to use the formula
r = v 2(v . n)n
to compute the reflection vector. Here n is the normalized vector from the last step. Write a function:
1 A normal of a flat surface is a vector perpendicular to the surface. An outward normal is any such vector pointing
outward from the surface object rather than inward.
2 Recall the length of a 3D vector w is given by
void reflectionVector(double vx, double vy, double vz,
double nx, double ny, double nz,
double& rx, double& ry, double& rz)
that does the following: (i) takes the original surface normal vector n and normalizes it using the
normalize function, (ii) computes the reflection vector r = (rx, ry, rz ) (note to do this the formula above
needs to be applied three times: once for each of the x, y, and z components; also note that computing
the reflection vector requires use of the dotProduct function), and (iii) uses call by reference to return
the reflection vector components. Finally, write a main driver program that does the following:
1. Asks the user to input the original direction, and then input the surface outward normal.
2. Checks if reflection occurs. To do this it should use the dotProduct function.
3. If reflection does not occur, your main program should print out an appropriate message. If
reflection does occur, your main program should call the reflectionVector function to
compute the reflection vector, and should print out that vector.
4. In either case, your main program should then ask the user if they wish to continue. If they do,
the program should allow the user to continue this process as many times as they wish.
Here is some example input and output.
Input the original direction vx vy vz: 0 -1 0
Input the surface outward normal nx ny nz: 1 1 0
Reflection vector: 1 -2.22045e-16 0
Continue (y/n)? y
Input the original direction vx vy vz: 1.5 2.5 3.5
Input the surface outward normal nx ny nz: 1 1 1
No reflection
Continue (y/n)? y
Input the original direction vx vy vz: 1.5 2.5 3.5
Input the surface outward normal nx ny nz: -1 -1 1
Reflection vector: 1.16667 2.16667 3.83333
Explanation / Answer
//Include the needed header files
#include<iostream>
#include<cmath>
#include <stdio.h>
#include <string.h>
using namespace std;
//Function find the dot product of V and n vectors
double dotProduct(double vx, double vy, double vz, double nx, double ny, double nz)
{
//Declare the retVal
double retVal=0;
//Find the dot product
retVal=vx*nx+vy*ny+vz*nz;
//Return the retVal
return retVal;
}
//Method normalizes the vector n
void normalize(double& wx, double& wy, double& wz)
{
//Declare length
double length=0;
//Declare the temp
double temp=wx*wx+wy*wy+wz*wz;
//Take the sqrt
length=sqrt(temp);
//Divide each component by length
wx=wx/length;
wy=wy/length;
wz=wz/length;
}
//Method find the reflection vector
void reflectionVector(double vx, double vy, double vz,
double nx, double ny, double nz,
double& rx, double& ry, double& rz)
{
//call dotProduct() and store it in retVal
double retVal=dotProduct(vx,vy,vz,nx,ny,nz);
//Multiply n vector by 2*retVal
nx=2*retVal*nx;
ny=2*retVal*ny;
nz=2*retVal*nz;
//Find the r vector
rx=vx-nx;
ry=vy-ny;
rz=vz-nz;
}
//main
int main()
{
//Declare the variables
double vx,vy,vz,nx,ny,nz;
double rx,ry,rz;
double retVal=0;
char repChoice='y';
//Infinite loop
while(1)
{
//Get the original-direction
cout<<"Input the original direction vx vy vz:";
cin>>vx>>vy>>vz;
//Get the surface-outward normal
cout<<"Input the surface outward normal nx ny nz:";
cin>>nx>>ny>>nz;
//Find the dot product
retVal=dotProduct(vx,vy,vz,nx,ny,nz);
//Check the retVal
if(retVal<0)
{
//Call normalize()
normalize(nx,ny,nz);
//Call reflectionVector()
reflectionVector(vx,vy,vz,nx,ny,nz,rx,ry,rz);
//Display the reflection vector
cout<<"Reflection vector: "<< rx<<" "<<ry<<" "<<rz<<endl;
}
//If reflection not occurs
else
//Display message
cout<<"No reflection"<<endl;
//Get the repetition choice
cout<<"Continue (y/n)?";
cin>>repChoice;
//Check if user wants to quit
if(repChoice=='n')
//exit
break;
}
//Stop
return 0;
}
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.