Problem with very slow scale, rotate and translate

Question

Hi -
Here is the basic problem. I want to take a bufferedImage (read from a jpeg earlier on) and then rotate it according to an angle value (radians) and then resize it to fit within a specifically sized box. My code works fine, but... I have to do this in a loop up to 200 times. The process is often taking several minutes to complete. If this is simply a consequence of what I am trying to do, then I'll accept that, but surely I am just doing something wrong? Please help!
Thanks - here is the (working but very slow) code
    public Graphics2D get_shape_image(Graphics2D g, BufferedImage b, double shaperotation, double space_width, double space_height,
            float x_scale_factor, float y_scale_factor, float shapeTransparency){
        // Work out the boundimg box size of the rotated image
        double imageWidth = (double) b.getWidth();
        double imageHeight = (double) b.getHeight();
        double cos = Math.abs( Math.cos(shaperotation));
        double sin = Math.abs( Math.sin(shaperotation));
        int new_width = (int) Math.floor(imageWidth * cos  +  imageHeight * sin);
        int new_height = (int) Math.floor(imageHeight * cos  +  imageWidth * sin);
        // Create the new bufferedImage of the right size
        BufferedImage transformed = new BufferedImage((int) new_width, (int) new_height, BufferedImage.TYPE_INT_RGB);
        // Create the transform and associated AffineTransformOperation
        AffineTransform at = new AffineTransform();
        AffineTransformOp affine_op;
        // Make sure our image to be rotated is in the middle of the new image
        double x_movement = ((double) (new_width / 2.0d)) - ((double) imageWidth / 2.0d);
        double y_movement = ((double) (new_height / 2.0d)) - ((double) imageHeight / 2.0d);
        at.setToTranslation(x_movement, y_movement);
        affine_op = new AffineTransformOp(at, AffineTransformOp.TYPE_BILINEAR);
        transformed = affine_op.filter(b, null);
        // Now we need to rotate the image according to the input rotation angle
        BufferedImage rotated = new BufferedImage((int) new_width, (int) new_height, BufferedImage.TYPE_INT_RGB);
        at.setToRotation(shaperotation, (double) new_width / 2.0d, new_height / 2.0d);
        affine_op = new AffineTransformOp(at, AffineTransformOp.TYPE_BILINEAR);
        rotated = affine_op.filter(transformed, null);
        // Do the scaling so that we fit into the grid sizes
        BufferedImage sizedImage = new BufferedImage((int) (space_width * x_scale_factor), (int) (space_height * y_scale_factor), BufferedImage.TYPE_INT_RGB);
        double xScale = (double) (space_width * x_scale_factor) / (double) new_width;
        double yScale = (double) (space_height * y_scale_factor) / (double) new_height;
        at.setToScale(xScale, yScale);
        affine_op = new AffineTransformOp(at, AffineTransformOp.TYPE_BILINEAR);
        sizedImage = affine_op.filter(rotated, null);
        // Finally translate the image to the correct position after scaling
        double x_adjust = (space_width / 2.0d) - ((space_width * x_scale_factor) / 2.0d);
        double y_adjust = (space_height / 2.0d) - ((space_height * y_scale_factor) / 2.0d);
        // Set the transparency
        AlphaComposite ac = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, shapeTransparency);
        g.setComposite(ac);
        // Draw the image as long as it's above 0 size
        if (sizedImage.getWidth() > 0 && sizedImage.getHeight() > 0)
            g.drawImage(sizedImage, null, (int) x_adjust, (int) y_adjust);
        return g;
    }

Answer 1

Your code worked okay in my system: busy at 200fps using 1.0f for alpha and
the x/y scale_factor values.
Here's another approach that isn't quite as busy.
import java.awt.*;
import java.awt.geom.*;
import java.awt.image.BufferedImage;
import java.io.*;
import javax.imageio.ImageIO;
import javax.swing.*;
public class XTest extends JPanel
    BufferedImage image;
    int gridWidth  = 100;
    int gridHeight = 100;
    double theta   = 0;
    double thetaInc;
    public XTest(BufferedImage image)
        this.image = image;
        thetaInc = Math.toRadians(1);
    protected void paintComponent(Graphics g)
        super.paintComponent(g);
        Graphics2D g2 = (Graphics2D)g;
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                            RenderingHints.VALUE_ANTIALIAS_ON);
        g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
                            RenderingHints.VALUE_INTERPOLATION_BICUBIC);
        int w = getWidth();
        int h = getHeight();
        int imageW = image.getWidth();
        int imageH = image.getHeight();
        // rather than making a new BufferedImage for each step of
        // the rotation and scaling let's try to rotate, scale and
        // fit the source image directly into the grid by using
        // transforms...
        // rotation
        AffineTransform rotateXform = new AffineTransform();
        double x = (w - imageW)/2;
        double y = (h - imageH)/2;
        rotateXform.setToTranslation(x,y);
        rotateXform.rotate(theta, imageW/2.0, imageH/2.0);
        // get rotated size for source
        double cos = Math.abs( Math.cos(theta));
        double sin = Math.abs( Math.sin(theta));
        double rw = Math.rint(imageW * cos  +  imageH * sin);
        double rh = Math.rint(imageH * cos  +  imageW * sin);
        // scale factors to fit image into grid
        double xScale = gridWidth /  rw;
        double yScale = gridHeight / rh;
        // scale from center
        x = (1.0 - xScale)*w/2;
        y = (1.0 - yScale)*h/2;
        AffineTransform scaleXform = AffineTransform.getTranslateInstance(x,y);
        scaleXform.scale(xScale, yScale);
        scaleXform.concatenate(rotateXform);
        g2.drawRenderedImage(image, scaleXform);
        // markers
        // grid
        g2.setPaint(Color.red);
        int gx = (w - gridWidth)/2;
        int gy = (h - gridHeight)/2;
        g2.drawRect(gx, gy, gridWidth, gridHeight);
        // bounds of unscaled, rotated source image
        g2.setPaint(Color.blue);
        double rx = (w - rw)/2;
        double ry = (h - rh)/2;
        g2.draw(new Rectangle2D.Double(rx, ry, rw, rh));
    public void rotate()
        theta += thetaInc;
        repaint();
    public static void main(String[] args) throws IOException
        BufferedImage bi = ImageIO.read(new File("images/bclynx.jpg"));
        XTest test = new XTest(bi);
        Activator activator = new Activator(test);
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setContentPane(test);
        f.setSize(400,400);
        f.setLocation(200,200);
        f.setVisible(true);
        activator.start();
class Activator implements Runnable
    XTest xTest;
    Thread thread;
    boolean animate;
    public Activator(XTest xt)
        xTest = xt;
        animate = false;
    public void run()
        while(animate)
            try
                Thread.sleep(50);
            catch(InterruptedException ie)
                animate = false;
                System.out.println("interrupt");
            xTest.rotate();
    public void start()
        if(!animate)
            animate = true;
            thread = new Thread(this);
            thread.setPriority(Thread.NORM_PRIORITY);
            thread.start();
    public void stop()
        animate = false;
        thread = null;
}