2   2
pixel(x,y)= base+ k ( sum sum pixel(x+k-1,y+l-1)*matrix(k,l) )
k=0 l=0

1/k is sum of matrix, or sum of matrix multiplied with div. base is given by r,g,b and is normally black.

blur (ie a 2d gauss function): ({({1,2,1}), ({2,5,2}), ({1,2,1})})
		original
sharpen (k>8, preferably 12 or 16): ({({-1,-1,-1}), ({-1, k,-1}), ({-1,-1,-1})})
edge detect: ({({1, 1,1}), ({1,-8,1}), ({1, 1,1})})
horisontal edge detect (get the idea): ({({0, 0,0}), ({1,-2,1}), ({0, 0,0})})
emboss (might prefer to begin with a grey image): ({({2, 1, 0}), ({1, 0,-1}), ({0,-1,-2})}), 128,128,128, 3
		greyed

This function is not very fast.

This function is not very fast.

average() and sumf() may also wrap, but on a line basis. (Meaning, be careful with images that are wider than 8425104 pixels.) These functions may have a precision problem instead, during to limits in the 'double' C type and/or 'float' Pike type.

original	->box(40,10,10,80,0,255,0)

original	->circle(50,50,30,50,0,255,255)

Method for scaling is rather complex; the image is transformed via a cosine transform, and then resampled back.

This gives a quality-conserving upscale, but the algorithm used is n*n+n*m, where n and m is pixels in the original and new image.

Recommended wrapping algorithm is to scale overlapping parts of the image-to-be-scaled.

This functionality is actually added as an true experiment, but works...

It write's dots on stderr, to indicate some sort of progress. It doesn't use any fct (compare: fft) algorithms.

When converting to RGB, the input data is asumed to be placed in the pixels as above.

original	->hsv_to_rgb();	->rgb_to_hsv();
tuned box (below)	the rainbow (below)	same, but rgb_to_hsv()

HSV to RGB calculation:

in = input pixel
out = destination pixel
h=-pos*c_angle*3.1415/(float)NUM_SQUARES;
out.r=(in.b+in.g*cos(in.r));
out.g=(in.b+in.g*cos(in.r + pi*2/3));
out.b=(in.b+in.g*cos(in.r + pi*4/3));

RGB to HSV calculation: Hmm.

Example: Nice rainbow.

object i = Image.Image(200,200);
i = i->tuned_box(0,0, 200,200,
({ ({ 255,255,128 }), ({ 0,255,128 }),
({ 255,255,255 }), ({ 0,255,255 })}))
->hsv_to_rgb();

original	->invert();	->rgb_to_hsv()->invert()->hsv_to_rgb();

original	->line(50,10,10,50,255,0,0)

Replacement examples:

Old code:

img=map_fs(img->select_colors(200));

img=Image.Colortable(img,200)->floyd_steinberg()->map(img);

Old code:

img=map_closest(img->select_colors(17)+({({255,255,255}),({0,0,0})}));

img=Image.Colortable(img,19,({({255,255,255}),({0,0,0})}))->map(img);

Default is to paint above, below, to the left and the right of these pixels.

You can also run your own outline mask.

The outline_mask function gives the calculated outline as an alpha channel image of white and black instead.

original	masked through threshold	...and outlined with red

phaseh gives an image where

max  falling   min  rising
value=  0     64      128   192

0 is set if there is no way to determine if it is rising or falling. This is done for the every red, green and blue part of the image.

Phase images can be used to create ugly effects or to find meta-information in the orginal image.

original	phaseh()	phasev()	phasevh()	phasehv()

The string is nullpadded or cut to fit.

original	->rotate_ccw();

original	->rotate_cw();

original	->skewx(15,255,0,0);	->skewx_expand(15);

original	->skewy(15,255,0,0);	->skewy_expand(15);

The "expand" variant of functions stretches the image border pixels rather then filling with the given or current color.

Tuning function is (1.0-x/xw)*(1.0-y/yw) where x and y is the distance to the corner and xw and yw are the sides of the rectangle.

original	tuned box	solid tuning (blue,red,green,yellow)	tuning transparency (as left + 255,128,128,0)