Optics, lenses, and cameras

Every photo on your phone, every word you read through your glasses, and the entire internet arriving over fiber all come down to one trick: a piece of glass that bends light in a predictable way. Learn to trace three lines and you can predict the picture any lens will make, before you ever touch an equation.

Why light bends at all

Start with something you have seen: a straw in a glass of water looks snapped at the surface, and a pool looks shallower than it is. Light travels a little slower inside water or glass than in air. When a wave crosses the boundary at an angle, one side of it enters the slower material before the other side does, so the wave pivots - the same way a shopping cart veers when one wheel hits gravel first. That pivot is called refraction, and it is the whole reason a lens can steer light. Light itself is the electromagnetic wave we built in electromagnetic waves and light; here we only need one fact about it, that it slows down in glass.

The precise rule for how much it bends is Snell's law. Each material gets a number $n$, its refractive index, which is just how many times slower light goes inside it (air is about 1, water 1.33, glass 1.5). The angles the ray makes with the line perpendicular to the surface obey:

This is stated here rather than derived, but the direction of the bend is not arbitrary: going into slower glass, the ray always swings toward the perpendicular, which is exactly what makes a curved piece of glass pull parallel light together.

Trace three rays and you have the image

A lens is curved so that its surface faces each incoming ray at a slightly different angle. You do not have to track every ray - for a thin converging lens, three special ones tell the whole story, and they meet exactly where the image forms. Drag the blue object in the widget and watch the three amber rays refract and cross.

The three rays each follow a rule you can memorize in a sentence:

Play with the object distance and one thing jumps out. When the object is farther than the focal length (the slider marked F), the rays cross on the far side and form a real image - one you could catch on a sensor or a piece of paper, and it is upside down. Slide the object inside the focal length and the rays on the far side spread apart instead of crossing; your eye traces them back to a virtual image that is right-way-up and enlarged. That second case is a magnifying glass, and it is why the widget draws those rays as dashed lines going backward.

The one equation that predicts the picture

The geometry of those crossing rays collapses into the thin-lens equation, relating the object distance $d_o$, the image distance $d_i$, and the focal length $f$:

Rearranged, $d_i=\frac{f{d}_o}{d_o-f}$, which is exactly what the widget computes to place the image. Notice the sign flip: when $d_o$ drops below $f$, the denominator turns negative, $d_i$ lands on the same side as the object, and the image becomes virtual. The magnification is $m=-\frac{d_i}{d_o}$: a negative value means upside down. This is derived from the same similar triangles the three rays draw, and it is all a phone camera does - move the lens a hair to change $d_i$ until a sharp real image lands on the sensor.

Trapping light: total internal reflection

Switch the widget to the Fiber tab. Snell's law has a breaking point. Going from glass into air, the ray bends away from the perpendicular, and past a certain angle - the critical angle - it cannot escape at all. Every bit of it reflects back inside. That is total internal reflection, and it is a perfect mirror made of nothing but a change in material. Slide the ray to a shallow angle and it races down the fiber, bouncing thousands of times without leaking. That is your fiber internet: light pulses trapped inside a glass thread thinner than a hair, carrying data across oceans.

The CS bridge: this is literally how graphics rendering works

Tracing rays to find where an image forms is not a metaphor. A ray tracer, the rendering technique behind modern game and film graphics, does exactly what you just did by hand: it follows straight light rays, bends or reflects them at each surface using Snell's law and reflection, and records where they land. The math in the widget is the math in the renderer.

def image_distance(f, d_o):
    # thin-lens equation solved for d_i; negative means a virtual image
    return f * d_o / (d_o - f)

def refract(theta1, n1, n2):
    # Snell's law: the angle after crossing into a new material
    import math
    return math.asin(n1 / n2 * math.sin(theta1))

print(image_distance(f=50, d_o=200))   # -> 66.7  real image, past the lens
print(image_distance(f=50, d_o=30))    # -> -75.0 virtual image (magnifier)

Check yourself