# Bild drehen



## Niki (3. Nov 2005)

Hallo zusammen!

Ich hab schon viel im Forum gefunden und das Drehen eines BufferedImages funktioniert auch (AffineTransform und AffineTransformOp) nur leider hab ich das Problem dass meine Seite ein verkleinertes A4 format hat und er beim Drehen den rechten und den unteren rand ein wenig weg schneidet. Der Punkt um den gedreht werden soll ist img.getWidth()/2 und img.getHeight()/2.

Hat jemand eine Ahnung wie ich das Problem lösen kann? Aja, das Image wird auf einem Label gezeichnet, ich denke eh schon darüber nach einfach eine JComponent zu nehmen, wär aber dann mehr Aufwand

Danke bereits im Voraus


----------



## The_S (3. Nov 2005)

Darf das Bild nicht größer werden, oder überlegst du nur gerade, wie du die benötigte Größe berechnest?


----------



## Niki (3. Nov 2005)

nein, das Bild darf nicht größer werden, ich will es 1:1 nur um 90° drehen


----------



## The_S (3. Nov 2005)

Dann musst du das Bild beim Drehen wohl verkleinern, da es logischerweiße beim Drehen horizontal bzw. vertikal mehr Platz benötigt.


----------



## Niki (3. Nov 2005)

Das es horizontal mehr Platz verbraucht ist mir klar, das macht aber eigentlich nichts. Ich glaub es liegt irgendwie mit dem Punkt um den ich drehe zusammen. Wenn ich schon dabei bin, das ganze möchte ich verwenden um Seiten eines PDF-Dokuments zu drehen, daweil steht nur mal die GUI, für das Auslesen und Umwandeln in Images verwende ich die PDFBox library, hab aber noch nicht entdeckt wie ich mittels der Library Seiten drehen kann. Wenn jemand eine Lösung auch für dieses Problem hat wäre ich sehr dankbar


----------



## The_S (3. Nov 2005)

Das hab ich ja gemeint mit "Darf das Bild größer werden" :wink: . OK, dann gibt es zwei Möglichkeiten (die mir einfallen :wink

1. Du berechnest die größe, die dein Bild gedreht benötigt, erzeugst ein neues BufferedImage mit genau dieser größe. Malst dann das Alte mittig in das neue und drehst letztendlich das neue BufferedImage. (solltest du hierfür nen algo finden, post ihn bitte mal. Ich bin nämlich daran gescheitert  )

2. du berechnest dir die Diagonalen deines Bildes, erzeugst ein neues BufferedImage, welches als länge und breite die diagonalen hat, zeichnest da dann mittig dein Bild rein, drehst das ganze und schneidest zu guter letzt die überflüssigen Kanten wieder weg (das hab ich (zusammen mit ich² hinbekommen), könnte dir also den Code geben. Aber die 1. Möglichkeit ist sicherlich die bessere!)


----------



## Niki (3. Nov 2005)

Mal ein wenig Code:


```
public class PageLabel
    extends Label {

    private static final Border MARKED_BORDER = BorderFactory.
        createEtchedBorder(Color.
                           red, Color.red);

    private static final Border BORDER = BorderFactory.createEtchedBorder(Color.
        black,
        Color.black);

    private boolean marked = false;

    private PDPage page = null;

    private JPPages view = null;

    private BufferedImage bi = null;

    private PropertyChangeSupport pcs = null;

    public static final String PROPERTY_MARKED_CHANGED =
        "PROPERTY_MARKED_CHANGED";

    PageLabel(BufferedImage bi, PDPage page, JPPages view, int seite) {
        pcs = new PropertyChangeSupport(this);
        this.bi = bi;
        this.page = page;
        this.view = view;
        guiInit(bi);
        setToolTipText("Seite " + (seite + 1));
    }

    public void addPropertyChangeListener(PropertyChangeListener l) {
        super.addPropertyChangeListener(l);
        if (pcs != null)
            pcs.addPropertyChangeListener(l);
    }

    public void removePropertyChangeListener(PropertyChangeListener l) {
        super.removePropertyChangeListener(l);
        if (pcs != null)
            pcs.removePropertyChangeListener(l);
    }

    private void guiInit(Image i) {
        ImageIcon ii = new ImageIcon(i);

        setBorder(BORDER);
        setIcon(ii);
        addMouseListener(new MouseListener() {
            public void mouseClicked(MouseEvent e) {
                boolean b = e.isControlDown();
                if (b) {
                    if (marked) {
                        unmark(true);
                    }
                    else {
                        mark(true);
                    }
                }
                else {
                    view.unmarkAll();
                    if (!marked) {
                        mark(true);
                    }
                }
            }

            public void mouseEntered(MouseEvent e) {
                if (!marked)
                    setBorder(MARKED_BORDER);
            }

            public void mouseExited(MouseEvent e) {
                if (!marked)
                    setBorder(BORDER);
            }

            public void mousePressed(MouseEvent e) {
            }

            public void mouseReleased(MouseEvent e) {
            }

        });

    }

    BufferedImage getBufferedImage() {
        return bi;
    }

    void setBufferedImage(BufferedImage bi) {
        this.bi = bi;
    }

    public PDPage getPage() {
        return page;
    }

    void mark(boolean fireEvent) {
        boolean old = marked;
        marked = true;
        setBorder(MARKED_BORDER);
        if(fireEvent)
            pcs.firePropertyChange(PROPERTY_MARKED_CHANGED, old, marked);
    }

    void mark() {
        mark(false);
    }

    void unmark() {
        unmark(false);
    }

    void unmark(boolean fireEvent) {
        boolean old = marked;
        marked = false;
        setBorder(BORDER);
        if(fireEvent)
            pcs.firePropertyChange(PROPERTY_MARKED_CHANGED, old, marked);
    }
}

//ROTATE_METHOD:
 private void rotatePages(double angle) {
        double rad = Math.toRadians(angle);
        for (Iterator iter = view.getSelectedPages().iterator(); iter.hasNext(); ) {
            PageLabel pl = (PageLabel) iter.next();
            BufferedImage old = pl.getBufferedImage();
            AffineTransform af = AffineTransform.getRotateInstance(rad, old.getWidth()/2, old.getHeight()/2);
            AffineTransformOp afp = new AffineTransformOp(af,
                AffineTransformOp.TYPE_BILINEAR);
            BufferedImage _new = new BufferedImage(old.getHeight(), old.getWidth(), old.getType());
            afp.filter(old, _new);
            pl.setIcon(new ImageIcon(_new));
            pl.setBufferedImage(_new);
        }
    }
```


----------



## Niki (4. Nov 2005)

Soda, ich hab die Lösung im InterNETZ gefunden, Funktioniert einwandfrei!!!!


```
public static BufferedImage rotateLeft(BufferedImage bi) 
  { 
    AffineTransform afLeft = AffineTransform.getRotateInstance( 
        Math.toRadians(270)); 
    afLeft.translate(bi.getWidth() * -1,0); 
    AffineTransformOp lOp = new AffineTransformOp(afLeft,null); 

    BufferedImage dstbi = lOp.filter(bi, null); 

    return dstbi; 
  } 

  public static BufferedImage rotateRight(BufferedImage bi) 
  { 
    AffineTransform afRight = AffineTransform.getRotateInstance( 
        Math.toRadians(90)); 
    afRight.translate(0,bi.getHeight() * -1); 
    AffineTransformOp rOp = new AffineTransformOp(afRight,null); 

    BufferedImage dstbi = rOp.filter(bi, null); 

    return dstbi; 
  }
```


----------

