How to save rotated image?

Question

i am developing an application in which user load image can scale it, also can save it. can also rotate image through menu item click rotate.

on click rotate one other frame opens and the last positioned or last scaled image load into rotate panel. now when user click on rotate option then image should be saved in that position but it is not done.

if anyone knows it then please help me. i have made 2 files 1. load image and save image that is ScaleIMG and 2. to rotate image that is RotateIMGn.

ScaleIMG.java

package logic;


import logic.RotateIMGn;

public class ScaleIMG extends JFrame {

    private static final long serialVersionUID = 1L;

    public static int widthx,heightx;
    public static String passpath;

    public static void main(String[] args) 
    {       
        new ScaleIMG().run();       
    }
    public void run() 
    {
        try {

            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());                    
            ScaleIMG frame1 = new ScaleIMG();
            frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame1.getContentPane().setLayout(new BorderLayout());
            frame1.getContentPane().add(new ViewPane());
            frame1.pack();

            frame1.setLocationRelativeTo(null);
            frame1.setVisible(true);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public ScaleIMG() {     

        final ImagePane s = new ImagePane();
        setTitle("Keyur");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 500, 300);

        JMenuBar menuBar = new JMenuBar();
        setJMenuBar(menuBar);

        JMenu mnFile = new JMenu("File");
        menuBar.add(mnFile);

        JMenuItem mntmLoadImage = new JMenuItem("Load Image");
        mnFile.add(mntmLoadImage);

        JMenuItem mntmSaveImage = new JMenuItem("Save Image");

        mntmSaveImage.addActionListener(new ActionListener()
        {
            @Override 
            public void actionPerformed (ActionEvent e) 
            {
                try 
                {
                    s.save("D:\\Workspace\\ScaleImage\\src\\images", "scaled_img_");
                } catch (IOException e1) 
                {

                    e1.printStackTrace();
                }
            }
        });     

        mnFile.add(mntmSaveImage);

        JSeparator separator = new JSeparator();
        mnFile.add(separator);

        JMenuItem mntmExit = new JMenuItem("Exit");
        mnFile.add(mntmExit);

        JMenu mnEdit = new JMenu("Edit");
        menuBar.add(mnEdit);

        JMenuItem mntmIncreaseBright = new JMenuItem("Increase Bright");
        mnEdit.add(mntmIncreaseBright);

        JMenuItem mntmDecreaseBright = new JMenuItem("Decrease Bright");
        mnEdit.add(mntmDecreaseBright);

        JSeparator separator_1 = new JSeparator();
        mnEdit.add(separator_1);

        JMenuItem mntmRestoreImage = new JMenuItem("Restore Image");
        mnEdit.add(mntmRestoreImage);

        JMenuItem mntmRotateImage = new JMenuItem("Rotate Image");
        mnEdit.add(mntmRotateImage);

        mntmRotateImage.addActionListener(new ActionListener() {
            @Override 
            public void actionPerformed (ActionEvent e) 
            {

                System.out.println(widthx);
                System.out.println(heightx);
                try 
                {
                     s.save("D:\\Workspace\\ScaleImage\\src\\images", "scaled_img_");
                     RotateIMGn rm = new RotateIMGn(passpath);
                     JFrame frame = new JFrame();  
                     frame.setContentPane(rm);  
                     frame.pack();  
                     frame.setVisible(true);  
                } catch (IOException e1)
                {

                    e1.printStackTrace();
                }              
            }
        });

        JMenu mnHelp = new JMenu("Help");
        menuBar.add(mnHelp);

        JMenuItem mntmHelpCtrl = new JMenuItem("Help ctrl + K");
        mnHelp.add(mntmHelpCtrl);

        JMenuItem mntmAboutImageEditor = new JMenuItem("About Image Editor");
        mnHelp.add(mntmAboutImageEditor);

        JSeparator separator_2 = new JSeparator();
        mnHelp.add(separator_2);

        JMenuItem mntmAboutCompany = new JMenuItem("About Company");
        mnHelp.add(mntmAboutCompany);

    }

    public class ViewPane extends JPanel {

        private static final long serialVersionUID = 1L;

        public ViewPane() {
            setLayout(null);
            ImagePane imagePane = new ImagePane();
            imagePane.setSize(imagePane.getPreferredSize());
            imagePane.setLocation(0, 0);
            add(imagePane);
        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(1200, 665);
        }

    }

    public static class ImagePane extends JPanel {

        private static final long serialVersionUID = 1L;
        private BufferedImage bg;
        private BufferedImage scaled;

        public String pathpass1;
        public String namepass1;

        public ImagePane() {
            try {
                bg = ImageIO.read(getClass().getResource("/images/src11.jpg"));

                pathpass1="D:\\Workspace\\ScaleImage\\src\\images";
                namepass1="src11.jpg";
                scaled = getScaledInstanceToFit(bg, new Dimension(600, 600));
            } catch (IOException ex) {
                ex.printStackTrace();
            }         

            setBackground(Color.BLACK);

            MouseHandler handler = new MouseHandler();
            addMouseListener(handler);
            addMouseMotionListener(handler);           
        }      

        public void save(String path, String name) throws IOException 
        {
            BufferedImage bf = new BufferedImage(widthx, heightx, BufferedImage.TYPE_INT_RGB);
            Graphics gg = bf.getGraphics();         
            gg.drawImage(scaled,0,0,widthx,heightx,null);       

            System.out.println(widthx);
            System.out.println(heightx);

             String s = "/images/src11.jpg";

             String sub = s.substring(s.lastIndexOf("/")+1);
             System.out.println(sub);

            if (bf != null) 
            {  
                name += bf.getWidth() + "x" + bf.getHeight();
                ImageIO.write(bf, "jpg", new File(path + File.separator + name + ".jpg"));
                passpath = path+File.separator+name+".jpg";

                pathpass1 =path;
                namepass1=sub;
                System.out.println(pathpass1);
            } 
            else 
            {
                throw new NullPointerException("Scaled instance is null");
            }
        }
        @Override
        public Dimension getPreferredSize() {
            return bg == null ? new Dimension(200, 200) : new Dimension(scaled.getWidth(), scaled.getHeight());
        }

        @Override
        public void invalidate() {
            super.invalidate();
            scaled = getScaledInstanceToFit(bg, getSize());
        }

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();
            int x = (getWidth() - scaled.getWidth()) / 2;
            int y = (getHeight() - scaled.getHeight()) / 2;
            g2d.drawImage(scaled, x, y, this);
            g2d.dispose();
        }

        public enum MouseAction {

            Move(Cursor.getPredefinedCursor(Cursor.MOVE_CURSOR)),
            ResizeSouth(Cursor.getPredefinedCursor(Cursor.S_RESIZE_CURSOR)),
            ResizeNorth(Cursor.getPredefinedCursor(Cursor.N_RESIZE_CURSOR)),
            ResizeEast(Cursor.getPredefinedCursor(Cursor.E_RESIZE_CURSOR)),
            ResizeWest(Cursor.getPredefinedCursor(Cursor.W_RESIZE_CURSOR)),
            ResizeNorthEast(Cursor.getPredefinedCursor(Cursor.NE_RESIZE_CURSOR)),
            ResizeNorthWest(Cursor.getPredefinedCursor(Cursor.NW_RESIZE_CURSOR)),
            ResizeSouthEast(Cursor.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR)),
            ResizeSouthWest(Cursor.getPredefinedCursor(Cursor.SW_RESIZE_CURSOR));

            private Cursor cursor;

            private MouseAction(Cursor cursor) {
                this.cursor = cursor;
            }

            public Cursor getCursor() {
                return cursor;
            }
        }

        public class MouseHandler extends MouseAdapter {

            private MouseAction action;
            private Point clickPoint;
            private boolean ignoreMoves;

            protected void updateAction(MouseEvent e) {
                int x = e.getX();
                int y = e.getY();

                int width = getWidth();
                int height = getHeight();

                if (x < 10 && y < 10) {
                    action = MouseAction.ResizeNorthWest;
                } else if (x > width - 10 && y < 10) {
                    action = MouseAction.ResizeNorthWest;
                } else if (y < 10) {
                    action = MouseAction.ResizeNorth;
                } else if (x < 10 && y > height - 10) {
                    action = MouseAction.ResizeSouthWest;
                } else if (x > width - 10 && y > height - 10) {
                    action = MouseAction.ResizeSouthEast;
                } else if (y > height - 10) {
                    action = MouseAction.ResizeSouth;
                } else if (x < 10) {
                    action = MouseAction.ResizeWest;
                } else if (x > width - 10) {
                    action = MouseAction.ResizeEast;
                } else {
                    action = MouseAction.Move;
                }
                setCursor(action.getCursor());
            }

            @Override
            public void mouseMoved(MouseEvent e) {
                if (!ignoreMoves) {
                    updateAction(e);
                }
            }

            @Override
            public void mousePressed(MouseEvent e) {
                updateAction(e);
                ignoreMoves = true;
                clickPoint = e.getPoint();
            }

            @Override
            public void mouseReleased(MouseEvent e) {
                clickPoint = null;
                ignoreMoves = false;
            }

            @Override
            public void mouseDragged(MouseEvent e) {
                switch (action) {
                    case Move: {
                        Point p = e.getPoint();
                        p.x -= clickPoint.x;
                        p.y -= clickPoint.y;
                        p = SwingUtilities.convertPoint(ImagePane.this, p, getParent());
                        setLocation(p);
                    }
                    break;
                    case ResizeWest: {
                        Point p = e.getPoint();
                        int xDelta = p.x - clickPoint.x;
                        int width = getWidth() - xDelta;
                        int x = getX() + xDelta;
                        setSize(width, getHeight());
                        setLocation(x, getY());
                        revalidate();
                    }
                    break;
                    case ResizeEast: {
                        Point p = e.getPoint();
                        int xDelta = p.x - clickPoint.x;
                        int width = getWidth() + xDelta;

                        setSize(width, getHeight());
                        revalidate();
                        clickPoint = p;
                    }
                    break;
                    case ResizeNorth: {
                        Point p = e.getPoint();
                        int yDelta = p.y - clickPoint.y;
                        int height = getHeight() - yDelta;
                        int y = getY() + yDelta;

                        setSize(getWidth(), height);
                        setLocation(getX(), y);
                        revalidate();
                    }
                    break;
                    case ResizeSouth: {
                        Point p = e.getPoint();
                        int yDelta = p.y - clickPoint.y;
                        int height = getHeight() + yDelta;

                        setSize(getWidth(), height);
                        revalidate();
                        clickPoint = p;
                    }
                    break;
                }
            }

            @Override
            public void mouseExited(MouseEvent e) {
            }
        }
    }
    public static BufferedImage getScaledInstanceToFit(BufferedImage img, Dimension size) {
        double scaleFactor = getScaleFactorToFit(img, size);
        return getScaledInstance(img, scaleFactor);
    }

    public static BufferedImage getScaledInstance(BufferedImage img, double dScaleFactor) {
        BufferedImage imgBuffer = null;
        imgBuffer = getScaledInstance(img, dScaleFactor, RenderingHints.VALUE_INTERPOLATION_BILINEAR);

        return imgBuffer;
    }

    protected static BufferedImage getScaledInstance(BufferedImage img, double dScaleFactor, Object hint) {
        BufferedImage imgScale = img;
        int iImageWidth = (int) Math.round(img.getWidth() * dScaleFactor);
        int iImageHeight = (int) Math.round(img.getHeight() * dScaleFactor);

        if (dScaleFactor <= 1.0d) {
            imgScale = getScaledDownInstance(img, iImageWidth, iImageHeight, hint);
        } else {
            imgScale = getScaledUpInstance(img, iImageWidth, iImageHeight, hint);
        }
        return imgScale;
    }    
    protected static BufferedImage getScaledDownInstance(BufferedImage img,
            int targetWidth,
            int targetHeight,
            Object hint) {

//        System.out.println("Scale down...");
        int type = (img.getTransparency() == Transparency.OPAQUE)
                ? BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB;

        BufferedImage ret = (BufferedImage) img;

        if (targetHeight > 0 || targetWidth > 0) {
            int w, h;
            // Use multi-step technique: start with original size, then
            // scale down in multiple passes with drawImage()
            // until the target size is reached
            w = img.getWidth();
            h = img.getHeight();

            do {
                if (w > targetWidth) {
                    w /= 2;
                    if (w < targetWidth) {
                        w = targetWidth;
                    }
                }

                if (h > targetHeight) {
                    h /= 2;
                    if (h < targetHeight) {
                        h = targetHeight;
                    }
                }

                BufferedImage tmp = new BufferedImage(Math.max(w, 1), Math.max(h, 1), type);
                Graphics2D g2 = tmp.createGraphics();
                g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, hint);             
                ScaleIMG.heightx=h;
                ScaleIMG.widthx=w;      

                g2.drawImage(ret, 0, 0, w, h, null);
                g2.dispose();

                ret = tmp;
            } while (w != targetWidth || h != targetHeight);

        } else {
            ret = new BufferedImage(1, 1, type);            
        }        
         return ret;
    }

    protected static BufferedImage getScaledUpInstance(BufferedImage img,
            int targetWidth,
            int targetHeight,
            Object hint) {

        int type = BufferedImage.TYPE_INT_ARGB;

        BufferedImage ret = (BufferedImage) img;
        int w, h;
        w = img.getWidth();
        h = img.getHeight();

        do {
            if (w < targetWidth) {
                w *= 2;
                if (w > targetWidth) {
                    w = targetWidth;
                }
            }

            if (h < targetHeight) {
                h *= 2;
                if (h > targetHeight) {
                    h = targetHeight;
                }
            }

            BufferedImage tmp = new BufferedImage(w, h, type);
            Graphics2D g2 = tmp.createGraphics();
            g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, hint);
            g2.drawImage(ret, 0, 0, w, h, null);
            g2.dispose();

            ret = tmp;
            tmp = null;
        } while (w != targetWidth || h != targetHeight);

        return ret;
    }
    public static double getScaleFactorToFit(BufferedImage img, Dimension size) {
        double dScale = 1;
        if (img != null) {
            int imageWidth = img.getWidth();
            int imageHeight = img.getHeight();
            dScale = getScaleFactorToFit(new Dimension(imageWidth, imageHeight), size);
        }
        return dScale;
    }

    public static double getScaleFactorToFit(Dimension original, Dimension toFit) {
        double dScale = 1d;
        if (original != null && toFit != null) {
            double dScaleWidth = getScaleFactor(original.width, toFit.width);
            double dScaleHeight = getScaleFactor(original.height, toFit.height);
            dScale = Math.min(dScaleHeight, dScaleWidth);
        }
        return dScale;
    }

    public static double getScaleFactor(int iMasterSize, int iTargetSize) {
        double dScale = 1;
        if (iMasterSize > iTargetSize) {
            dScale = (double) iTargetSize / (double) iMasterSize;
        } else {
            dScale = (double) iTargetSize / (double) iMasterSize;
        }
        return dScale;
    }
}

RotateIMGn.java

package logic;

import logic.ScaleIMG.ImagePane;

public class RotateIMGn extends JPanel
{
    private static final long serialVersionUID = 1L;
    public ImageIcon image;  
    JLabel label = new JLabel(image);  
    JPanel rotationPanel;  
    final int WIDTH = 350;  
    final int HEIGHT = 500;  
    double degrees=0; 

    ImagePane iobj = new ImagePane();

    public RotateIMGn(String passpath)  
    {       
        image =new ImageIcon(passpath);     
        setPreferredSize(new Dimension(446, 500));  

        setFocusable(true);

        //addKeyListener(new KeyboardListener());  
        rotationPanel = new JPanel();  
        rotationPanel = new turningCanvas();  
        rotationPanel.setPreferredSize(new Dimension(image.getIconWidth(),image.getIconHeight()));  
        add(rotationPanel);  

        JMenuBar menuBar = new JMenuBar();
        add(menuBar);

        JMenu mnFile = new JMenu("Rotate");
        menuBar.add(mnFile);

        ImageIcon icon90 = createImageIcon("/images/images_Right.png"); 
        JMenuItem mntmTR90 = new JMenuItem("Rotate 90+",icon90);

        mntmTR90.addActionListener(new ActionListener() 
        {

        @Override
        public void actionPerformed(ActionEvent arg0) 
        {
            try
            {
                degrees+=90.0;
                repaint();
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }

        }
    });

    mnFile.add(mntmTR90);


    ImageIcon icon180 = createImageIcon("/images/images_Vertical.png");
    JMenuItem mntmRT180 = new JMenuItem("Rotate 180+",icon180);

    mntmRT180.addActionListener(new ActionListener() 
    {

        @Override
        public void actionPerformed(ActionEvent e)
        {
            try
            {
                degrees+=180.0;
                repaint();
            }
            catch(Exception ex)
            {
                ex.printStackTrace();
            }

        }
    });

    mnFile.add(mntmRT180);

    JSeparator separator = new JSeparator();
    mnFile.add(separator);

    ImageIcon micon90 = createImageIcon("/images/images_Left.png"); 
    JMenuItem mntmTRM90 = new JMenuItem("Rotate 90-",micon90);

    mntmTRM90.addActionListener(new ActionListener() 
    {

        @Override
        public void actionPerformed(ActionEvent e) 
        {
            try
            {
                degrees-=90.0;
                repaint();
            }
            catch(Exception exc)
            {
                exc.printStackTrace();
            }


        }
    });
    mnFile.add(mntmTRM90);

    ImageIcon micon180 = createImageIcon("/images/images_Horizontal.png");  
    JMenuItem mntmRTM180 = new JMenuItem("Rotate 180-",micon180);

    mntmRTM180.addActionListener(new ActionListener() 
    {
        @Override
        public void actionPerformed(ActionEvent e) 
        {
            try
            {
                degrees-=180.0;
                repaint();
            }
            catch(Exception exz)
            {
                exz.printStackTrace();
            }

        }
    });

    mnFile.add(mntmRTM180);
    rotationPanel.setBounds(WIDTH/2, HEIGHT/2, rotationPanel.getPreferredSize().width, 

    rotationPanel.getPreferredSize().height);  

    }  

    public void paintComponent (Graphics g)  
    {  
    super.paintComponent(g); 
    }  

    public class turningCanvas extends JPanel  
    { 
        private static final long serialVersionUID = 1L;

        public void paintComponent (Graphics g)  
        {  

            try 
            {
                System.out.println(iobj.pathpass1);
                System.out.println(iobj.namepass1);
                iobj.save(iobj.pathpass1, iobj.namepass1);
            } 
            catch (IOException e) 
            {

                e.printStackTrace();
            }


            super.paintComponent(g);  
            Graphics2D g2d = (Graphics2D)g;  
            g2d.rotate(Math.toRadians(degrees),image.getIconWidth()/2,image.getIconHeight()/2);  
            image.paintIcon(this, g2d, 0, 0);  

        }  
    }  

    public static void main(String[] args)  
    {  
         String mn = null;
         RotateIMGn test = new RotateIMGn(mn);  
         JFrame frame = new JFrame();  

         frame.setTitle("Rotate Panel");
         frame.setContentPane(test);  
         frame.pack();  
         frame.setVisible(true);  
     }

    protected static ImageIcon createImageIcon(String path) {
        java.net.URL imgURL = RotateIMGn.class.getResource(path);
        if (imgURL != null) {
            return new ImageIcon(imgURL);
        } else {
            System.err.println("Couldn't find file: " + path);
            return null;
        }
    }   
}

Answer 1

You can use the Screen Image class to create an image of any component.