AffineTransform: die Skalierung einer Form von deren Mittelpunkt

Ich versuche skalieren eines Rechtecks aus seiner Mitte mit AffineTransform. Ich bin sicher, die Lösung liegt auf der Hand, aber ich kann nicht damit es funktioniert ! Hier ist, was ich bisher getestet haben...

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.geom.AffineTransform;

import javax.swing.JOptionPane;
import javax.swing.JPanel;

public class Test extends JPanel {
    Test()
        {
        super(null);
        setOpaque(true);
        setBackground(Color.WHITE);
        setPreferredSize(new Dimension(200,200));
        }
    @Override
    protected void paintComponent(Graphics g1) {
        super.paintComponent(g1);
        Rectangle r= new Rectangle(5,5,getWidth()-10,getHeight()-10);
        double cx= r.getCenterX();
        double cy= r.getCenterY();
        Graphics2D g=(Graphics2D)g1;
        g.setColor(Color.BLACK);
        AffineTransform old= g.getTransform();
        for(double zoom=0.9; zoom>=0.5; zoom-=0.1)
            {
            AffineTransform tr2= new AffineTransform(old);
            tr2.translate(-cx, -cy);
            tr2.scale(zoom, zoom);
            tr2.translate(cx/zoom,cy/zoom);
            g.setTransform(tr2);
            g.draw(r);
            g.setTransform(old);
            }
        }


    public static void main(String[] args) {
        JOptionPane.showMessageDialog(null, new Test());
        }
    }

Aber es funktioniert nicht.... Jede Anregung ?

Ich nehme an, Sie versuchen zu verfolgen, konzentrisch/interne Rechtecke?

InformationsquelleAutor Pierre | 2009-03-27

  1. 5

    Ich sehe, was Sie meinen, wenn Sie ' re Umgang mit Rechtecken. Der Grund ist, weil die erste Berechnung für die übersetzung nicht berücksichtigen, die Größe des container-Objekts.

    Diese stattdessen zu verwenden:

    tr2.translate(
    (this.getWidth()/2) - (r.getWidth()*(zoom))/2,
    (this.getHeight()/2) - (r.getHeight()*(zoom))/2
);
tr2.scale(zoom,zoom);
g.setTransform(tr2);

    Was dieser tut, ist die übersetzung des Rechtecks auf der Mitte der Vorderseite vor der Skalierung. In meinen tests funktioniert es ganz gut.

    InformationsquelleAutor Welbog

  2. 5

    Vorausgesetzt, Skalierung behebt die Lage der oberen linken Ecke des Rechtecks (die ich für richtig halte aber es ist schon eine lange Zeit, seit ich getan habe Grafiken in Java), die Sie benötigen, zu übersetzen, ist das Rechteck in die entgegengesetzte Richtung auf die Skalierung.

    tr2.translate(
    r.getWidth()*(1-zoom)/2,
    r.getHeight()*(1-zoom)/2
);
tr2.scale(zoom,zoom);
g.setTransform(tr2);

    So verschieben Sie das Rechteck Links und rechts die Hälfte der Veränderung in der Breite und Höhe.

    Scheint nicht zu funktionieren.
    Ihre Lösung funktioniert nicht, aber es gibt mir ein paar neue Ideen, danke
    was ist das Ergebnis, das Sie bekommen? Ich don ' T haben Zugang zu einer Java-IDE bei der Arbeit, so kann ich es nicht selbst ausprobiert. Ich arbeite weitgehend aus dem Gedächtnis.
    Mit der original-code, alle Felder Ihren Ursprung in der linken oberen Ecke. Mit Ihrer code, Sie werden zunehmend in Richtung Mitte verlagert, aber nicht genug.
    Ah, hab es. Alles, was Sie tun müssen, ist, verschieben Sie die Skala() auf, nachdem die translate() und es funktioniert perfekt.

    InformationsquelleAutor Welbog

  3. 1

    War ich gerade an eine desktop-Anwendung zum zuschneiden Brittney Spear ' s face (D. A. Y.) Das Rechteck zum beschneiden musste die Skala um seinen Mittelpunkt:

    import javafx.scene.Cursor;
import javafx.scene.Group;
import javafx.scene.input.MouseEvent;
import javafx.scene.input.ScrollEvent;
import javafx.scene.paint.Color;
import javafx.scene.paint.Paint;
import javafx.scene.shape.Rectangle;

class ResizableRectangle extends Rectangle {

 ResizableRectangle(double x, double y, double width, double height, Group group) {

  super(x, y, width, height);

  //Set scroll listener for crop selection
  group.addEventHandler(ScrollEvent.SCROLL, event -> {
   double zoomFactor = 1.10;
   double deltaY = event.getDeltaY();
   if (deltaY > 0) {
    zoomFactor = 2.0 - zoomFactor;
   }

   super.setX(getX() + (super.getWidth() * (1 - zoomFactor) / 2)); //Set new X position
   super.setWidth(getWidth() * zoomFactor); //Set new Width

   super.setY(getY() + (super.getHeight() * (1 - zoomFactor) / 2)); //Set new Y position
   super.setHeight(getHeight() * zoomFactor); //Set new Height

   event.consume();
  });
 });
}

    Im Allgemeinen der Algorithmus funktioniert wie folgt:

    • Übersetzen-Rechteck x-Werte mit: x + (width * (1 - zoomFactor) /2)
    • Translate y-Werte mit: y + (height * (1 - zoomFactor) /2)
    • Satz neue Breite: width * zoomFactor
    • Neue Höhe: height * zoomFactor

    InformationsquelleAutor Martin Erlic

  4. 0

    Dies beinhaltet einen Prozess namens conjugating eine Transformation.

    Wenn S die Skalierung, die Sie tun möchten, und T ist die transformation, die nimmt Punkt (0,0) auf den Punkt, der das Zentrum der Skalierung, dann die Transformation, die nicht den job ist

    T(S(inverse(T)))

    InformationsquelleAutor paulmurray

  5. 0

    (Später) Hier ist eine Lösung ohne Vorherige Kenntnis der Dimension des Panels.

    import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Shape;
import java.awt.geom.AffineTransform;
import java.awt.geom.Ellipse2D;

import javax.swing.JOptionPane;
import javax.swing.JPanel;

public class Test extends JPanel
    {
    private static final long serialVersionUID = 1L;
    private Test()
        {
        super(null);
        setOpaque(true);
        setBackground(Color.WHITE);
        setPreferredSize(new Dimension(600,600));
        }

    @Override
    protected void paintComponent(Graphics g1) {
        super.paintComponent(g1);
        Shape r= new Ellipse2D.Double(5,380,400,200);
        double cx= r.getBounds2D().getCenterX();
        double cy= r.getBounds2D().getCenterY();
        Graphics2D g=(Graphics2D)g1;
        g.setColor(Color.BLACK);
        AffineTransform old= g.getTransform();
        g.drawLine((int)cx-10, (int)cy, (int)cx+10, (int)cy);
        g.drawLine((int)cx, (int)cy-10, (int)cx, (int)cy+10);
        for(double zoom=1; zoom>=0.1; zoom-=0.1)
                {


                AffineTransform tr2 =AffineTransform.getTranslateInstance(-cx, -cy);
                AffineTransform  tr= AffineTransform.getScaleInstance(zoom,zoom);
                tr.concatenate(tr2); tr2=tr;
                tr =AffineTransform.getTranslateInstance(cx, cy);
                tr.concatenate(tr2); tr2=tr;

                tr= new AffineTransform(old);
                tr.concatenate(tr2);  tr2=tr;

                g.setTransform(tr2);



                g.draw(r);
                g.setTransform(old);
                }
        }


    public static void main(String[] args) {
        JOptionPane.showMessageDialog(null, new Test());
        }
    }

    InformationsquelleAutor Pierre

Schreibe einen Kommentar