JXImagePanel을 회전하는 방법?

Question

나는 JXImagePanel을 회전시키기 위해 kuje을 사용했다.

이 페이지에 그것은이 가능해야한다 -이 JXImagePanel에 대해 언급한다 - http://java.net/projects/swingx/sources/svn/content/trunk/www/documentation/index.html?raw=true#JXImagePanel : JLabel의의와의 JButton의 쉽게 스윙 응용 프로그램에 이미지를 추가 할 수 있도록이의 JXImagePanel 그것을 하찮게 쉽게 하나를 추가 할 수 있지만

Swing 애플리케이션에 BufferedImage 또는 Icon. 편집 가능하면 사용자가 이미지를 변경할 수있는 방법을 제공합니다. 또한 JXImagePanel은 타일링, 크기 조절, 회전, 합성 등의 다양한 기본 내장 효과를 제공합니다.

그러나이 방법은 알 수 없습니다. 어떤 아이디어?

현재 내 코드는 다음과 같습니다

 bufferedImage = ImageIO.read(new File("image.png"));    
     image = new ImageIcon(bufferedImage).getImage(); 
     tempImage = image.getScaledInstance(100, 150, Image.SCALE_FAST); 
     this.deskJXImagePanel.setImage(tempImage); 

지금은 (0-360)도에서 회전하고 싶습니다. 어떻게 할 수 있습니까? 고맙습니다. 내가 somethimg SwingX's JXImagePanel에 대한 자세한하지만 일반 바닐라 스윙을 모르는

Answer 1

내가 Sn'Oracle의 eerrrght에 의해 old.forums.sun.com에서이 무한 혼란을 싫어 ... aephyr 또는 tjacobs 또는 의해 excelent 해결 방법을 (존재)이 여전히 내부적으로 사용 있기 때문에 JXImagePanel은, 1.6.2의 민간 (실제로 만든 패키지를 사용되지 않습니다

import java.awt.*; 
import java.awt.event.*; 
import java.awt.geom.AffineTransform; 
import java.awt.image.BufferedImage; 
import java.io.File; 
import java.util.*; 
import javax.imageio.ImageIO; 
import javax.swing.*; 
import javax.swing.Timer; 
import javax.swing.filechooser.*; 

public class RotatableImageComponent extends JComponent { 

    private static final long serialVersionUID = 1L; 
    private Image image; 
    private double angle = 0; 
    private MyObservable myObservable; 

    public RotatableImageComponent() { 
     myObservable = new MyObservable(); 
    } 

    public RotatableImageComponent(Image image) { 
     this(); 
     this.image = image; 
    } 

    public Image getImage() { 
     return image; 
    } 

    public void setImage(Image image) { 
     this.image = image; 
    } 

    public double getAngle() { 
     return angle; 
    } 

    public void setAngle(double angle) { 
     if (angle == this.angle) { 
      return; 
     } 
     this.angle = angle; 
     double circle = Math.PI * 2; 
     while (angle < 0) { 
      angle += circle; 
     } 
     while (angle > circle) { 
      angle -= circle; 
     } 
     if (myObservable != null) { 
      myObservable.setChanged(); 
      myObservable.notifyObservers(this); 
     } 
     repaint(); 
    } 

    /** 
    * In the rotation events sent to the listener(s), the second argument 
    * (the value) will be a reference to the RotatableImageComponent. One then 
    * should call getAngle() to get the new value. 
    * @param o 
    */ 
    public void addRotationListener(Observer o) { 
     myObservable.addObserver(o); 
    } 

    public void removeRotationListener(Observer o) { 
     myObservable.deleteObserver(o); 
    } 

    public void rotateClockwise(double rotation) { 
     setAngle(getAngle() + rotation); 
    } 

    public void rotateCounterClockwise(double rotation) { 
     //setAngle(getAngle() - rotation); 
     rotateClockwise(-rotation); 
    } 

    @Override 
    public void paintComponent(Graphics g) { 
     if (image == null) { 
      super.paintComponent(g); 
      return; 
     } 
     Graphics2D g2 = (Graphics2D) g; 
     AffineTransform trans = AffineTransform.getTranslateInstance(getWidth()/2, getHeight()/2); 
     trans.rotate(angle); 
     trans.translate(-image.getWidth(null)/2, -image.getHeight(null)/2); 
     g2.transform(trans); 
     g2.drawImage(image, 0, 0, null); 
    } 

    @Override 
    public Dimension getPreferredSize() { 
     if (image == null) { 
      return super.getPreferredSize(); 
     } 
     int wid = image.getWidth(null); 
     int ht = image.getHeight(null); 
     int dist = (int) Math.ceil(Math.sqrt(wid * wid + ht * ht)); 
     return new Dimension(dist, dist); 
    } 

    public static class TimedRotation { 

     private RotatableImageComponent comp; 
     private long totalTime, startTime; 
     private double toRotate, startRotation; 
     private int interval; 
     public Timer myTimer; 
     private myAction mAction; 

     public TimedRotation(RotatableImageComponent comp, double toRotate, long totalTime, int interval) { 
      //super(interval, new myAction()); 
      this.comp = comp; 
      this.totalTime = totalTime; 
      this.toRotate = toRotate; 
      this.startRotation = comp.getAngle(); 
      this.interval = interval; 
     } 

     public void start() { 
      if (mAction == null) { 
       mAction = new myAction(); 
      } 
      if (myTimer == null) { 
       myTimer = new Timer(interval, new myAction()); 
       myTimer.setRepeats(true); 
      } else { 
       myTimer.setDelay(interval); 
      } 
      myTimer.start(); 
      startTime = System.currentTimeMillis(); 
     } 

     public void stop() { 
      myTimer.stop(); 
     } 

     private class myAction implements ActionListener { 

      @Override 
      public void actionPerformed(ActionEvent ae) { 
       long now = System.currentTimeMillis(); 
       if (totalTime <= (now - startTime)) { 
        comp.setAngle(startRotation + toRotate); 
        stop(); 
        return; 
       } 
       double percent = (double) (now - startTime)/totalTime; 
       double rotation = toRotate * percent; 
       comp.setAngle(startRotation + rotation); 
      } 
     } 
    } 

    private class MyObservable extends Observable { 

     @Override 
     protected void setChanged() { 
      super.setChanged(); 
     } 
    } 

    public static class RotationKeys extends KeyAdapter { 

     private RotatableImageComponent comp; 
     private double rotationAmt; 

     public RotationKeys(RotatableImageComponent comp, double rotationAmt) { 
      this.comp = comp; 
      this.rotationAmt = rotationAmt; 
     } 

     public RotationKeys(RotatableImageComponent comp) { 
      this(comp, Math.PI/90); 
     } 

     @Override 
     public void keyPressed(KeyEvent ke) { 
      if (ke.getKeyCode() == KeyEvent.VK_LEFT) { 
       comp.rotateCounterClockwise(rotationAmt); 
      } else if (ke.getKeyCode() == KeyEvent.VK_RIGHT) { 
       comp.rotateClockwise(rotationAmt); 
      } 
     } 
    } 

    public static void main(String[] args) { 
     SwingUtilities.invokeLater(new Runnable() { 

      @Override 
      public void run() { 
       try { 
        FileFilter filter = new FileNameExtensionFilter("JPEG file", "jpg", "jpeg"); 
        JFileChooser chooser = new JFileChooser(); 
        chooser.addChoosableFileFilter(filter); 
        if (chooser.showSaveDialog(null) == JFileChooser.APPROVE_OPTION) { 
         File f = chooser.getSelectedFile(); 
         BufferedImage im = ImageIO.read(f); 
         final RotatableImageComponent c = new RotatableImageComponent(im); 
         c.addRotationListener(new Observer() { 

          @Override 
          public void update(Observable arg0, Object arg1) { 
           System.out.println("Angle changed: " + ((RotatableImageComponent) arg1).getAngle()); 
          } 
         }); 
         JPanel controls = new JPanel(new FlowLayout()); 
         final JTextField rotation = new JTextField(); 
         rotation.setText("30"); 
         controls.add(new JLabel("Rotation(degrees)")); 
         controls.add(rotation); 
         final JTextField time = new JTextField(); 
         time.setText("1000"); 
         time.setColumns(6); 
         rotation.setColumns(7); 
         controls.add(new JLabel("Time(millis)")); 
         controls.add(time); 
         JButton go = new JButton("Go"); 
         go.addActionListener(new ActionListener() { 

          @Override 
          public void actionPerformed(ActionEvent ae) { 
           TimedRotation tr = new TimedRotation(c, 
             Double.parseDouble(rotation.getText())/180 * Math.PI, 
             Integer.parseInt(time.getText()), 50); 
           tr.start(); 
          } 
         }); 
         controls.add(go); 
         RotationKeys keys = new RotationKeys(c); 
         c.addKeyListener(keys); 
         c.setFocusable(true); 
         JFrame jf1 = new JFrame(); 
         jf1.getContentPane().add(c); 
         JFrame jf2 = new JFrame(); 
         jf2.getContentPane().add(controls); 
         jf1.pack(); 
         jf2.pack(); 
         jf1.setLocation(100, 100); 
         jf2.setLocation(400, 100); 
         jf1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
         jf2.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE); 
         jf1.setVisible(true); 
         jf2.setVisible(true); 
        } 
       } catch (Throwable t) { 
        t.printStackTrace(); 
       } 
      } 
     }); 
    } 
} 

Answer 2

), 그래서 더 잘 사용하지 않는, 곧 제거 될 것입니다. 대신

, 코드에서는, ImagePainter과 화가에 적용되는 임의의 transformOp와 JXPanel을 사용하여 같은 것을 니펫 : 당신은 아마 당신이 원하는 정확한 효과를 얻기 위해 약간을 재생해야합니다

JXPanel panel = new JXPanel(); 
    ImagePainter image = new ImagePainter(myImage); 
    image.setFilters(
      new AffineTransformOp(AffineTransform.getRotateInstance(-Math.PI * 2/8, 100, 100), null) 
      ); 
    panel.setBackgroundPainter(image); 

달성하기. 문제가 있으면 Swinglabs 포럼에 게시하려고 할 수 있습니다.