In Pan, images are functions from continuous, infinite 2D space to colors with partial opacity.  It's useful to generalize to images over arbitrary "pixel" type, so we make Image be a type constructor:

type Image c = PointE -> c type PointE = (FloatE, FloatE)

We will explain below why we use an "E" suffix in type names.  For now, you can think of FloatE as synonymous with Float, etc.

Two useful special cases are color-valued images and spatial regions:

type ImageC = Image ColorE type Region = Image BoolE

Note that any function over 2D space is an image, no matter how you define it.   You can define one entirely from scratch if you want.  For instance here is a Sierpinski-like region.

gasket :: Region gasket (x,y) = i .|. j <=* i where i = f2i x; j = f2i y

The f2i function truncates floats into ints, and the ".|." operator is bitwise or.

You don't have to create images from scratch, because Pan provides many useful image-producing functions.  For instance, bitmap importation, stretching, turning, moving, swirling, and tiling.  See Functional Images for some of what can be done, although that paper takes some liberties with notation.  See also the implementation's Image module and the examples in DemoSrc.

Spatial transforms are simply mappings from space to itself:

type TransformE = PointE -> PointE

Again, anything of this type is a transform, no matter how it's defined.  Again, you can make your own from scratch, or use the building blocks that Pan provides.  As an example, here are the definitions of translation (shifting) and scaling:

translateP, scaleP :: (FloatE,FloatE) -> TransformE translateP (dx,dy) (x,y) = (x + dx, y + dy) scaleP (sx,sy) (x,y) = (sx * x, sy * y)

Rotation has the same form, but a more complicated calculation, using trig:

rotateP :: FloatE -> TransformE rotateP ang (x,y) = (x * c - y * s, y * c + x * s) where c = cos ang s = sin ang

Note the selective use of Currying here.  The translate, scale, and rotate functions are typically applied to a single argument, yielding transform, which is another function.

What about transforming images?  The trick is to compose the image (itself a function) with the transform's inverse.  Since it's not always possible to invert functions, Pan provides some convenient definitions that form inverse functions and perform the composition.  For instance,

translate (dx,dy) im = im . translateP (-dx, -dy) scale (sx,sy) im = im . scaleP (1/sx, 1/sy) rotate ang im = im . rotateP (-ang)

There are many more transform building blocks.  See the paper, examples, and the Transform module.

Our first examples are drawn from the module "Simple" (in the file Simple.hs) in the DemoSrc directory.  This module mainly contains definitions of "UIs", which encapsulate both an image effect and the user interface to that effect.  These encapsulated effects and their user interfaces can be combined into more complex and specialized ones.  (That is, they are compositional, "first class values".)  Let's look at a first example:

rotateUI :: UI (ImageXf a) rotateUI = do angle <- angleUI "rotate" (-180,180) 45 return $ rotate angle

The "do notation" we use comes from Haskell's more general support for "monads".  Monads are type constructors that serve to contain or generate values.  (You do not need to understand monads in general to use Pan.)  Here, UI is the monad -- it not only presents controls to the user, but also generates a value.  In this case, the value is an image-transforming function, for which Pan provides a convenient name:

type Filter c = Image c -> Image c

The polymorphism here means that rotateUI can be applied to any image with any type of "pixels".  The most common two are ColorE and BoolE, with the latter representing arbitrary regions of 2D space.

The angleUI function used here is defined in terms of the slider primitive.  It interprets the slider value as degrees, with positive to the right (clockwise) and negative to the left (counter-clockwise). This convention matches the slider, kinesthetically, and is mapped to radians with positive counter-clockwise and negative clockwise.

angleUI :: Label -> (Float, Float) -> Float -> UI FloatE angleUI lab range def = do angDeg <- slider lab range def return $ angDeg * (-pi/180)

Note the common pattern in these two definitions: a value is extracted from a UI and used to construct a new value, which is then returned.  Haskell is very good at being able to abstract patterns, and in fact already has a suitable monadic combinator: liftM.  We can use liftM because it is defined to work on all type constructors declared to be monads.

liftM :: (Monad m) => (a -> b) -> m a -> m b liftM f a = do a' <- a return $ f a'

Using liftM allows us to rewrite turnUI and angleUI more succinctly:

turnUI = liftM turn $ angleUI "turn" (-180,180) 45 angleUI lab range def = liftM (* (-pi/180)) $ slider lab range def

For angleUI, we've used Haskell's "section" notation for partially applied infix operators (here "*").

As another example, here's the definition of the ripple UI, which is based on the rippleRadius image-producing function.  Since rippleRadius takes two arguments instead of one, there are two sliders in our composite UI:

rippleUI = do n <- islider "# ripples" (1,15) 3 d <- slider "depth" (-0.5,1.5) 0.3 return $ rippleRadius n d

Again, there is a concise monadic equivalent:

rippleUI = liftM2 rippleRadius (islider "# ripples" (1,15) 3) (slider "depth" (-0.5,1.5) 0.3)

For more examples, see Simple.hs, and the other modules in the DemoSrc directory.

Sometimes overloading is not possible, because the original type declarations were not general enough.  In such cases, Pan provides a function whose name ends in "E" or "*", depending on whether the original is alphanumeric or not.

	"if-then-else" is not overloadable, so Pan uses "ifE".
	Equality and inequality relations, and boolean connectives, e.g., "x >* 1", "notE" and "a ||* b".
	Some number functions, evenE, oddE, truncateE, roundE, ceilingE, floorE.

If you forget to append a "*" or "E" when needed, you should get a helpful error message.