My friend told me that many years ago, she lost points in an MIT art class for putting the highlight in the wrong place on a sphere. So when she saw my last post about radiance, she posed the question to me.
Turns out the answer is (-0.24,-0.25,-2.06).
![]()
![]()
// Projects a sphere onto the screen with ambient, diffuse and specular
Turns out the answer is (-0.24,-0.25,-2.06).
Here's one where I moved the light source and just liked how it looked (before I added specular reflection):
// Projects a sphere onto the screen with ambient, diffuse and specular
// lighting, and prints the location of the specular highlight.
//
// Viewpoint is 0,0,0
// Screen is from -1,-1,-1 to 1,1,-1
// Sphere is at 0,0,-3 with radius 1
// Light source is at -1,-1,0 and projects
//
// Surface of the sphere emits ambient light in red, specular reflection in green and
// diffuse reflection in blue.
//
// Compile with gcc -o sphere sphere.c -lm -lfreeimage
// and make sure you have the libfreeimage-dev package installed.
#include <stdio.h>
#include <math.h>
#include <FreeImage.h>
#include <stdlib.h>
#define IMAGE_WIDTH 1000
#define IMAGE_HEIGHT 1000
#define SAMPLE_DENSITY 300
FIBITMAP *image;
void setup_image() {
FreeImage_Initialise(FALSE);
image = FreeImage_Allocate(IMAGE_
if (image == NULL) {
printf("Failed to allocate image.\n");
exit(1);
}
}
void setpixel(double x, double y, double r, double g, double b) {
RGBQUAD color;
const double brightness_boost = 40.0;
int red = fmin(r * 255 * brightness_boost, 255);
int green = fmin(g * 255 * brightness_boost, 255);
int blue = fmin(b * 255 * brightness_boost, 255);
color.rgbRed = red;
color.rgbGreen = green;
color.rgbBlue = blue;
FreeImage_SetPixelColor(image, x * IMAGE_WIDTH + (IMAGE_WIDTH / 2),
y * IMAGE_HEIGHT + (IMAGE_HEIGHT / 2), &color);
//printf("%lf,%lf\n", x, y);
}
void teardown() {
FreeImage_Save(FIF_PNG, image, "out.png", 0);
FreeImage_DeInitialise();
}
int main(int argc, char **argv) {
const double pi = 3.14159;
const double sphere_z = -3;
const double light_x = -1;
const double light_y = -1;
const double light_z = -1;
const double light_brightness = 1;
const double specular_reflection_exponent = 10;
const double reflected_brightness = 500;
const double ambient_brightness = 0.2;
double latitude;
const double latitude_elements = SAMPLE_DENSITY / 2;
const double latitude_step = pi / latitude_elements;
setup_image();
// For MIT's art department, keep track of where the specular highlight looks brightest
double max_reflected_value = 0;
double highlight_x = 0;
double highlight_y = 0;
double highlight_z = 0;
// Walk over the sphere and compute light from the source and to the viewpoint at each spot.
for (latitude = 0; latitude < pi; latitude += latitude_step) {
double y = cos(latitude);
double longitude;
const double radius = sin(latitude);
const double circumference = 2 * pi * radius;
const double longitude_elements_at_equator = SAMPLE_DENSITY;
const double longitude_step = (2 * pi) / longitude_elements_at_equator;
for (longitude = 0; longitude < pi; longitude += longitude_step) {
double x = radius * cos(longitude);
double z = radius * sin(longitude);
// Now we have x,y,z relative to the sphere center. To get absolute coordinates,
// we just have to translate in z, since the sphere is at 0,0,sphere_z.
double absolute_z = z + sphere_z;
double distance_to_viewpoint_squared = x*x + y*y + absolute_z*absolute_z;
double distance_to_viewpoint = sqrt(distance_to_viewpoint_
// Dot product is x1x2 + y1y2 + z1z2 and yields cosine of the angle between
// them if they're both normalized.
// But x1=x2 and y1=y2, and |x,y,z|=1, so we only need to normalize by
// distance_to_viewpoint.
// This dot product is between the viewpoint and surface normal
double view_dot_product = (x*x + y*y + (absolute_z * z)) / distance_to_viewpoint;
// Now we'll calculate the dot product for the light source.
// First, the vector from the sphere surface to the light
double lx = light_x - x;
double ly = light_y - y;
double lz = light_z - absolute_z;
double light_distance_squared = lx*lx + ly*ly + lz*lz;
double light_distance = sqrt(light_distance_squared);
// Now we can compute cos(angle to the light)
double light_dot_product = (lx*x + ly*y + lz*z) / light_distance;
// Cosine law for intensity and inverse square law
double light_intensity = fmax(light_dot_product, 0) / light_distance_squared;
// Reflection of light vector is light - 2(light dot normal)*normal
// (also normalizing here)
double reflected_x = (lx - 2*light_dot_product*x) / light_distance;
double reflected_y = (ly - 2*light_dot_product*y) / light_distance;
double reflected_z = (lz - 2*light_dot_product*z) / light_distance;
// Now we compute cos(angle between reflection and viewpoint)
double reflected_dot_product = (reflected_x*x + reflected_y*y + reflected_z*absolute_z)
/ distance_to_viewpoint;
reflected_dot_product = fmax(reflected_dot_product, 0);
// Raise to a power based on how shiny the surface is
double reflected_intensity = pow(reflected_dot_product, specular_reflection_exponent);
// Lambert's Law and inverse square law to viewpoint
double view_intensity = fabs(view_dot_product) / distance_to_viewpoint_squared;
double light_value = light_brightness * light_intensity * view_intensity;
double ambient_value = ambient_brightness * view_intensity;
double reflected_value = reflected_brightness * view_intensity * reflected_intensity;
//printf("light:%.4lf ambient:%.4f\n", light_value, ambient_value);
// If the sphere is lambertian, then the cosine of the angle between the surface
// normal and the viewpoint gives the intensity.
double projected_x = x / absolute_z;
double projected_y = y / absolute_z;
//printf("[lat=%.02lf lng=%.02lf (%.02lf,%.02lf,%.02lf) ", latitude, longitude, x, y, z);
setpixel(projected_x, projected_y, ambient_value, reflected_value, light_value);
if (reflected_value > max_reflected_value) {
max_reflected_value = reflected_value;
highlight_x = x;
highlight_y = y;
highlight_z = absolute_z;
}
}
}
printf("Brightest specular highlight was at (%.02f,%.02f,%.02f)\n",
highlight_x, highlight_y, highlight_z);
teardown();
return 0;
}