Change the angle/position of a drawing with a algorithm in Java

Try something like…

The demo is designed to allow images to be rotated through virtual angels (angles < 0 & > 360), but the basic concept is the same…

public class TestFlipImage {

    protected static final String IMAGE_PATH = "/path/to/your/image";

    public static void main(String[] args) {
        new TestFlipImage();
    }

    public TestFlipImage() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException ex) {
                } catch (InstantiationException ex) {
                } catch (IllegalAccessException ex) {
                } catch (UnsupportedLookAndFeelException ex) {
                }

                JFrame frame = new JFrame();
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setLayout(new BorderLayout());

                BufferedImage image = null;
                try {
                    image = ImageIO.read(new File(IMAGE_PATH));
                } catch (IOException ex) {
                }

                JPanel mainPane = new JPanel(new GridBagLayout());
                GridBagConstraints gbc = new GridBagConstraints();
                mainPane.add(new ImagePane(image, 0));
                mainPane.add(new ImagePane(image, 90));
                mainPane.add(new ImagePane(image, 180));

                frame.add(mainPane);
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class ImagePane extends JPanel {

        private BufferedImage masterImage;
        private BufferedImage renderedImage;

        public ImagePane(BufferedImage image, int angle) {
            masterImage = image;
            applyRotation(angle);
        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(renderedImage.getWidth(), renderedImage.getHeight());
        }

        @Override
        public Dimension getMinimumSize() {
            return getPreferredSize();
        }

        protected int getVirtualAngle(int angle) {
            float fRotations = (float) angle / 360f;
            int rotations = (int) (fRotations - (fRotations / 1000));

            int virtual = angle - (rotations * 360);

            if (virtual < 0) {
                virtual = 360 + virtual;
            }

            return virtual;
        }

        // The code is designed to rotate an image through 90 degree
        // angles, but it can handle angle's less then 0 and greater then
        // 360 degrees
        public void applyRotation(int angle) {
            // This will only work for angles of 90 degrees...

            // Normalize the angle to make sure it's only between 0-360 degrees
            int virtualAngle = getVirtualAngle(angle);
            Dimension size = new Dimension(masterImage.getWidth(), masterImage.getHeight());
            int masterWidth = masterImage.getWidth();
            int masterHeight = masterImage.getHeight();

            double x = 0; //masterWidth / 2.0;
            double y = 0; //masterHeight / 2.0;

            switch (virtualAngle) {
                case 0:
                    break;
                case 180:
                    break;
                case 90:
                case 270:
                    size = new Dimension(masterImage.getHeight(), masterImage.getWidth());
                    x = (masterHeight - masterWidth) / 2.0;
                    y = (masterWidth - masterHeight) / 2.0;
                    break;
            }
            renderedImage = new BufferedImage(size.width, size.height, masterImage.getTransparency());
            Graphics2D g2d = renderedImage.createGraphics();

            AffineTransform at = AffineTransform.getTranslateInstance(x, y);

            at.rotate(Math.toRadians(virtualAngle), masterWidth / 2.0, masterHeight / 2.0);
            g2d.drawImage(masterImage, at, null);

            g2d.dispose();
        }

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);

            Graphics2D g2d = (Graphics2D) g;
            int width = getWidth() - 1;
            int height = getHeight() - 1;

            int x = (width - renderedImage.getWidth()) / 2;
            int y = (height - renderedImage.getHeight()) / 2;

            g2d.drawImage(renderedImage, x, y, this);
        }
    }
}

Additional

You may also want to take a look at AffineTransform.rotate() – how do I xlate, rotate, and scale at the same time? wch discusses a means for flipping a image on its horizontal and vertical axis