Mirrors: More Problems from Nature

Discussion.

What do you see when you look at something in a mirror? You see the mirror image of it! Mathematically, the object is reflected in the plane of the mirror. It is an interesting problem to draw the reflection of an object in a Maple worksheet. Just how would you do that? For example, in the diagram below, P is a point on the object and R is your eye. How do you determine the point Q that your eye sees when you look at the reflection of P in the mirror? The answer is that Q is the point on the mirror which also lies on the line from R to P', the reflection of P through the mirror. P' is defined mathematically as the point on the opposite side of the mirror such that the segment PP' is perpedicular to the mirror and is bisected by the mirror. So the point Q is a convex combination of P' and R. The equation is . If we take the plane of the mirror to be the xz-plane (y=0), then we can determine s by solving the equation in the second coordinate (indicated by a "2" subscript).

or

Since , the reflection of in the yz plane, we have that .

mirr1

Diagram "light1"

> miror:=plots[polygonplot3d]([[-2,0,0],[2,0,0],[2,0,3],[-2,0,3]],
style=wireframe,thickness=3,color=blue):
flor:=plots[polygonplot3d]([[-2,-1,0],[2,-1,0],[2,1,0],[-2,1,0]],
style=patch,thickness=3,color=tan):
pointP:=plots[textplot3d]([-1,1,1,` P`], font=[TIMES,BOLD,24]):
refP:=plots[textplot3d]([-1,-1,1,` P'`], font=[TIMES,BOLD,24]):plots[display]([miror,flor,pointP,refP]):
eye:=plots[textplot3d]([2,2,1,` eye`], font=[TIMES,BOLD,24]):
P_refP:=plots[polygonplot3d]([[-1,1,1],[-1,-1,1]],
style=wireframe,color=red):
eye_refP:=plots[polygonplot3d]([[2,2,1],[-1,-1,1]],
style=wireframe,color=red):
pointQ:=plots[textplot3d]([0,0,1,` Q`], font=[TIMES,BOLD,24]):
light1:=plots[display]([miror,flor,pointP,refP,eye,P_refP,
eye_refP,pointQ],orientation=[40,60]):

> light1;

We can define a word 'image' to return this point Q given the points P and R.

> image := proc(p,r)
local s,q,refp;
s := p[2]/(r[2]+p[2]);
refp :=[p[1],-p[2],p[3]];
q := s*r+(1-s)*refp;
end:

Test this word out by taking p to be at [0,2,1] and r at [1,1,1]. In this case, the reflection of p through the xz plane is refp = [0,-2,1], the scalar s is 2/(1+2), and so the image of p on the mirror y=0 when the observer r is at [1,1,1] is 2/3*[1,1,1]+ 1/3*[0,-2,1] = [2/3, 0, 1].

> p := [0,2,1]; r:=[1,1,1];
q := image(p,r);

That's right. Now we can draw the picture.

> pl1 := plots[polygonplot3d]({[p,q],[r,[p[1],-p[2],p[3]]]}, thickness=3,scaling=constrained,axes=boxed):

> pl2 :=plots[textplot3d]({[op(q),`Q`], [op(r),`R`],[op(p),`P`]},
align=BELOW):

> plots[display]([pl1,pl2]);

Problem: Draw the letter K and its reflection in a mirror.

For the sake of simplicity, let us assume that the letter K is standing in the yz plane on the y-axis, with one base at say [0,1,0] and the other at [0,2,0]. Our mirror will be a square in the xz plane with base [[0,0,0],[2,0,0]]. We, the observer will be standing at a point (a,b,c) to be determined later. The picture looks like this:

mirr2

First define the mirror and the letter k.

> mir := [[0,0,0],[2,0,0],[2,0,2],[0,0,2]];

> mirror := plots[polygonplot3d](mir,style=patch,color=gray):

> kay := [[0,1,0],[0,1,1]],[[0,1,.5],[0,1.5,1]],
[[0,1,.5],[0,1.5,0]];

> ka :=plots[polygonplot3d]({kay},thickness=3,color=red):

Now the image of the letter k in the mirror is a function of the position (a,b,c) of the observer.

> refkay := proc(a,b,c)
local i;
seq(map(image,kay[i],[a,b,c]),i=1..nops([kay]));
end:

>

So let's pick an observation point ob

> ob := [2,3,1];

obs is a blue stick located at the observation point.

> obs := plots[polygonplot3d]([ob,[ob[1],ob[2],0]],color=blue,thickness=3):

reka is the image of the letter k in the mirror from the observation point ob.

> reka :=plots[polygonplot3d]({refkay(op(ob))},thickness=3,
color=red):

We can see what this looks like with display.

> plots[display]([obs,mirror,ka,reka],scaling=constrained,axes=boxed);

Looks fine. Copy down the input cells from above to make a word to draw the mirror, the letter, and its image in the mirror as seen from the observer.

> mirimage := proc(ob)
local obs, reka;
obs := plots[polygonplot3d]([ob,[ob[1],ob[2],0]],color=blue,thickness=3):
reka :=plots[polygonplot3d]({refkay(op(ob))},thickness=3,color=red):
plots[display]([obs,mirror,ka,reka],scaling=constrained,axes=boxed);
end:

> mirimage([3, 4,.2]);

Exercise : Make a movie showing what happens to the reflection as we move the observer around in a circle .

> movie := [seq(mirimage(evalf([2+cos(j*Pi/5),2+sin(Pi*j/5),1])),j=1..10)]:

> plots[display](movie,insequence=true);

>

Questions:

Question: Suppose we had another mirror in a vertical plane perpendicular with the first mirror with its base on the segment [[3,1,0],[3,3,0]]. If an observer at [2,2,1] looked in the second mirror, what would he see (besides himself)? Model this.

Question If you have two perfect mirrors, and hold them just right, you can see down an infinite corridor. Even with two good mirrors, you can see a large number of reflections of reflections. Observe this and describe what you see exactly. As an experiment, hold up a transparency with a letter k written on it. How hard would this be to model?

Question: If you have three mirrors which form a corner of a box and shine a beam of light almost into the corner, what happens to the beam?

Problem: Model a kaleidoscope.

Some solutions

geombouncer instructions

> restart;

> geombouncer:=proc(A,P, dir,maxbounces)
local objlist,j:
geometry[point](O,[0,0]);
geometry[point](a,A):
geometry[point](c,P+dir):
geometry[point](b,[A[1],0]):
geometry[point](p,P):
geometry[line](topline,[O,a]):
geometry[segment](top,[O,a]):
geometry[line](baseline,[O,b]):
geometry[segment](base,[O,b]):
geometry[line](lnofpth0,[p,c]):
geometry[intersection](R0,lnofpth0,topline):
geometry[reflection](lnofpth1,lnofpth0,topline):
geometry[intersection](R1,lnofpth1,baseline):
geometry[dsegment](path0, [R0,R1]):
geometry[dsegment](initialpath, [p,R0]):
objlist:=NULL:
objlist:=R0,a,b,O,top(color=tan,thickness=2),base(color=tan,thickness=2),initialpath(color=blue,thickness=2),path0(color=blue,thickness=2):
for j from 1 to maxbounces while ( geometry[coordinates](cat(R,j))[1]< A[1] and geometry[coordinates](cat(R,j))[1]>0 ) do
geometry[draw]({objlist});
if (geometry[coordinates](cat(R,j))[2]< geometry[coordinates](cat(R,j-1))[2]) then
geometry[reflection](cat(lnofpth,j+1),cat(lnofpth,j),baseline):
geometry[intersection](cat(R,j+1),cat(lnofpth,j+1),topline):
else
geometry[reflection](cat(lnofpth,j+1),cat(lnofpth,j),topline):
geometry[intersection](cat(R,j+1),cat(lnofpth,j+1),baseline):
fi:
geometry[dsegment](cat(path,j),[cat(R,j),cat(R,j+1)]):
if geometry[coordinates](cat(R,j+1))[1] >0 then
objlist:=objlist,cat(R,j),cat(path,j)(color=blue,thickness=2): fi:
od:
geometry[draw]({objlist},scaling=constrained);
end:

> geombouncer([7,5],[8,3],[-1,-.2],10);

>

>

In the above example the ray emits from [8,3] in the direction [-1,-.2] and bounces five times before it leaves the mirrors.

Exercise: Experiment with geombouncer to see if you can make the ray bounce a large number of times. Note that simply chosing a shallow angle won't necessarily produce a small number.

> geombouncer([7,5],[7,4.8],[-7,-4],10);

>

>

To analyze this problem we will find it convenient to use the two angles and as indicated in the following diagram.

mirr4

That is, is the angle between the two mirrors (which we take to be acute) and is the angle of incidence of the ray upon the upper mirror. Actually, what we want to look at is the sequence of incidence angles = , ... The basic idea is that the angles are increasing in size and as soon as becomes greater than or equal to the ray will be on its way out of the region between the mirrors

mirr5

Thus we need to see how to calculate for each i. This is not hard to do if we determine the reflection of the angle rather than the angle itself. Consider the following diagram in which the angle AOB is reflected through the line AO to produce the angle AOC. The initial ray strikes AO at the point R0 and angle . It is reflected, hitting the segment AO at the point R1 at angle . If the original path were continued it would meet OC at a point R1'.

Exercise: Show that, as indicated in the diagram, the angle R0R0'C is equal to and that

mirr6

Exercise: Extend the previous argument by reflecting AOB first through AO and then through OC and use the same idea to show that . This and in general .

Exercise: Argue that there are exactly as many bounces of the light beam between the two mirrors as there are points of intersection of the extended original path of the fan of rays with rays spaced exatly apart opening counterclockwise from the x-axis.

Show that the ray will start moving away from the center on that pth bounce where p is the smallest integer such that

mirr7

Exercise: Show that there will be q bounces where q is the largest integer such that

Exercise: Show that the light will exactly retrace its enrty route to leave if and only if is a non-negative integer.

Exercise: If two mirrors meet at a 30 degree angle what is the maximum possible number of reflections off of the mirrors of a light ray which is incident upon one of them?

Exercise: Adapt the instructions in the "geombouncer" word to produce an animation of the ray following its path rather than a static image of the final path.

We used the geometry package for our diagrams earlier but there is no reason for our not writing a "bouncer" word ourselves. The following word "bouncer" takes in angles alpha and beta where theta is the angle between two lines and alpha is an angle of at most alpha which an incident ray makes with one of the legs of the angle. The procedure returns a plot of the path of the ray as it enters and bounces out of the angle between the two lines. It is followed by an an alternate discussion of the calculation of the numnber of intersections, paths that retrace themselves, etc.

> bouncer:=proc(alpha, beta)
local STARTPT,n,w,line,nalphaline,eqn,eqns,PTS,leg1,leg2,refpts,i,N,slns; STARTPT:=evalf([cos(alpha),sin(alpha)]);
line:=evalf(expand(STARTPT+t*[ cos(alpha-beta), sin(alpha-beta)]));
nalphaline:=s*[cos(n*alpha) ,sin(n*alpha)];
eqn:=expand(line-nalphaline);
eqns:={eqn[1]=0,eqn[2]=0};
PTS:=NULL;
N:= floor((Pi-beta)/alpha):
if frac((Pi-beta)/(alpha))=0 then N:=N-1 fi;
for w from 1 to N+1 do
slns:=fsolve(subs(n=w,eqns),{s,t}):
PTS:=PTS,subs(slns, line):
od: PTS:=[PTS];
leg1:=evalf([cos(alpha),sin(alpha)]);leg2:=[1,0];
refpts:=NULL:
for i from 1 to nops(PTS) do
if i mod 2 = 1 then refpts:=refpts,linalg[norm](PTS[i],2)*leg1; else refpts:=refpts, linalg[norm](PTS[i],2)*leg2 fi; od:
plots[display]( [plots[polygonplot]([[0,0],[1,0],[1,tan(alpha)]],style=patch,color=tan), plot([refpts]),
plots[polygonplot]([STARTPT,subs(t=.2,line),STARTPT],scaling=constrained )]):
end:

>

>

> bouncer(Pi/4,Pi/8);

>

>

The unterminated line is the incident ray and the returning path ends at its last bounce point. That is the returning ray will reflect at an angle smaller than theta, the lower left angle of the colored triangle and will therefore not hit either leg of the triangle again.

If is the incident angle which is less than or equal to theta then the angle at which the ray rebounds at the ith bounce is (where the initial bounce is the "zeroth"). The condition for the ray to return exactly along its original path is that it hit one of the legs at a right angle, that is that is a right angle

> eqn1:=beta+n*alpha=Pi/2;

> critbeta:=solve(eqn1,beta);

>

>

Since we see that n is the integer part of unless this is actually an integer in which case this value of n is one less than . The latter situation only occurs when theta has the form where k is an integer. For the moment, we ignore this possibility and have the formula

> critbeta:=proc(alpha) Pi/2-floor(Pi/(2*alpha))*alpha end;

>

>

Now we can draw most critical paths:

> backbouncer:= proc(alpha) bouncer(alpha, critbeta(alpha))end;

>

>

> backbouncer(Pi/5);

>

>

Note that backbouncer does fine with angles other than those like , etc.

Exercise: Complete backbouncer so that it works for all positive angles less that .

Exercise: Do an animation of backbouncer as theta changes between and

Solution

> movie:=NULL: for i from 1 to 20 do movie:=movie,backbouncer(Pi/5-1/4+i/40): od:plots[display]([movie],insequence=true);

>

Exercise: In the animation for the previous exercise the leg at which the ray meets perpendicularly switches several times. Where (i.e. at which angles theta) do such switches happen?

>