2D-Grafik Quadrat/Dreieck um Mittelpunkt drehen

[Jats]

Tag,

ich versuche momentan ein Quadrat bzw. ein Dreieck um einen Mittelpunkt zu drehen.
Das ganze stellt das Haus vom Nikaus da, welches von der Klasse Zeichnen mit 5 Eckpunkten und 10 x/y-Koordinaten gezeichnet wird.
Der erste Startpunkt (unten links) ist in der Klasse vorgegeben, die restlichen werden berechnet.
Davon abgesehen, dass die Spitze des Hauses außerhalb des Fensters ist, was ich noch ändern muss, aber nicht genau weiß, wie, läuft alles.
Von Zeichnen aus will ich also zuerst in der Methode paint das Haus mit den originalen Koordinaten zeichnen und in drehen sollen die Koordinaten geändert werden.

Jetzt hab ich allerdings ein paar Denkblockaden, ich komme einfach nicht drauf, wie ich die neuen Koordinaten für die Punkte berechne.
Nimmt man an, man hat ein Quadrat, zeichnet einen Kreis drum, der die 4 Eckpunkte des Quadrats berührt, dann ist der Kreis ja praktisch die Linie, auf der sich die Koordinaten befinden.
Ich kann Radius, den Mittelpunkt, irgendwelche Längen alles berechnen, aber ich komme nicht drauf, wie ich bspw. den originalen Punkt xPunkte[0] = 125; neu berechne, sodass er in Richtung/oder gegen den Uhrzeigersinn (, mir ist das relativ egal) geschoben wird.

Ich hab an Sinus, Cosinus und Tangens, sowie an die Drehmatrix gedacht, aber kann das nicht umsetzen.

Hier mal meine Ansätze bis jetzt (es ging mir erstmal nur um die Punkte, dass sie richtig berechnet werden, dass noch nichts gezeichnet wird ist mir klar, darum hab ich die Punkte berechnen und ausgeben lassen.) :

import java.awt.*;
import javax.swing.*;
import java.awt.Graphics;
import java.math.*;

/*
 *draw.(this) v1.2
 *22/05/2011, 11:30
 *© by Jats 
 *
 *Update: draw.(this) v1.3
 *22/05/2011, 12:00
 *
 */

public class Zeichnen extends JFrame
{

    private Haus h;
    double xPunkte [];
    double yPunkte [];

    public Zeichnen()
    {
        new Canvas();
        setSize(750,500);
        setLocation(400,100);
        setDefaultCloseOperation(3);
        setResizable(false);
        setBackground(Color.WHITE);
        setVisible(true);       
        repaint();

        h = new Haus();

        xPunkte = new double [5];
        yPunkte = new double [5];        
    }

    public void drehen() {

        double dxPunkte [];
        double dyPunkte [];

        dxPunkte = new double [5];
        dyPunkte = new double [5];

        int a = h.geta();

        double hyDreieck = yPunkte[2]-yPunkte[3];
        double mxViereck = xPunkte[0]+a/2;
        double myViereck = yPunkte[0]-a/2;
        double rViereck = Math.sqrt((a/2)^2+(a/2)^2);
        double rDreieck = (a/2)+hyDreieck;
        double beta = Math.pow((a/2),2)+Math.pow(rViereck,2);

        for(int i=0; i<=360; i++) {
            for(int j=0; j<5; j++) {
                dxPunkte [j] = (Math.cos(i) - Math.sin(i))*(xPunkte[j]);
                System.out.println(dxPunkte[j]+"");
                dyPunkte [j] = (Math.cos(i) - Math.sin(i))*(yPunkte[j]);
                System.out.println(dyPunkte[j]+"");
            }
        }        

    }

    public void paint(Graphics g) {

        for(int i=0; i<5; i++) {
            xPunkte [i] = ((double)h.getPx(i));
            yPunkte [i] = ((double)h.getPy(i));
        }

        try {
            g.drawString("© by Jats",125,400);
            Thread.sleep(2000);
            g.drawLine(((int)xPunkte[0]),((int)yPunkte[0]),((int)xPunkte[1]),((int)yPunkte[1]));
            Thread.sleep(2000);
            g.drawLine(((int)xPunkte[1]),((int)yPunkte[1]),((int)xPunkte[2]),((int)yPunkte[2]));
            Thread.sleep(2000);
            g.drawLine(((int)xPunkte[2]),((int)yPunkte[2]),((int)xPunkte[3]),((int)yPunkte[3]));
            Thread.sleep(2000);
            g.drawLine(((int)xPunkte[3]),((int)yPunkte[3]),((int)xPunkte[4]),((int)yPunkte[4]));
            Thread.sleep(2000);
            g.drawLine(((int)xPunkte[4]),((int)yPunkte[4]),((int)xPunkte[2]),((int)yPunkte[2]));
            Thread.sleep(2000);
            g.drawLine(((int)xPunkte[2]),((int)yPunkte[2]),((int)xPunkte[0]),((int)yPunkte[0]));
            Thread.sleep(2000);
            g.drawLine(((int)xPunkte[0]),((int)yPunkte[0]),((int)xPunkte[4]),((int)yPunkte[4]));
            Thread.sleep(2000);
            g.drawLine(((int)xPunkte[4]),((int)yPunkte[4]),((int)xPunkte[1]),((int)yPunkte[1]));

            drehen();

        }
        catch(InterruptedException e)
        {
            e.printStackTrace();
        }
    }

}

Ich hoffe, ihr versteht das Problem und könnt mir helfen, ist bestimmt nicht allzu schwer, aber ich komme einfach nicht drauf. Die aktuelle Berechnung läuft glaub ich falsch, eigentlich müsste ich ja was mit PI oder so machen, aber ich weiß nicht, wie.

 

[Michael...]

Hab den Code nicht angeschaut, aber anstatt die Koordinaten selbst zu berechenen. Rotiere einfach das Graphics Objekt (um den richtigen Punkt) und zeichne mit den "normalen" Koordinaten. Dazu einfach das Graphics Objekt nach Graphics2D casten - letztere Klasse besitzt zwei Methoden rotate(...)

Ansonsten gilt:
- kein Thread.sleep(...) in einer paint(...)
- besser ein JPanel oder eine JComponent nehmen und deren paintComponent(Graphics g) überschreiben statt die paint() einen JFrames

 

[Jats]

Rotiere einfach das Graphics Objekt (um den richtigen Punkt) und zeichne mit den "normalen" Koordinaten. Dazu einfach das Graphics Objekt nach Graphics2D casten - letztere Klasse besitzt zwei Methoden rotate(...)

Ich weiß ehrlich gesagt nicht, ob das -auch, wenn es einfacher wäre- so gewünscht ist.
Wir sollten die Punkte berechnen lassen.

Ansonsten gilt:
- kein Thread.sleep(...) in einer paint(...)
- besser ein JPanel oder eine JComponent nehmen und deren paintComponent(Graphics g) überschreiben statt die paint() einen JFrames

Haben wir im Unterricht alles genauso gemacht, gut, wenn du mir sagst, dass es nicht korrekt ist, ich werde es ändern, aber das mit der Canva und dem JFrame/paint lasse ich so, so war es auch vorgeschrieben.

Kann mir niemand sagen, wie diese Berechnungen gehen ?

 

[Marco13]

Beschreib' mal genauer, worum es geht (genaue Aufgabenstellung). Ist es wirklich das Ziel, das ganze "per Hand" zu implementieren? Oder kann man versuchen, das ganze mit

zu machen?

 

[Michael...]

Haben wir im Unterricht alles genauso gemacht, gut, wenn du mir sagst, dass es nicht korrekt ist, ich werde es ändern

Ist es nicht und macht auch gar keinen Sinn. Soll man den sehen, wie das Haus Strich für Strich gezeichnet wird?

aber das mit der Canva

das erzeugte Canvas Objekt wird gar nciht genutzt (abgesehen davon, dass man AWT und Swing Kompenten nicht mischen sollte)

 

[Jats]

Es wird erwartet, dass das Haus vom Nikolaus über die Klasse Zeichnen gezeichnet wird.
Die Koordinaten dafür stehen in der Klasse Haus und diese sollen anhand des ersten Punktes berechnet werden.
Bei mir wäre das xPoints[0] = 125, yPoints[0] = 375.
Ich poste mal die Klasse Haus.

/*
 *draw.(this) v1.2
 *22/05/2011, 11:30
 *© by Jats 
 */

public class Haus
{   
    double [] xpoints;
    double [] ypoints;
    int a;
        public Haus()
    {
        int x = 125;
        int y = 350;
        a = 250;
        int i = 0;

       xpoints = new double [5];
       ypoints = new double [5];

        while(i<xpoints.length-1) {
            xpoints[0] = x;
            xpoints[1] = x+a;
            xpoints[2] = x;
            xpoints[3] = x+a/2;
            xpoints[4] = x+a;

            ypoints[0] = y;
            ypoints[1] = y;
            ypoints[2] = y-a;
            ypoints[3] = Math.sqrt((a^2)+((a/2)^2));
            ypoints[4] = y-a;

            i = 5;
        }
    }

    public int getPx(int i) {
        return ((int) xpoints[i]);
    }

    public int getPy(int i) {
        return ((int) ypoints[i]);
    }
    
    public int geta() {
        return a;
    }
    
}

Des weiteren wurde gesagt, es solle möglich sein, mit Zeichnen das Haus zuerst normal zu zeichnen und dann mit der Methode drehen zu drehen, um einen festgelegten Mittelpunkt. Das hab ich alles berechnet, aber wird nicht verwendet, da ich nicht weiß, wie ich das machen muss.
Es wurde irgendwas von 2PI und Kreis/Bogenmaß gesagt, aber mehr nicht. Man hat uns nur den Tipp mit dem Kreis gegeben, aber wie genau die Umsetzng sein soll wurde nicht gesagt. Ich bin nicht der Mathefreak, dass ich mir darunter genug vorstellen kann, um das umzusetzen, deshalb komme ich halt nicht weiter.
An sich hab ich ja alles.

EDIT: @Michael: Dass das Canvas nicht benutzt wird, hab ich auch bemerkt, aber das stand so in der Vorlage drin, die wir nicht verändern sollen. Es stört ja nicht, also von daher
Und das Zeichnen des Hauses sollte man sehen, ja.

 

[FabiUHhh]

Hey Jason,
ich bins Fabian
ich habs auch noch nicht ganz geschafft aber ich hab die Formel um die neuen Punkte zu berechnen, nur bei mir sind die Unterschiede zwischen den werten so klein das beim typecast automatisch immer 341 draus wird ?!

[JAVA=42] public class Haus
{

private double[] pX;
private double[] pY;
private double a;
private double r; //Radius

public Haus()
{
pX = new double [5];
pY = new double [5];

a = 100.0;
r = a*Math.sqrt(2);

pX[0] = 200.0 + r * Math.cos(7/8 * (2*Math.PI));
pX[1] = 200.0 + r * Math.cos(5/8 * (2*Math.PI));
pX[2] = 200.0 + a + r * Math.cos(3/8 * (2*Math.PI));
pX[3] = 200.0 + a + r * Math.cos(1/8 * (2*Math.PI));
pX[4] = 250.0 + a * Math.cos(2*Math.PI);

pY[0] = 200.0 + r * Math.sin(7/8 * (2*Math.PI));
pY[1] = 200.0 + a + r * Math.sin(5/8 * (2*Math.PI));
pY[2] = 200.0 + a + r * Math.sin(3/8 * (2*Math.PI));
pY[3] = 200.0 + r * Math.sin(1/8 * (2*Math.PI));
pY[4] = 200.0 - a/2 + a * Math.sin(2*Math.PI);

}

public int getPx(int n)
{
return (int) pX[n];
}

public int getPy(int n)
{
return (int) pY[n];
}

public void drehen(int grad)
{
pX[0] = 200.0 + r * Math.cos((7/8+grad/360) * (2*Math.PI));
pX[1] = 200.0 + r * Math.cos((5/8+grad/360) * (2*Math.PI));
pX[2] = 200.0 + a + r * Math.cos((3/8+grad/360) * (2*Math.PI));
pX[3] = 200.0 + a + r * Math.cos((1/8+grad/360) * (2*Math.PI));
pX[4] = 200.0 - a/2 + a * Math.cos((1+grad/360) * (2*Math.PI));

pY[0] = 200.0 + r * Math.sin((7/8+grad/360) * (2*Math.PI));
pY[1] = 200.0 + a + r * Math.sin((5/8+grad/360) * (2*Math.PI));
pY[2] = 200.0 + a + r * Math.sin((3/8+grad/360) * (2*Math.PI));
pY[3] = 200.0 + r * Math.sin((1/8+grad/360) * (2*Math.PI));
pY[4] = 200.0 - a/2 + a * Math.sin((1+grad/360) * (2*Math.PI));
}

}
[/code]

Die Formeln sind im Prinzip von dem nur das ich nochma nachgedacht habe radius ist ja eigentlich a*sqrt(2) und nicht wie der
meinte a/sqrt(2)

 

[Jats]

Hey

Sollten wir drehen in Haus machen ?
Ich hab es so verstanden, dass das in zeichnen reinkommt.
Wie auch immer, die Formeln, die du hast, hab ich gar nicht von dem bekommen. Der war so beschäftigt und hat ständig hoch und runter gescrollt, dass ich nicht dazu gekommen bin.

Jetzt mal zu deinem Code.
Weshalb rechnest du 200.0 + (...) ?
Ich verstehe jetzt nicht, wo du die 3/8 z.B. hernimmst.
Zu dem Typecast-Kram hab ich das hier gefunden, keine Ahnung, ob's hilft.

EDIT: Ich meine, so, wie ich es berechne geht es ja auch, es wird normal gezeichnet, aber ich muss doch irgendwie von den Koordinaten auf die neuen kommen. Reicht es
" + r * Math.cos((7/8+grad/360) * (2*Math.PI)); " usw. hinzuzufügen ?
Deine Rechnung hat mich jetzt verwirrt ^^

 

[Fabi12346]

Hi nochma,
Ja die Formel ist x=ap + r*cos(winkel). Und y=ap +r*sin(winkel)

Die 1/8 3/8 5/8 7/8
sind für die ausgangspunkte also 1/8 ist oben rechts vom mittelpunkt usw...
Ich glaub ich mach jetzt nix mehr morgen hat sowieso wieder keiner was

 

[Jats]

Sorry, dass ich nochmal frage, aber was ist jetzt p ?
Ist das der alte oder der neue Punkt und ist die Formel für den neuen oder den alten Punkt ?

 

[Fabii]

Ap hab ich für alter punkt geschrieben , also so hab ich die formel dann gefunden irgendwo