Pixelle

Web Start

Thanks for your interest in 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.