Many of these original backgrounds were created with the aid of filters produced from Filter Factory. It's a tiny little plug-in, add-on that comes with Adobe Photoshop (which some have said is no longer even supported by Adobe in its latest Photoshop 7 release). However, the filters produced with it, and the little Filter Factory itself, will also run with other programs - such as Paint Shop Pro 4.12, which I use (with the restriction that in PSP, one of the channels used by Photoshop, the alpha or transparency channel, is ignored). What these filters do is move pictures around, even rolling around or wrapping from one side of the screen to the other. They can be used to sharpen or soften images, swirl them and rotate them around in all sorts of strange ways, break them up and superimpose 'weave' patterns, mirror or reflect them in different ways, and so on in a variety of often striking and useful effects. (At the bottom, you will find some links to various of these filters that others have already programmed and have made available.)

This Filter Factory editor is presented to the designer as a dialog box, with 8 sliders for controlling things (most of which are typically not used), and 4 large boxes for typing in the filter commands, for each channel (only three boxes in PSP, since it ignores the 4th channel).
 
 

The first three channels are simply the Red, Green and Blue values (0 to 255) of any dot in the image. The fourth is a transparency value for the dot. What you do is copy or type in a single line of commands and math operations, very cryptic, beginning with channel 0 (the Red channel) and then down to Green and Blue, as seen in the picture above. Each of these expressions, or command lines, returns a value from 0-255.

These commands are executed for every dot in the image. You simply set up the general instructions, and the filter performs the calculation repeatedly for each dot; each dot called more formally, a pel, or pixel (a term derived from the words, picture element), which consists of both its 2-D position in the image (X and Y) and its color, composed of the R, G, and B values (and with 256 shades of Red (0-255, counting 0), 256 of Green, and Blue, multiplied together, makes over 16 million colors possible, or 'true color').

And within these command lines, any or all of the sliders can be included by the ctl(x) command; that is, ctl, a control, and with a value from 0-7, eight in all. So when the filter is being run, the current value of that control (slider) is used right at the point where it's included in the command line.

As the filter runs automatically through every dot in the image, the R, G, and B values, each separately, for each pixel in its turn are referred to by lower case, r, g and b. And there's also a shortcut, c , which returns the value for the channel which contains that command line (e.g. the equation is for Red, then c refers to red). In addition, the channels can also be referred to by number, or 'index', (another scheme can be used, beside R,G,B, using other reserved letters, but it takes extra calculation time). R is 0, G is 1, B is 2, and the alpha transparency is 3. Various commands can retrieve or set these values by referring to 0 (red), 1, &c.

The coordinates used by the filter, again, are literally the pixel coordinates in the image, the position of each dot. There is a variable x and y , used for calculations, as the filter goes through every dot in the image when it runs. And the maximum is the actual width and height of the image, a constant, X or Y , written just so, with capital letters (e.g. if an image is 40 dots wide by 30 high, then if there is a cap X in the formula, it means 40, and any Y is 30).

There are also various operators allowed in command lines, plus and multiply &c., of course, but also logical/boolean operators, and a modulo, as well. There's an all important if-then-else branching construct; making this more sort of a language and less just a simple macro.

And, of course, there are the commands. There are read (e.g. src) and set pixel value. You have sin, cosine and the like, which are often used for wavy effects. You have polar coordinate commands, often used for swirling effects. And so on.

So . . an example. One of the most useful filters, particularly for PSP, is what one innovator with these filters called 'slipthrough'; a screen wrap. As also described elsewhere , the backgrounds, here, are seamlessly tiled.

• One way to do that is with a filter that blends the edges. But this often looks like it, and isn't always acceptable. PSP has one of these built-in. And you can do basically the same with one of these FF filters.
   
• A second way is using a mirror or kaleidoscope filter, such as with these bath tile backgrounds.
   
• A third way is to deform the image but wrap whatever is pushed off the image back around the other side.
   
• A fourth way is to use a wrap, which simply slides the image around, but also wrapping the bit that would otherwise get pushed off back around the other side of the image, making it so the former edges are now in the middle of the screen. There you can see them and fuzz them over, cut stuff out and overlay on these borders, and so on, in order to get a background that doesn't look just like a rectangle repeated over and over again. This is particularly useful for cloning photographic image textures. Adobe's Photoshop has this wrap capability built in. PSP 4 does not. The benefit, even so, of using a filter for this, is that the FF filter slips, or slides, or wraps only within the section that is selected, which is not necessarily the whole image.

This wrap filter is actually shown in the picture, above. Only two sliders are used for controllers, here the top two - ctl(0) and ctl(1). The top slider is used to wrap horizontally. The one underneath is used for the vertical. Each slider is set to 128 when the filter is first opened, which brings the margins around right into the center where you can then fudge over, smudge over, cut and paste over the border to make that seam 'go away' (for a slightly faster wrap, one can always use the 'slipthrough' filter, from the FF collection). There may still be a little bit on the edges, even so, that can escape touch up. So you might have to slide back and forth a little, up and down a little, until you've made it all pretty seamless; at which point it can be saved, or wrapped some more, or wrapped back to were it started (since it's seamless at this point, it no longer matters).

So, in the editor, this is the command line, repeated once for Red, Green and Blue:

for r,g,b src(( x <val(0,0,X) ? X-val(0,0,X)+x: x-val(0,0,X) ), ( y <val(1,0,Y) ? Y-val(1,0,Y)+y: y-val(1,0,Y) ), z)
 

Then press MAKE :

• and name ctl(0), Horiz, and set it at 128
• and ctl(1) is named Vert, and also set at 128
• (and might name the filter category, Mirror, or Wrap, or what have you)

(download the ready to run 8bf wrap filter, if you'd like)

• Src -- is a command to get a channel value for a specific pixel or dot, not necessarily that which the filter has gotten up to; but one anywhere in the image. In the grid of all pixels - it's choosing one in particular. Src is typically used in FF Filters.
   
• Lower case z -- is a 'dummy', shorthand for the index 0-3, similar to the c shorthand for channel value. For this same command line under Red, z is 0 (for red), but for green the index is 1.
   
• The question mark and colon -- are the branch construct: i.e., is the x position of whatever dot less than whatever ctl(0) has been set to. If the condition is true, then the first consequent, X (the width of the image) minus the slider value (the val() stuff, read on) plus whatever x position the filter is at. If false the next bit. Same for whatever y position it's gotten up to as the filter runs.
   
• The val command -- is sort of a normalization function. Without it, the wrap filter would be testing against actual pixel values from the margin, which would make the slider values inconsistent with different sized images. It's here, too, that those slider values, the filter controls, are read in as the zeroes and ones in the parentheses. Val maps the slider value, the first parameter or argument, into the integer range set by the next two; here being from 0 to either the X width of the image, or the Y height. So val(0,0,X) takes the value at ctl(0) and squeezes it into the range of 0 to whatever X (image width) happens to be.

And so other filters are similar, and even much more complicated. You need either this little Filter Factory editor (which you can use within Photoshop or PSP, as just another filter). Or you can use a separate Filter Factory Manager, linked just below; which is actually recommended since it allows one to add a lot more housekeeping infomation than using Filter Factory editor; and, also, the Manager allows for convenient decompilation of existing filters, so you can see the commands other people have used, and start with those.

Utilities and Filters              [TOP]