2D-Grafik Punkt drehen

Grejak

Aktives Mitglied
Hallo nal wieder

Ich möchte ein spezielles Programm schreiben hab aber nun folgendes Problem

Ein Point p soll um einen double wert degrees um den Ursprung Point u rotieren.

Hilfe???:L
 

Grejak

Aktives Mitglied
Yay so etwas habe ich schonmal ausprobiert aber es hat n icht wirklich funktioniert:
Java:
Point2D point=new Point2D(10,10);
Point2D anchor=new Point2D(15,15);
AffineTransform at=new AffineTransform();
at.rotate(90,anchor.getX(),anchor.getY());
point.setAffineTransform(at);

so meinst du dass,oder?
 

Marco13

Top Contributor
AUs dem Kopf etwa sowas
Java:
Point2D point=new Point2D.Float(10,10);
AffineTransform at=new AffineTransform();
at.rotate(Math.toDegrees(90));
Point2D rotated = new Point2D.Float(0,0);
at.transform(pt, rotated);
 

Marco13

Top Contributor
Ja, das [c]pt[/c] sollte [c]point[/c] sein. Beschreib' mal genauer worauf das ganze rauslaufen soll... ist ja schon ziemlich zäh so...
 

Grejak

Aktives Mitglied
wie schon gesagt einen Punkt rotieren

aber eine frage zu dem code wo stellt das programm den bezug zwischen punkten und grad zahl her
 

Marco13

Top Contributor
Ja, einen Punkt rotieren :noe: Schreib' in klaren Sätzen, was du vorhast, wie der Zusammenhang ist, und wo die Probleme liegen, dann kann man auch angemessen Antworten. Zugegeben, meine erste Antwort war nicht die ausführlichste, aber eben genau das: Angemessen.
 

Andi_CH

Top Contributor
Ein Point p soll um einen double wert degrees um den Ursprung Point u rotieren.

Ja, einen Punkt rotieren :noe: Schreib' in klaren Sätzen,

Also noch klarer kann man es IMO gar nicht beschreiben, aber genau das Problem ist mit der affinen Transformation gelöst - Wie gesagt durch leichtes aktivieren der grauen Masse genannt Hirn findet man auch raus wo die "Grad zahl" steht, die halt im Beispiel eine Konstante ist.

Oder müssen wir dir noch erklären wie man die Punkte im Koordinatensystem so schiebt, dass u in den Ursprung zu liegen kommt?

1. Schieben
2. Drehen
3. Zurück schieben

Die affine Transformation kann das vielleicht auch in einem Schritt (mittels Matrizen) aber das habe ich nicht so ganz verstanden.

Und wenn du das sauber implemetiert hast, postest du das ganze KSKB und sagst uns präzise was denn nicht tut - rätselraten ist nicht unsere Sache

EDIT: Schau mal da ich habe nur 3 Stunden (Ähm räusper Minuten) gebraucht um das zu finden :eek:
 
Zuletzt bearbeitet:

Marco13

Top Contributor
Ja, einen Punkt rotieren Schreib' in klaren Sätzen,
Also noch klarer kann man es IMO gar nicht beschreiben

Der entscheidende Teil war ja: "...was du vorhast, wie der Zusammenhang ist, und wo die Probleme liegen". Aufgrund des Eingangsbeirages ein KSKB zu basteln, um dann zu hören: "AffineTransform war das richtige Stichwort" oder "Bei mir ist das aber so-und-so" (oder eben "das funtionie bei mir nicht ;(" ;) ) ist so zwischendurch manchmal schwierig...
 

Andi_CH

Top Contributor
AUs dem Kopf etwa sowas
Java:
Point2D point=new Point2D.Float(10,10);
AffineTransform at=new AffineTransform();
at.rotate(Math.toDegrees(90));
Point2D rotated = new Point2D.Float(0,0);
at.transform(pt, rotated);

Math.toDegree ist sicher falsch ;-) 90 sind schon degrees

Schade dass die affine transformation nicht mit Point umgehen kann. Point kann translate aber leider kein rotate :-(
 
Zuletzt bearbeitet:

Andi_CH

Top Contributor
aber wie stellst du den bezug zu dem Punkten da

Sorry aber jetz kann ich mir V.......t nicht ganz verklemmen. Das habe ich 13:36 getippt.

SCHIEBEN
DREHEN
ZURÜCKSCHIEBEN

Wenn du nicht weisst wie man einen Punkt verschiebt geh nochmals in den Geometriunterricht oder lies die API von affine transformation - ich habs auch nicht anders gemacht und nach etwa 15 Minuten war alles erledigt und oberflächlich getestet!
 

Andi_CH

Top Contributor
Neinnein, ich wollte ja um 5156.62016 Grad drehen :noe:

BTW: Das "SCHIEBEN, DREHEN, ZURÜCKSCHIEBEN" braucht man nicht, dafür gibt's in AffineTransform schon eine Methode, aber... inzwischen hab' ich den Verdacht, dass hier getrollt wird... ???:L

Stimmt 5156.62016 Grad tönen schwer nach Troll :D :lol:

Ach geht das in Einem - das haben wir auf die Schnelle nicht gefunden. Den Drei-Schritt-Ansatz hab ich dem Azubi hier delegiert ;-) der hat gerne Abwechslung und ich hab das höchstkomplexe :oops: Main geschrieben, das einige Fälle testet. Dauerte knapp 15 Minuten oder so.
 

Marco13

Top Contributor
Poste ein Compilierbares Programm, wo du an einer Stelle einfügst
Java:
Point2D p = ...
Point2D q = ...

// HIER SOLL p UM q GEDREHT WERDEN
Dann schreibt dir jemand die 5 Zeilen... (die dir nichts bringen werden, weil wenn du sie nicht hinbekommst, du auch an der 6., 7. und 8. Zeile scheitern wirst....)
 

Grejak

Aktives Mitglied
Problem:

Also das was ich eigentlich erreichen will ist es ein zusammenhängendes Bild aus mehreren einzelnen zu gestalten. Dabei ist das Bild aufgebaut wie eine Marionette, dabei besteht die möglichkeit Teile
der Marionette zu drehen. Folglich müsste das Bild einfach nur gedreht werden.
Jedoch kann es sein dass ein weiteres Teil der Marionette an dem zu drehenden befestigt ist, da ich das Bild für das individuelle Teil an einem Punkt anhefte muss dieser Punkt mit dem Bild gedreht werden, damit das Bild ein ganzes bleibt.

siehe Anhang


Aber warum seid ihr so aufbauend und nett?
 
Zuletzt bearbeitet:

Grejak

Aktives Mitglied
:bae:
Java:
public Point2D rotatePoint(Point2D point,double degrees,Point2D anchor){
        AffineTransform transform=new AffineTransform();
        transform.rotate(Math.toRadians(degrees),anchor.getX(),anchor.getY());
        Point2D rotatedPoint=new Point2D.Float(0, 0);
        transform.transform(point,rotatedPoint);
        return rotatedPoint;
}

Java:
public BufferedImage rotateImage(BufferedImage img,double degrees,Point2D anchor){
        AffineTransform transform=new AffineTransform();
        transform.rotate(Math.toRadians(degrees),anchor.getX(),anchor.getY());
        Graphics2D g=(Graphics2D)img.getGraphics();
        BufferedImage copy=img;
        g.clearRect(0,0,img.getWidth(),img.getHeight());
        g.drawImage(copy,0,0,null);
        return img;
}
:bae:

nur weil ich fragen stelle die ihr sofort beantworten könnt bin ich nicht dumm:D
 
Zuletzt bearbeitet:

Marco13

Top Contributor
Es geht nicht um dumm oder den Inhalt der Frage, sondern um die ART der Frage. Wenn du beschrieben hättest, was du vorhast, und worin die Frage besteht (und vielleicht noch auf http://www.java-forum.org/hausaufgaben/127835-affinetransform.html verwiesen hättest) wäre das halb so schlimm. Aber... aus dem was du in diesem Beitrag schon hattest, und dem was ich darauf geantwortet habe, hättest du auch selbst lecht auf das kommen können, was du jetzt als Lösung bezeichnet hast.

Die meisten sind hier übrigens so aufbauend und nett, wie es in Anbetracht des vom Fragesteller an den Tag gelegten Engagements angebracht erscheint. Und immerhin wollte ich gerade (nachdem ich die Verbindung zum oben verlinkten Thread hergestellt und damit den Zusammenhang erkannt habe) das hier posten...
Java:
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.AffineTransform;
import java.awt.geom.Point2D;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;


public class JumpingJackTest 
{
	public static void main(String[] args) 
	{
		SwingUtilities.invokeLater(new Runnable()
        {
            @Override
            public void run()
            {
                JFrame f = new JFrame();
                f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                BodyPart root = buildBody();
                JumpingJackPanel panel = new JumpingJackPanel(root);
                createMovement(panel, root);
                f.getContentPane().add(panel);
                f.setSize(800,800);
                f.setVisible(true);
            }
        });
	}

	private static BufferedImage createImage(int w, int h, Color color)
	{
        BufferedImage image = new BufferedImage(w,h,BufferedImage.TYPE_INT_ARGB);
        Graphics2D g = image.createGraphics();
        g.setColor(color);
        g.fillRect(0,0,w,h);
        g.dispose();
        return image;
	}
	
	private static BodyPart buildBody()
	{
        BodyPart torso = new BodyPart(400,400, 25,10, createImage(50,100, Color.RED));
	    
        BodyPart leftUpperLeg = new BodyPart(10,90, 10,10, createImage(20,100, Color.GREEN));
        torso.addChild(leftUpperLeg);

        BodyPart rightUpperLeg = new BodyPart(40,90, 10,10, createImage(20,100, Color.GREEN));
        torso.addChild(rightUpperLeg);

        BodyPart leftLowerLeg = new BodyPart(10,90, 10,10, createImage(20,100, Color.YELLOW));
        leftUpperLeg.addChild(leftLowerLeg);

        BodyPart rightLowerLeg = new BodyPart(10,90, 10,10, createImage(20,100, Color.YELLOW));
        rightUpperLeg.addChild(rightLowerLeg);
        
	    return torso;
	}
	
	
	
	static void createMovement(final JComponent component, final BodyPart root)
	{
        Thread t = new Thread(new Runnable(){

            @Override
            public void run()
            {
                while (true)
                {
                    increaseRotation(root,3);
                    component.repaint();
                    try
                    {
                        Thread.sleep(20);
                    }
                    catch (InterruptedException e)
                    {
                        Thread.currentThread().interrupt();
                    }
                }
            }

            private void increaseRotation(BodyPart bodyPart, int counter)
            {
                double rotationDeg = bodyPart.getRotation();
                rotationDeg += counter;
                bodyPart.setRotation(rotationDeg);
                for (BodyPart child : bodyPart.getChildren())
                {
                    increaseRotation(child, counter+3);
                }
            }
        });
        t.start();
	}
}


class JumpingJackPanel extends JPanel
{
    private BodyPart root;
    
    public JumpingJackPanel(BodyPart root)
    {
        this.root = root;
    }

    @Override
    protected void paintComponent(Graphics gr)
    {
        super.paintComponent(gr);
        Graphics2D g = (Graphics2D)gr;
        root.paint(g);
    }
}

class BodyPart
{
    // The image to be painted
    private BufferedImage image;
    
    // The position of this body part relative to its parent
    private Point2D anchor;
    
    // The position of the anchor point in the local coordinate
    // system (i.e. the point that the image is rotated about)
    private Point2D localAnchor;
    
    // The body parts attached to this one
    private List<BodyPart> children;
    
    // The current rotation angle of this body part
    private double rotationAngleDeg;
    
    public BodyPart(int anchorX, int anchorY, int localAnchorX, int localAnchorY, BufferedImage image)
    {
        this.anchor = new Point2D.Float(anchorX, anchorY);
        this.localAnchor = new Point2D.Float(localAnchorX, localAnchorY);
        this.image = image;
        this.children = new ArrayList<BodyPart>();
    }
    
    public void addChild(BodyPart child)
    {
        this.children.add(child);
    }
    
    public List<BodyPart> getChildren()
    {
        return Collections.unmodifiableList(children);
    }

    public void setRotation(double angleDeg)
    {
        this.rotationAngleDeg = angleDeg;
    }
    
    public double getRotation()
    {
        return rotationAngleDeg;
    }
    
    
    public void paint(Graphics2D g)
    {
        AffineTransform oldAT = g.getTransform();
        g.translate(anchor.getX(), anchor.getY());
        g.translate(-localAnchor.getX(), -localAnchor.getY());
        g.transform(AffineTransform.getRotateInstance(
            Math.toRadians(rotationAngleDeg), 
            localAnchor.getX(), 
            localAnchor.getY()));
        g.drawImage(image, 0, 0, null);
        g.setColor(Color.BLACK);
        g.fillOval((int)localAnchor.getX()-2, (int)localAnchor.getY()-2, 4, 4);
        for (BodyPart child : children)
        {
            child.paint(g);
        }
        g.setTransform(oldAT);
    }
}
 

Neue Themen


Oben