Java Imaging on Pocket PC (Windows Mobile 2003)

Question

Hi all,
I've got a problem concerning imaging on a pocket pc (HP IPAQ with an Intel PXA270 CPU). I have to extend an existing SWT application written with J2ME Personal Profil and IBM J9 runtime. The thing is, that I have to implement a certain imaging functionallty, namely I have to implement a function where you can rotate gifs/jpg images an arbitrary amount of grades around their center. After extensive searching I couldn't spot a java extension wich would include pocket pc support to do this rapidly.
So I tried to do it "by hand", which means pixel by pixel (see attached code).
But the problem I got now is a very weak performance. The rotation itself of a 600x600 gif consumes about 5800 ms which is definitly to heigh for the purpose I want to use it for. My questions now are:
- Is there any imaging extension for java which I could use for this puropse on the pocket pc
- If not: How could I improve the performance of the rotation function?
I'd be very thankful for any tips & hints.
static ImageData rotateFull(ImageData srcData, int grad) {
          int diagonal =
               (int) Math.sqrt(
                    (srcData.width * srcData.width)
                         + (srcData.height * srcData.height));
          ImageData destData =
               new ImageData(diagonal, diagonal, srcData.depth, srcData.palette);
          int x_adj, y_adj, x_new, y_new, pixel_data;
          int corrX = srcData.width / 2;
          int corrY = srcData.height / 2;
          int pixels = srcData.height * srcData.width;
          double bogen = (grad * Math.PI) / 180;
          float cos_winkel = (float) Math.cos(bogen);
          float sin_winkel = (float) Math.sin(bogen);
          for (int y = 0; y < (srcData.height); y++) {
               for (int x = 0; x < (srcData.width); x++) {
                    x_adj = x - corrX;
                    y_adj = y - corrY;
                    x_new = (int) ((x_adj * cos_winkel) - (y_adj * sin_winkel));
                    y_new = (int) ((x_adj * sin_winkel) + (y_adj * cos_winkel));
                    pixel_data = srcData.getPixel(x, y);
                    destData.setPixel(
                         x_new + (destData.width / 2),
                         y_new + (destData.height / 2),
                         pixel_data);
          return destData;
     }

Answer 1

Fellow regulars, please forgive the zombie thread: it's referenced in another thread, and it seemed the best place to put the following code.
I've shown a number of intermediate steps en route to the best solution I can be bothered to post, which is the last of the rotate* methods. The next step, which would eliminate almost 4*sqrt(width*width+height*height) divisions, is to use Bresenham's line-drawing algorithm to work out the edges and then interpolate between them. However, to be frank, I couldn't be bothered. That's a lot of work, and probably means splitting the code into 9+ cases.
One further optimisation which might be worth considering is to use the AWT ImageConsumer/ImageProducer model rather than SWT images. That would eliminate the awkward boxing/unboxing of the rasters, which is probably responsible for at least 10% of the time taken by rotateArray and subsequent.
Profiling is always tricky. Comparing rotateTrueclip against rotateFull using different methods I measure it as taking as much as 133% of the time, or as little as 1%. The Bresenham version would certainly be faster than rotateTrueclip.
I hope this proves useful both as code in its own right and as an example of some optimisation techniques.
import org.eclipse.swt.events.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.widgets.*;
public class RotationSandbox {
    private static final Display display=new Display();
    private final String title;
    private final Image image;
    public RotationSandbox(String title, Image image) {
        this.title=title;
        this.image=image;
    public RotationSandbox(String title, ImageData imagedata) {
        this(title, new Image(display,imagedata));
    public void run() {
        final Shell shell = new Shell(display);
        shell.addPaintListener(new PaintListener() {
            public void paintControl(PaintEvent event) {
                // Draw the untainted image
                event.gc.drawImage(image, 0, 0);
        shell.setText(title);
        shell.setSize(image.getImageData().width+20, image.getImageData().height+30);
        shell.open();
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch()) {
                display.sleep();
        image.dispose();
        display.dispose();
    static ImageData rotateFull(ImageData srcData, int grad) {
        int diagonal =
            (int) Math.sqrt(
                (srcData.width * srcData.width)
                    + (srcData.height * srcData.height));
        ImageData destData =
            new ImageData(diagonal, diagonal, srcData.depth, srcData.palette);
        int x_adj, y_adj, x_new, y_new, pixel_data;
        int corrX = srcData.width / 2;
        int corrY = srcData.height / 2;
        int pixels = srcData.height * srcData.width;
        double bogen = (grad * Math.PI) / 180;
        float cos_winkel = (float) Math.cos(bogen);
        float sin_winkel = (float) Math.sin(bogen);
        for (int y = 0; y < (srcData.height); y++) {
            for (int x = 0; x < (srcData.width); x++) {
                x_adj = x - corrX;
                y_adj = y - corrY;
                x_new = (int) ((x_adj * cos_winkel) - (y_adj * sin_winkel));
                y_new = (int) ((x_adj * sin_winkel) + (y_adj * cos_winkel));
                pixel_data = srcData.getPixel(x, y);
                destData.setPixel(
                    x_new + (destData.width / 2),
                    y_new + (destData.height / 2),
                    pixel_data);
        return destData;
    // First change: iterate over destination pixels rather than source pixels.
    static ImageData rotateDest(ImageData srcData, int theta_deg) {
        int diagonal =
            (int) Math.sqrt(
                (srcData.width * srcData.width)
                    + (srcData.height * srcData.height));
        ImageData destData =
            new ImageData(diagonal, diagonal, srcData.depth, srcData.palette);
        final int corrX = srcData.width / 2;
        final int corrY = srcData.height / 2;
        double bogen = (theta_deg * Math.PI) / 180;
        final float cos_winkel = (float) Math.cos(bogen);
        final float sin_winkel = (float) Math.sin(bogen);
        final int half_diag=diagonal>>1;
        for (int y=0; y<diagonal; y++) {
            for (int x=0; x<diagonal; x++) {
                int x_new=x-half_diag, y_new=y-half_diag;
                int x_adj=(int) ((x_new * cos_winkel) + (y_new * sin_winkel));
                int y_adj=(int) (-(x_new * sin_winkel) + (y_new * cos_winkel));
                int x_old=x_adj+corrX, y_old=y_adj+corrY;
                if (x_old>=0 && y_old>=0 && x_old<srcData.width && y_old<srcData.height) {
                    destData.setPixel(x,y,srcData.getPixel(x_old,y_old));
        return destData;
    // Second change: replace multiplications with additions.
    static ImageData rotateIter(ImageData srcData, int theta_deg) {
        int diagonal =
            (int) Math.sqrt(
                (srcData.width * srcData.width)
                    + (srcData.height * srcData.height));
        ImageData destData =
            new ImageData(diagonal, diagonal, srcData.depth, srcData.palette);
        final int corrX = srcData.width / 2;
        final int corrY = srcData.height / 2;
        double bogen = (theta_deg * Math.PI) / 180;
        final float cos_winkel = (float) Math.cos(bogen);
        final float sin_winkel = (float) Math.sin(bogen);
        final int half_diag=diagonal>>1;
        for (int y=0; y<diagonal; y++) {
            float x_adj=-half_diag*cos_winkel + (y-half_diag)*sin_winkel + corrX;
            float y_adj=half_diag*sin_winkel + (y-half_diag)*cos_winkel + corrY;
            for (int x=0; x<diagonal; x++) {
                int x_old=(int)x_adj, y_old=(int)y_adj;
                if (x_old>=0 && y_old>=0 && x_old<srcData.width && y_old<srcData.height) {
                    destData.setPixel(x,y,srcData.getPixel(x_old,y_old));
                x_adj+=cos_winkel; y_adj-=sin_winkel;
        return destData;
    // Third change: eliminate those virtual method calls in favour of direct array indexing.
    static ImageData rotateArray(ImageData srcData, int theta_deg) {
        int diagonal =
            (int) Math.sqrt(
                (srcData.width * srcData.width)
                    + (srcData.height * srcData.height));
        ImageData destData =
            new ImageData(diagonal, diagonal, srcData.depth, srcData.palette);
        final int corrX = srcData.width / 2;
        final int corrY = srcData.height / 2;
        double bogen = (theta_deg * Math.PI) / 180;
        final float cos_winkel = (float) Math.cos(bogen);
        final float sin_winkel = (float) Math.sin(bogen);
        final int half_diag=diagonal>>1;
        int[] src_raster=new int[srcData.width*srcData.height];
        srcData.getPixels(0,0,src_raster.length,src_raster,0);
        int[] dst_raster=new int[diagonal*diagonal];
        for (int y=0; y<diagonal; y++) {
            float x_adj=-half_diag*cos_winkel + (y-half_diag)*sin_winkel + corrX;
            float y_adj=half_diag*sin_winkel + (y-half_diag)*cos_winkel + corrY;
            for (int x=0; x<diagonal; x++) {
                int x_old=(int)x_adj, y_old=(int)y_adj;
                if (x_old>=0 && y_old>=0 && x_old<srcData.width && y_old<srcData.height) {
                    dst_raster[x+y*diagonal]=src_raster[x_old+y_old*srcData.width];
                x_adj+=cos_winkel; y_adj-=sin_winkel;
        destData.setPixels(0,0,dst_raster.length,dst_raster,0);
        return destData;
    // Fourth change: use fixed-point rather than floating-point.
    static ImageData rotateFixpoint(ImageData srcData, int theta_deg) {
        int diagonal =
            (int) Math.sqrt(
                (srcData.width * srcData.width)
                    + (srcData.height * srcData.height));
        ImageData destData =
            new ImageData(diagonal, diagonal, srcData.depth, srcData.palette);
        final int corrX = srcData.width / 2;
        final int corrY = srcData.height / 2;
        double bogen = (theta_deg * Math.PI) / 180;
        final int cos=(int)(65536*Math.cos(bogen));
        final int sin=(int)(65536*Math.sin(bogen));
        final int half_diag=diagonal>>1;
        int[] src_raster=new int[srcData.width*srcData.height];
        srcData.getPixels(0,0,src_raster.length,src_raster,0);
        int[] dst_raster=new int[diagonal*diagonal];
        for (int y=0; y<diagonal; y++) {
            int x_adj=-half_diag*cos + (y-half_diag)*sin + (corrX<<16);
            int y_adj=half_diag*sin + (y-half_diag)*cos + (corrY<<16);
            for (int x=0; x<diagonal; x++) {
                int x_old=x_adj>>16, y_old=y_adj>>16;
                if (x_old>=0 && y_old>=0 && x_old<srcData.width && y_old<srcData.height) {
                    dst_raster[x+y*diagonal]=src_raster[x_old+y_old*srcData.width];
                x_adj+=cos; y_adj-=sin;
        destData.setPixels(0,0,dst_raster.length,dst_raster,0);
        return destData;
    // Fifth change: only iterate over the box we care about.
    // I've also done some incrementalising immediately, rather than defer to the
    // next version.
    static ImageData rotateTrueclip(ImageData srcData, int theta_deg) {
        int diagonal =
            (int) Math.sqrt(
                (srcData.width * srcData.width)
                    + (srcData.height * srcData.height));
        ImageData destData =
            new ImageData(diagonal, diagonal, srcData.depth, srcData.palette);
        final int corrX = srcData.width / 2;
        final int corrY = srcData.height / 2;
        double bogen = (theta_deg * Math.PI) / 180;
        final int cos=(int)(65536*Math.cos(bogen));
        final int sin=(int)(65536*Math.sin(bogen));
        final int half_diag=diagonal>>1;
        final int wfix=srcData.width<<16, hfix=srcData.height<<16;
        int[] src_raster=new int[srcData.width*srcData.height];
        srcData.getPixels(0,0,src_raster.length,src_raster,0);
        int[] dst_raster=new int[diagonal*diagonal];
        int x_start=-half_diag*(cos+sin)+(corrX<<16)-sin;
        int x_end=x_start+diagonal*cos;
        int y_start=half_diag*(sin-cos)+(corrY<<16)-cos;
        for (int y=0; y<diagonal; y++) {
            x_start+=sin; x_end+=sin;
            y_start+=cos;
            int dxs=0, dxe=diagonal;
            // Clip to keep source x-coords in range.
            if (cos>0) {
                if (x_start<0) dxs=(cos-1-x_start)/cos;
                if (x_end>=wfix+cos) dxe=(wfix-x_start+cos-1)/cos;
            else if (cos<0) {
                if (x_end<cos) dxe=(cos-x_start-cos+1)/cos;
                if (x_start>=wfix) dxs=(wfix-x_start+cos-1)/cos;
            else if (x_start<0 || x_start>=wfix) continue;
            // Clip to keep src y-coords in range, taking into account the
            // changes already made to dxs and dxe.
            int y_adj=y_start-dxs*sin;
            final int y_end=y_start-dxe*sin;
            if (sin>0) {
                if (y_end<-sin) dxe=(y_start+sin)/sin;
                if (y_adj>=hfix) {
                    dxs=(-hfix+y_start+sin+1)/sin;
                    y_adj=y_start-dxs*sin;
            else if (sin<0) {
                if (y_adj<0) {
                    dxs=(y_start+sin-1)/sin;
                    y_adj=y_start-dxs*sin;
                if (y_end>=hfix-sin) dxe=(y_start-hfix+sin+1)/sin;
            else if (y_start<0 || y_start>=hfix) continue;
            int x_adj=x_start+dxs*cos;
            int doff=dxs+y*diagonal;
            for (int x=dxs; x<dxe; x++) {
                int x_old=x_adj>>16, y_old=y_adj>>16;
                dst_raster[doff++]=src_raster[x_old+y_old*srcData.width];
                x_adj+=cos; y_adj-=sin;
        destData.setPixels(0,0,dst_raster.length,dst_raster,0);
        return destData;
    public static void main(String[] args) {
        ImageData orig=new ImageData(100,100,32,new PaletteData(0xff0000,0xff00,0xff));
        int[] raster=new int[100*100];
        int roff=0, col=0;
        for (int y=0; y<100; y++) {
            for (int x=0; x<100; x++) {
                raster[roff++]=col;
                col+=(1<<16);
            col=(col&0xff)+1;
        orig.setPixels(0,0,raster.length,raster,0);
        // For some reason I don't understand, not knowing SWT, I only appear able to
        // make one Display and one Shell per Display.
//        new RotationSandbox("Original image",orig).run();
//         ImageData dasu_rotate=rotateFull(orig,45);
//         new RotationSandbox("Rotated with dasu's code",dasu_rotate).run();
//         ImageData rotate_dest=rotateDest(orig,45);
//         new RotationSandbox("Rotated iterating over dest pixels",rotate_dest).run();
//         ImageData rotate_iter=rotateIter(orig,45);
//         new RotationSandbox("Mul -> add",rotate_iter).run();
//         ImageData rotate_array=rotateArray(orig,45);
//         new RotationSandbox("Use raster arrays",rotate_array).run();
//         ImageData rotate_fixpoint=rotateFixpoint(orig,45);
//         new RotationSandbox("Use fixpoint arithmetic",rotate_fixpoint).run();
        ImageData rotate_trueclip=rotateTrueclip(orig,45);
        new RotationSandbox("Clip to rotated bounding box",rotate_trueclip).run();
}