Pixelle

Version 1.0.0 has just been released! Please report bugs or suggestions on the project pages.

The web start link should work, give it a try.

There are many image editing projects out there, and many are very good. But most of
these follow the point and click transformation style, and in some instances it can be
tedious to edit a bitmap if you have specific ways you want to change it. This tools works
differently. It allows you to apply arbitrary expressions to the red, green, blue, transparent
and selection pieces of a bitmap. Each expression can take as input the value of any other
value.

At the heart of this program is the transform dialog, shown here:

It shows five input fields for specifying how to transform
the red, green, blue and transparent parts of the bitmap, as well as the selection
attribute of each pixel. The default values for these algorithms is the value that will
produce an exact copy of the source image. In this way you can just change one field, or
all fields, and get what you expect. Each algorithm may include the following items.

p[x,y].r, p[x,y].g, p[x,y].b, p[x,y].t, p[x,y].s
The pixel value for the red, green, blue, transparency and selection at a
particular location.

x
The current x coordinate of the pixel location from left to right.

y
The current y coordinate of the pixel location from top to bottom.

width
The width in pixels of the image.

height
The height in pixels of the image.

abs(e)
The absolute value of an expression.

min(e, f)
The minimum value of two expressions.

max(e, f)
The maximum value of two expressions.

pow(e, f)
One expression raised to the second expression's power

sqrt(e)
The square root of an expression

sin(e)
The sine of an expression

cos(e)
The cosine of an expression

tan(e)
The tangent of an expression

asin(e)
The arc sine of an expression

acos(e)
The arc cosine of an expression

atan(e)
The arc tangent of an expression

log(e)
The log of an expression

exp(e)
The euler number (e) raised to an expression's power.

random(e)
A random number between 0 and 1

pi()
The number pi, the ratio of the circumference of a circle to its diameter

e()
The number e, the base of the natural logarithms

As of June 14, simple expressions should work. Some examples:
p[x,y].r = (x + y) == 100 ? 255 : p[x,y].r
This sets all red pixels to the same value as the input, except those pixels
that form a diagonal line where x + y == 100, and those pixes are converted to white.
p[x,y].r = p[x,y].g
This sets all the red pixels to the value of all the green pixels.
p[x,y].b = p[y,x].b
This rotates the blue component 90 degrees.
p[x,y].g = (p[x,y].g*3 + p[x+1,y].g + p[x,y+1].g)/5
This performs a simple convolution operation on the green pixels.
p[x,y].t = ((x == y) || (x == (width - y))) ? 0 : p[x,y].t
Sets the transparency to fully transparent in an x shape.
p[x,y].s = (p[x,y].r == p[x,y].g) || (p[x,y].r == p[x,y].b)
Sets the selection to any pixels where the red component equals either
the green or blue component.
p[x,y].b = (p[x,y].s || (p[x,y].r < p[x,y].g) ? 0 : 255
Sets the blue pixel to full blue if the pixel is selected or if the red component
is less than the green component, or else it sets it to black.

As of November 14, a pixel inspector window has been added, which helps determine input for the transformations

As of November 21, transformations can be done to grayscale. Prototypical example is color separations. Also
The output size can be specified in the transform dialog

As of February 18, multiple input sources can be processed. So
p[x,y].r = p(x/10)[x,y].r
Copies 10 pixel bands from a series of images into the destination
Note that if the value in the parenthesis is larger then the number of images,
the value is moded to fall into the appropriate range.

Still to be done is recognition of more image types, more options handling such as fractional pixels,
a bunch of bugs, and a bunch of stuff I have yet to think about.