Sprite Rotation Utility

Making rotated versions of sprites is usually a pain in the ass, because most programs that rotate a sprite will antialias it (which blurs it and messes with the colors) and ones that don't antialias it tend to do a poor job of preserving features of the original image. It usually takes a lot of manual touch-up work to make the rotated sprite look good. (If you didn't know already, the walking and running frames in Sonic 1, 2, and 3 all need 45 degree rotated equivalents, and I believe those were custom-drawn by the artists at Sega for lack of any good way of generating them)

So I wrote a little utility to avoid those problems: It can rotate sprites at arbitrary angles without antialiasing and (IMHO) without making them look demented. I call it rotsprite because I suck at inventing names and don't care. It attempts to preserve lines and (to some extent) curves in the original image, it never mixes colors together, and it considers multiple rotation offsets to minimize error. It can optionally scale up or down while rotating.

It isn't perfect; it minimizes error by a very simple method, but won't try to intelligently recognize and eliminate oddities like a human could. Other, simpler methods may do better for certain parts of the image, but rotsprite output should require much less touch-up work overall. It works best on small images, so the quality of rotation can suffer if you place many sprites in an image and rotate the whole image instead of rotating them separately. Dithering (fine-grained checkerboard patterns) can confuse it because it tries to rotate the pattern itself without considering it a single color, so if you need to rotate something dithered I suggest replacing the dithered parts with solid blended colors before rotation, and replacing those colors with the dithering pattern after rotation.

The program asks for input when you open it, should be self-explanitory. To use it as a commandline utility, here are the flags:
rotsprite -in "input.png" -out "output.bmp" -angle 22.5 -endangle 180 -scale 1.0 -endscale 1.0 -frames 8

Now for some sample output:
Creating angled frames for an animation without them:


Comparing automatically rotated sprites with Sega's actual final rotated sprites:


More comparison between regular aliased rotation and this program's output:


Fun with upscaling and rotation:


Making a silly animation (64 rotation angles):


If you missed the download link here it is again: http://www.fileden.com/files/2006/12/3/457443/rotsprite.zip

 

I'm glad people are finding this useful and motivating; hopefully someone will put this to better use than I can.

BTW, even though the main feature is rotation, the scaling is decent compared to point sampling. It's handy if you have some sprites you want to use but they're the wrong size for the game:



The angled ones were made by scaling and rotating at the same time. It looks worse if you rotate and scale separately, so... don't do that. For comparison, here's what normal point sampling/rotation gives:

 

The algorithm is dead simple, so I'll just describe it and you can decide: First it scales the image to 8x size, using a "pixel guessing" algorithm to add detail. Then it scales the image to 1/8 size and also rotates it using standard aliased rotation and scaling. That's basically it. To get a big speed increase for a small penalty in quality, you could use 4x instead of 8x and skip some other optional steps I did, but I wanted high quality above all else.

Here's the more detailed version: First it scales the image to double size using something similar to Scale2x, but checking if pixels are more similar to each other instead of if they're equal, which makes the result less blocky and ultimately leads to smoother output. The important thing is that the scaling algorithm works by choosing a pixel instead of by blending pixels. It does that 3 times to achieve an 8x scale, determined empirically to be a good place to stop. Then (optional step) it tries to find the best rotation offsets by looping through a small grid of offsets between 0 and 7 pixels in x and y, and for each one looping through the 8x image at the rotation angle with step size 8 pixels, and adding the squared distance of the difference in color components between each point and its immediate (1 pixel) neighbors in the 8x image, which will be 0 except on the boundaries between 8x pixels. Then it simply performs standard nearest-neighbor scaling+rotation, starting at the offsets that gave minimal sum of squared differences, and using 1/8 scale to return the image to normal size while rotating it. Finally (optional step), it tries to fix any overlooked single-pixel details by checking for any pixels in the output image that have 3 or 4 identical neighbors equal to them and unequal to the color at the corresponding place in the source image, and replacing those pixels with the one from the source image.

You might say I'm cheating by not vectorizing the graphics into lines and curves and rotating those, but I say this method is an approximation of that and works better in practice. When the original image has little detail at the angle it's being sampled, aliased rotation makes too many arbitrary decisions, but the smoothing of a pixel-choosing enlargement algorithm is sufficient to resolve most of the ambiguity.