java - 如何保存旋转后的图像？

Question

我正在开发一个应用程序，用户加载图像可以缩放它，也可以保存它。还可以通过菜单项点击旋转来旋转图像。

单击旋转时，会打开另一个框架，并将最后定位或最后缩放的图像加载到旋转面板中。现在，当用户单击旋转选项时，图像应该保存在该位置，但尚未完成。

如果有人知道请帮助我。我做了2个文件1.加载图像并保存图像，即ScaleIMG和2. 旋转图像即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

您可以使用Screen Image类来创建任何组件的图像。