Notes, 98-04-06
---------------

Want the dual junk on const's so that when you display, your basis f'ns are
1, so you just display what you've got.

The dual stuff is just a framework for thinking about how you're avoiding
multiplies at display-time.

Today: operators and norms.

Operators are a layer of notation that makes it easier to work with nasty
integral equations.  Norms tell su how big things are.

Suppose we have
                                        cos(theta_x) cos(theta_y)
   L(x) = L_e(x) + rho(x) Int_hemi L(x) ------------------------- vis(x,y) dy
                                              || x-y ||^2

We write, representing that integral as an operator M:

   L(x) = L_e(x) + ML(x)
   (I-M) L(x) = L_e(x)

This makes it obvious that our goal is to invert the opeartor M.  Makes it
clear that if L_e(x) is scaled by some constant, we end up with an L(x)
scaled by the same constant, if M is linear.  Properties of lienar op is:

   a (I-M) L(x) = a L_e(x)      - make light dimmer, scene gets uniformly dim
   (I-M)(L_1(x) + L_2(x)) = L_e1(x) = L_e2(x) - solve for each light, add up

The operator I-M will someday become a matrix; it's a whole lot easier to
solve matrix eq'ns than integral eq'ns.  These eq'ns are really like:

  (I-M) L = L_e

they're equations whose solutions are functions.  We want to invert the
operator I-M:

  (I-M)^-1 = I + M + M^2 + M^3 + ...

if M^k goes to zero eventually, then it's friendly and it converges.  The
operator M takes radiance functions to radiance functions.

It's often nice to split an operator up into two other operators.  Let's create
two, G and K that when composed together to the same thing as M:

  KG = M

G is the global operator, K is local.  G deals with "shooting light out" from
the world.  K deals with an interaction at a specific point.  G adds a bunch
of stuff up and yields the "field radiance" which is the irradiance at a
specific point.

K takes the incoming radiance (from G) and does most of the rest:

  K = rho(x) Int_hemi L_i(x,w) cos (theta_x) dw

Remember from first day (xformation of variables):

  cos(theta_y) vis(x,y)
  --------------------- dy = dw
      || x-y || ^2

it's sortof the local effects.  It takes everything coming in and weights it
by the reflectivity at a point.  Has to do with "hemicube radiosity
algorithms."

Global means that in order to figure out what's going on a pt x we have to
look through the whole universe (global operation) then perform reflection
and stuff (local operation).

G gives us incoming at a pt, then K gives us outgoing form the pt.

Can't write down what G is.  It's sortof the ray-tracing operation.  It
moves a little vector from a source to a target.

---

(forget all variables)

Norms basically say how big things are.  Use 'em in vector things all the
time.  sqrt(a_x^2+a_y^2+a_z^2) is the 2-norm: ||a||_2

Properties of norms:

  ||x|| >= 0
  ||x|| == 0 iff x == 0    (anything nonzero is some dist. away from zero)
  ||ax|| == |a|*||x||
  ||x+y|| <= ||x|| + ||y|| ("triangle inequality")

We're interested in the sizes of different functions: "How big is L?"
"How big is ML?" ||L||, ||ML||.  Might want to know the magnitude of a
radiance.  It's a measure of size.

There are a set of useful norms, called the p-norms: L_1 norm, L_2 norm, 
L_infinity norm and the general L_p norm.  L means "over functions":

  L_1 norm = ||L||_1 = Int Int | L(x) | cos(w) dx dw

basically, you integrate the abs of the f'n over the entire space.  Since
our L(x) is constant over the outgoing direction, we can pull the cos(w)
out and turn it into a Pi:

                     = Pi Int | L(x) | dx   -- L is W/m^2*sr
                                          ||L||_1 units is W

The 1-norm is a measure of the amount of power in the environment; how much
energy is different between the two functions.

The infinity-norm is Max over all x,w of L(x,w)

L1-norm is good for "how totally wrong is this function"?
Linf-norm is good for "how maximally wrong is this function"?

L2-norm = sqrt(Int Int | L(x) |^2 cos w dx dw)
Lp-norm puts a ^p and a 1/p for the root.

L1-norm is for energy
L2-norm is for dual stuff
Linf-norm looks at maximal variation between two things

these are the 3 people use in practice.

We have norms defined for functions as above.  We also have norms defined for
operators: ||N||_p = ||N_x||_p / ||x||_p

It says basically: What's the worst possible thing (in terms of making it
larger) that this operator can do for any x?

Since the ops are linear (for scalar mult): ||N||_p = Max_x ||Nx||_p / ||x||_p
= Max_x:||x||=1 ||Nx||_p

Basically, you take an N-sphere (N is dimension of argument space for
operator's function) through the operator and get some funky shape.  The norm
of the operator is the farthest point from the origin on that funky shape.

If we can show that ||M||<1, then ||M^k||<||M||^k, so this goes to zero,
so that big series we had above will converge.

Can't show that for M reallly, but *can* for G and K, which is why we chopped
M up in the first place.

G is a "shuffling operator"; it hasn't changed the value of anything, it's
just changed where it's at.  It's nicely invertible (can put it all back where
it came from):

  ||G|| = 1

It's < 1 if there are "holes in space" through which energy disappears.

Want to bound K as well, then use fact that ||M|| = ||KG|| <= ||K|| ||G||

If can show inf-norm of K is < 1, then we're happy.  cos in K just makes
things smaller.  If rho(x)<1, it all works out.  Might need rho(x)<1/Pi
if you define things that way.  The inf-norm of K is the maximum reflectivity.

Key thing: as long as max refl < 1, (I-M)^1 converges, and by looking at
||K||, you can tell how far out you need go before you should stop.  This
is one of the HW questions.