[2D theorie] rotatie figuur X en Y as

[Nexopheus]

Ik ben bezig met een progje dat een simpel figuur laat roteren over respectievelijk zijn x en y as.

Nu heb ik de verschillende transformatie matrices gemaakt, en deze werken allemaal......behalve...juist de x en y as rotaties.

ik gebruik homogene coordinaten.
de x-as rotatie matrix ziet er als volgt uit:

code:

 1 0    0
 0 cos  sin
 0 -sin cos

De rotatie om de Z-as gaat wel goed. (dwz rotatie van rechts naar links over de oorsprong aangezien de Z-as een lengte van 1 heeft).

Voorbeeldje:
Start, figuur van 50x50 met als startcoordinaat 0,0

[img]http://www.xs4all.nl/~phbkn/start.jpg[\img]
[afbeelding]


Na 10graden rotatie over X-as"

[img]http://www.xs4all.nl/~phbkn/rotateX.jpg[\img]
[afbeelding]

Wat gaat hier nu fout? Kan het niet voor elkaar krijgen.
Heb al verschillende translaties geprobeerd, maar blijf dit rare resultaat krijgen.

[ Voor 10% gewijzigd door Nexopheus op 03-03-2003 20:26 . Reden: IMG tag schijnt niet helemaal te werken! ]

[MisterData]

Ik had een dergelijk probleem ook... ik geloof dat ik een cos ipv een -cos had neergezet ergens (ik doe een software 3d engine dus vergelijkbaar).... probeer es met je matrix te spelen, dat lost het vast op

[Nexopheus]

De cos en sin waarden staan wel goed, getuige het feit dat de rotatie over de "Z" as wel goed gaat. Ik gebruik generieke methodes hiervoor:
Zie hieronder:

Java:

private static final int X = 0;
private static final int Y = 1;
private static final int Z = 2;


//Private rotatie generatie methode.
    private static Matrix rotateAxis(double angle, int a1, int a2){
        double sin = Math.sin(angle);
        double cos = Math.cos(angle);
        
        Matrix rotate = Matrix.transformation();
        rotate.matrix[a1][a1] = cos;
        rotate.matrix[a1][a2] = -sin;
        rotate.matrix[a2][a2] = cos;
        rotate.matrix[a2][a1] = sin;        
        
        return rotate;
    }
    
    /**
    * Rotatie matrix
    * Transformatie-matrix voor een rotatie om de x-as.
    * @param angle Aantal radialen waarover geroteerd dient te worden.
    * @return Een transformatie-matrix.
    */
    public static Matrix rotateX(double angle){
        return rotateAxis(angle, Y, Z);
    }
    
    /**
    * Rotatie matrix
    * Transformatie-matrix voor een rotatie om de y-as.
    * @param angle Aantal radialen waarover geroteerd dient te worden.
    * @return Een transformatie-matrix.
    */
    public static Matrix rotateY(double angle){
        return rotateAxis(angle, X, Z);
    }
    
    /**
    * Rotatie matrix
    * Transformatie-matrix voor een rotatie om de z-as.
    * @param angle Aantal radialen waarover geroteerd dient te worden.
    * @return Een transformatie-matrix.
    */
    public static Matrix rotateZ(double angle){
        return rotateAxis(angle, X, Y);
    }
    

[ Voor 4% gewijzigd door Nexopheus op 03-03-2003 21:45 . Reden: Toevoegen const. XYZ ]

[Soultaker]

Debug-print de Matrix die rotateX retourneert eens? Als die gewoon correct is, en je hebt de vermenigvuldiging goed geïmplementeert, zou alles goed moeten zijn. Plaats de code daarvan anders ook eens.

[Nexopheus]

De transformatie matrix voor de rotatie over de X-as ziet er met 10 graden rotatie als volgt uit:

code:

     [java] -----------------------------
     [java] | 1.0, 0.0, 0.0 |
     [java] | 0.0, 0.984807753012208, -0.17364817766693033 |
     [java] | 0.0, 0.17364817766693033, 0.984807753012208 |
     [java] -----------------------------

!edit Ter aanvulling.
Ik heb dus een "world" object die representeerd het assenstelsel, het figuur transleer ik wanneer ik ga tekenen dus terug "omhoog" naar de wereld.

Het gekke is dat alle andere matrix operaties goed gaan.
shear,
transformatie.
rotatie over de oorsprong.

[ Voor 29% gewijzigd door Nexopheus op 03-03-2003 20:44 ]

[Harmsen]

Gezien je screenshots doe je dit in Java. Wij hebben dit voor school ongever ook moeten doen, na wat gepruts met Graphics2D en de rotate functie daarvan zijn we toch via een andere manier gaan werken.

Ik heb toen een tutorial gevonden die een paar leuke functies hadden

bron : http://www.programming.de/java_tutorial/j_tutor20.html

de functies waar het om gaan zijn dan :

Java:

int rotate_x(int x, int y)
    {
        return ((int) (cx + x * cos - y * sin));
    }

    int rotate_y(int x, int y)
    {
        return ((int) (cy + y * cos + x * sin));
    }

    void SetAngle(double a)
    {
        radians = (a * 2 * Math.PI) / 360;

        cos = Math.cos(radians);
        sin = Math.sin(radians);
    }

    void RotatePolygon(int x[], int y[], int n)
    {
        int new_x[] = new int [n];
        int new_y[] = new int [n];

        for(int i=0; i<n; i++)
        {
            new_x[i]=rotate_x(x[i], y[i]);
            new_y[i]=rotate_y(x[i], y[i]);
        }

        gBuffer.fillPolygon(new_x, new_y, n);
    }

Hopelijk kan je hier iets mee, de code op die site is makkelijk te begrijpen al zeg ik het zelf en ik neem aan dat je niet een beginner bent in Java zoals ik.

[Nexopheus]

Bedankt voor je input, maar als je kijkt naar

Java:

int rotate_x(int x, int y)
    {
        return ((int) (cx + x * cos - y * sin));
    }

    int rotate_y(int x, int y)
    {
        return ((int) (cy + y * cos + x * sin));
    }

En je zet dit in een matrix vorm, kom je uit op de matrix die ik hierboven ergens heb gezet.

Verder wil ik geen standaard API gebruiken zoals Graphics2D oid,. (deze heeft bijvoorbeeld ook een translate methode....)

[Soultaker]

Nexopheus schreef op 03 March 2003 @ 20:42:
De transformatie matrix voor de rotatie over de X-as ziet er met 10 graden rotatie als volgt uit:

code:

     [java] -----------------------------
     [java] | 1.0, 0.0, 0.0 |
     [java] | 0.0, 0.984807753012208, -0.17364817766693033 |
     [java] | 0.0, 0.17364817766693033, 0.984807753012208 |
     [java] -----------------------------

Dat ziet er prima uit. Plaats je code voor de vermenigvuldiging van de vector met de matrix ook eens? En de uitvoer wanneer je er (bijvoorbeeld) (50, 0, 100), (50, 100, 0) en (50, 100,100) in stopt?

[Nexopheus]

mmmm, de resultaten die ik uiteindelijk krijg schieten het dak uit!

hier het gehele verloop:

code:

[java] Transformatie naar de wereld:
     [java] Matrix parent:
     [java] -----------------------------
     [java] | 1.0, 0.0, 0.0 |
     [java] | 0.0, 1.0, 0.0 |
     [java] | 0.0, 0.0, 1.0 |
     [java] -----------------------------
     [java] 
     [java] Deze vermenigvuldigen met.....
     [java] -----------------------------
     [java] | 1.0, 0.0, 0.0 |
     [java] | 0.0, 0.984807753012208, -0.17364817766693033 |
     [java] | 0.0, 0.17364817766693033, 0.984807753012208 |
     [java] -----------------------------
     [java] 
     [java] Geeft als resultaat:
     [java] -----------------------------
     [java] | 1.0, 0.0, 0.0 |
     [java] | 0.0, 0.984807753012208, -0.17364817766693033 |
     [java] | 0.0, 0.17364817766693033, 0.984807753012208 |
     [java] -----------------------------
     [java] 
     [java] Totale translatie matrix naar de wereld:
     [java] -----------------------------
     [java] | 1.0, 0.0, 0.0 |
     [java] | 0.0, 0.984807753012208, -0.17364817766693033 |
     [java] | 0.0, 0.17364817766693033, 0.984807753012208 |
     [java] -----------------------------
     [java] 
     [java] Nu translatie van de basispunten van de figuur
     [java] Totale transformatie matrix:.....
     [java] -----------------------------
     [java] | 1.0, 0.0, 0.0 |
     [java] | 0.0, 0.984807753012208, -0.17364817766693033 |
     [java] | 0.0, 0.17364817766693033, 0.984807753012208 |
     [java] -----------------------------
     [java] 
     [java] Deze vermenigvuldigen met.....
     [java] -----------------------------
     [java] | 0.0, 0.0, 50.0, 50.0, 0.0 |
     [java] | 0.0, 50.0, 50.0, 0.0, 0.0 |
     [java] | 1.0, 1.0, 1.0, 1.0, 1.0 |
     [java] -----------------------------
     [java] 
     [java] Geeft als resultaat:
     [java] -----------------------------
     [java] | 0.0, 0.0, 50.0, 50.0, 0.0 |
     [java] | -0.17364817766693033, 49.06673947294347, 49.06673947294347, -0.17364817766693033, -0.17364817766693033 |
     [java] | 0.984807753012208, 9.667216636358724, 9.667216636358724, 0.984807753012208, 0.984807753012208 |
     [java] -----------------------------
     [java] 
     [java] Nu transformeren naar het scherm toe
     [java] Scherm transformator: 
     [java] -----------------------------
     [java] | 1.0, 0.0, 200.0 |
     [java] | 0.0, -1.0, 150.0 |
     [java] | 0.0, 0.0, 1.0 |
     [java] -----------------------------
     [java] 
     [java] Deze vermenigvuldigen met.....
     [java] -----------------------------
     [java] | 0.0, 0.0, 50.0, 50.0, 0.0 |
     [java] | -0.17364817766693033, 49.06673947294347, 49.06673947294347, -0.17364817766693033, -0.17364817766693033 |
     [java] | 0.984807753012208, 9.667216636358724, 9.667216636358724, 0.984807753012208, 0.984807753012208 |
     [java] -----------------------------
     [java] 
     [java] Geeft als resultaat:
     [java] -----------------------------
     [java] | 196.9615506024416, 1933.4433272717447, 1983.4433272717447, 246.9615506024416, 196.9615506024416 |
     [java] | 147.89481112949812, 1401.0157559808652, 1401.0157559808652, 147.89481112949812, 147.89481112949812 |
     [java] | 0.984807753012208, 9.667216636358724, 9.667216636358724, 0.984807753012208, 0.984807753012208 |
     [java] -----------------------------
     [java]

Er gaat dus ergens iets gigantisch mis met de vermenigvuldiging....

!edit
Hier de vermenigvuldiging methode:

Java:

public Matrix multiply(Matrix arg){
        Matrix result;        
        double sum;
        if(this.cols != arg.rows)            
            return null;
        
        result = (Matrix) this.clone(this.rows,arg.cols);
        for(int i = 0; i< this.rows;i++)
            for(int j=0;j<arg.cols;j++){
                sum = 0.0;
                for(int k = 0; k < this.cols;k++)
                    sum += this.matrix[i][k] * arg.matrix[k][j];
                result.matrix[i][j] = sum;            
            }
        return result;            
    }  

[ Voor 11% gewijzigd door Nexopheus op 03-03-2003 21:11 ]

[Nexopheus]

Soultaker schreef op 03 maart 2003 @ 20:53:
[...]

Dat ziet er prima uit. Plaats je code voor de vermenigvuldiging van de vector met de matrix ook eens? En de uitvoer wanneer je er (bijvoorbeeld) (50, 0, 100), (50, 100, 0) en (50, 100,100) in stopt?

Die vertices zijn 3D! ik gebruik enkel de "z" voor het homogeen maken van de vector. -->

Java:

Vertex A = new Vertex("A",0,0);
Vertex B = new Vertex ("B",0,100);
Vertex C = new Vertex("C",100,100);
Vertex D = new Vertex("D",100,0);

[....connecties maken ed...]
geeft als matrix
(0, 0, 100, 100)
(0, 100, 100, 0)    
(1, 1, 1, 1 )

[ Voor 12% gewijzigd door Nexopheus op 03-03-2003 21:34 ]

[Nexopheus]

Ok, doet het nu zoals het moet.
rotatiematrix: (X)

code:

(1, 0, 0)
(0,cos,0)
(0,0,1)

Raar, maar waar.

[dusty]

Een (absolute) matrix opstellen voor een rotatie is vaak beter dan het met cos/sin "ter plekke" te berekenen (juist vanwege de afrondings verschijnselen) die je dus kunt vermijden door juist gebruik te maken van een matrix. Dus matrix zonder cos/sin erin. Maar absolute getallen. Hierdoor kan je verplaatsingen krijgen die exact op een punt vallen en niet tussen twee verschillende beeldscherm punten.

[ Voor 33% gewijzigd door dusty op 03-03-2003 22:16 ]

[Nexopheus]

Dat doe ik ook! zie post hierboven./
De matrix die daar staat is mijn rotatie matrix.

[dusty]

Nexopheus schreef op 03 maart 2003 @ 22:15:
Dat doe ik ook! zie post hierboven./
De matrix die daar staat is mijn rotatie matrix.

Ik zie een (cos) erin, dus gebruik je actief een cos (en reken je dus de cos "ter plekke" uit)

(was net bezig om het woordje absoluut bij mijn vorige post te zetten..)

[Nexopheus]

In mijn matrix class wordt de cos gebruikt.
Aan de hand van het aantal graden dat geroteerd dient te worden genereer ik in die klasse een transformatie matrix. En dat kan toch niet echt zonder de cosines.....toch.?

!edit Zie hier de JBuilder (no comments please) generated html van de source/
[ Matrix.java ]

[ Voor 27% gewijzigd door Nexopheus op 03-03-2003 22:25 ]

[EfBe]

Een oude lame java applet van me: http://www.xs4all.nl/~perseus/zoom/zoom.html
(de source staat er ook)

snippet uit de 2D rotate routine (waar jij om vraagt)

Java:

void    rotate_it()
{
    double  gamma_rad;
    double  sin_g;
    double  cos_g;

    double  xn,yn;
    double  xn2,yn2;

    int i;

    // first update the angle. only gamma is interesting...
    gamma=(gamma+dgamma)%360;

    gamma_rad=(gamma/360)*2*Math.PI;
        
    // get the sin and cos of the angles

    sin_g=Math.sin(gamma_rad);      
    cos_g=Math.cos(gamma_rad);      

    // now rotate the coords...
    for(i=0;i<num_of_coords;i++)
    {
        yn=ys_coords[i];
        xn=xs_coords[i];

        xd_coords[i]=(xn*cos_g) - (yn*sin_g);
        yd_coords[i]=(yn*cos_g) + (xn*sin_g);
    }
}

xd_coords en yd_coords zijn de destination arrays voor de geroteerde punten, xs_coords en ys_coords zijn de source arrays voor de origin punten. Je roteert dus altijd vanuit de source. Daar heb je echt geen matrices voor nodig, gewoon 2 euler formuletjes

Enjoy.

[EfBe]

dusty schreef op 03 March 2003 @ 22:14:
Een (absolute) matrix opstellen voor een rotatie is vaak beter dan het met cos/sin "ter plekke" te berekenen (juist vanwege de afrondings verschijnselen) die je dus kunt vermijden door juist gebruik te maken van een matrix. Dus matrix zonder cos/sin erin. Maar absolute getallen. Hierdoor kan je verplaatsingen krijgen die exact op een punt vallen en niet tussen twee verschillende beeldscherm punten.

Euler lock doet zich niet voor in 2D dacht ik. In 3D heb je gelijk, maar dan ga je toch liever Quaternions gebruiken ipv euler based matrices. Dit is een 2D dingetje, dat roteren is 2 formuletjes.

[ Voor 2% gewijzigd door EfBe op 03-03-2003 22:51 . Reden: jaja het is lang geleje, deternions bestaan niet, quaternions wel ]

[Nexopheus]

Wanneer je deze code

Java:

xd_coords[i]=(xn*cos_g) - (yn*sin_g); 
yd_coords[i]=(yn*cos_g) + (xn*sin_g); 

(stelsel van vergelijkingen) in matrix vorm zet

dus. stelsel is:

x' = x * cos(hoek) - y * sin (hoek)
y' = y * cos(hoek) + x * sin(hoek)

[x'] [cos, -sin, 0] [x]
[y'] = [cos, sin, 0] * [y]
[1] [0,0,1] [z]

[layout is fucked-up grrr]
De matrix vermenigvuldiging doet dus exact het zelfde

[ Voor 7% gewijzigd door Nexopheus op 03-03-2003 22:52 ]

[EfBe]

klopt, de matrix uitgeschreven is dit setje formules. maar arrays zijn niet fijn in java, dus die formules leveren meer op, zeker in 2D

[Nexopheus]

Uiteraard is de methode die je me voorlegt een stuk sneller. Het gaat me echter om de lineaire algebra (incl. de matrices) te oefenen....

Nog iets wat je me mischien kan vertellen, hoe kom ik nu aan die absolute waarden ???
bij rotaties over een kleine hoek, is de cos bijna gelijk aan 1, dus die kan eventueel weg(?)...

Shine your light!

[EfBe]

welke absolute waarden bedoel je? De resultaatcoordinaat?

[Nexopheus]

dusty schreef op 03 March 2003 @ 22:14:
[......]
Dus matrix zonder cos/sin erin. Maar absolute getallen. Hierdoor kan je verplaatsingen krijgen die exact op een punt vallen en niet tussen twee verschillende beeldscherm punten.

Deze bedoel ik, je noemde Euler-lock in 1 van je vorige posts ...

[Verwijderd]

Nexopheus schreef op 03 March 2003 @ 21:00:
....

code:

     [java] Nu translatie van de basispunten van de figuur
     [java] Totale transformatie matrix:.....
     [java] -----------------------------
     [java] | 1.0, 0.0, 0.0 |
     [java] | 0.0, 0.984807753012208, -0.17364817766693033 |
     [java] | 0.0, 0.17364817766693033, 0.984807753012208 |
     [java] -----------------------------
     [java] 
     [java] Deze vermenigvuldigen met.....
     [java] -----------------------------
     [java] | 0.0, 0.0, 50.0, 50.0, 0.0 |
     [java] | 0.0, 50.0, 50.0, 0.0, 0.0 |
     [java] | 1.0, 1.0, 1.0, 1.0, 1.0 |
     [java] -----------------------------
     [java] 
     [java] Geeft als resultaat:
     [java] -----------------------------
     [java] | 0.0, 0.0, 50.0, 50.0, 0.0 |
     [java] | -0.17364817766693033, 49.06673947294347, 49.06673947294347, -0.17364817766693033, -0.17364817766693033 |
     [java] | 0.984807753012208, 9.667216636358724, 9.667216636358724, 0.984807753012208, 0.984807753012208 |
     [java] -----------------------------
     [java]

Er gaat dus ergens iets gigantisch mis met de vermenigvuldiging....
.........

Wat doet die 3x5 matrix???

Maar volgens mij moet je je vector andersom uitlezen.
Er staat nu:: (voor punt (50,50))

code:

|50|
|50|
| 1 |

Maar dit zou volgens mij het volgende moeten zijn::

code:

| 1 |
|50|
|50|

Als ik deze vector vermenigvuldig met rotatie matrix, kom ik wel op het juiste punt uit.

[Nexopheus]

Nee hoor, voor dat punt klopt het wel. Dat zijn homogene coordinaten.
dus

code:

[x]
[y] 
[1]

De 3x5 matrix (is nu overigens 3*4) is het figuur dat getekend wordt.
(in homogene coordinaten)

[ Voor 33% gewijzigd door Nexopheus op 03-03-2003 23:26 ]

[SuperRembo]

Ik denk dat je probleem eerder ligt bij de projectiematrix, hoe kom je aan dat ding?

code:

Scherm transformator: 
| 1.0,  0.0, 200.0 |
| 0.0, -1.0, 150.0 |
| 0.0,  0.0,   1.0 |

Projectie op vlak loodrecht op de z-as, daarna schaling van x- en y-as:

code:

| 200,   0, 0 |
|   0, 150, 0 |
|   0,   0, 0 |

[ Voor 29% gewijzigd door SuperRembo op 03-03-2003 23:42 ]

[Nexopheus]

Dat ding is de transformatie matrix naar mij assenstelsel.
Dit assenstelsel heeft zijn oorsprong op 200,150 (scherm coordinaten) en
de -1 zorgt ervoor dat de y-as geinverteerd wordt.
Op deze manier creeer ik een assenstelsel waarmee ik verder ga werken.

De structuur die getekend wordt is een "kind" van dit assenstelsel. Voordat ik de structuur kan tekenen moet ik deze eerst nog transformeren naar zijn "parent" toe, in dit geval dus het assenstelsel.

[SuperRembo]

Aha, maar dan moet je het zo doen:

code:

|x_scherm|   |200|   |1  0  0| |x|
|y_scherm| = |150| + |0 -1  0|*|y|
|z_scherm|   |  0|   |0  0  0| |z|

[Nexopheus]

leg eens uit....

[SuperRembo]

De 3x1 kolom zorgt voor de translatie (verschuiving).
De 3x3 matrix zorgt voor de projectie op het xy-vlak en de spiegeling t.o.v. de y-as.
Zo komt de oorsprong (0,0,0) dus ook op (200,150) op je scherm.

[Nexopheus]

Aha, Ok.

PS ik werk niet in 3D dus het punt (0,0,0) bestaat niet.
dat is bij mij (0,0,1).

[SuperRembo]

Waarom gebruik je dan z=1 en niet gewoon z=0
En waarom wil je om de x-as roteren als je in 2D werkt? Wil je gewoon in het vlak van het scherm roteren (met de klok mee / tegen de klok in)?

[Nexopheus]

z = 1 gebruik ik om de coordinaten homogeen te maken zodat de matrix vermenigvuldigingen in serie doorlopen kunnen worden.
[bijv] translatie, rotate, scale, translatie.....

Ik wil graag om de x-as van het figuur roteren (en Y-as ook overigens) omdat dit een opdracht van school (was/is).
Ik keek er ook raar tegenaan, en ben dus ook een hele tijd aan het kutten geweest om de "rotatie" voor elkaar te krijgen.

Het is meer omklappen naar rechts-links of naar boven-onder, zodat de illusie gewekt wordt dat de structuur om zijn eigen as draait.

in een 3D wereld doet z gewoon mee als coordinaat, en werk ik met 4x4 transformatie matrices. [inderdaad ivm de homogene coordinaten]

[SuperRembo]

Ow, ik snap het al
Dus dit

code:

|x'|   |200|   |1  0  0| |x|
|y'| = |150| + |0 -1  0|*|y|
|z'|   |  0|   |0  0  0| |z|

is hetzelfde als dit

code:

|x'|   |1  0  200| |x|
|y'| = |0 -1  150|*|y|
| 1|   |0  0    1| |1|

Haal je die systemen ((x,y,z) en (x,y,1)) dan niet door elkaar?
Die rotatiematrix gaat uit van (x,y,z) coords, die andere transformatie gaat uit van (x,y,1).

[Nexopheus]

De matrix klasse gaat inderdaad uit van 3D, dus wellicht dat daar nog het een en ander aan gefixed moet worden. Zoals ik het nu geimplementeerd heb werkt het precies zoals ik het wil. [hopen dat de docenten daar ook zo over denken ].
zie Matrix.java

[Verwijderd]

Hoe kom ja aan die rotatie matrix?

code:

 1 0    0
 0 cos  sin
 0 -sin cos

moet dan de rotatie matrix niet als volgt zijn?

code:

 cos -sin 0
 sin  cos 0
   0    0   1

Dit omdat je de volgende vector gebruikt

code:

x
y
0

[Nexopheus]

nope, dat is de rotatie-matrix voor de rotatie over de oorsprong.

!Edit: Dus eingelijk over de Z-as.

[ Voor 24% gewijzigd door Nexopheus op 04-03-2003 00:22 ]

[Verwijderd]

Volgens mij gaat het fout omdat je gebruik maak van 3x3 matrices. Ik heb de berekening, om bijvoorbeeld het punt (50,50,0) 10 graden over de x as te roteren, gemaakt met 3x3 matrices (zoals je in 2d zou verwachten) en een keer met behulp van 4x4 matrices(zoals gebruikelijk is in 3d).

Het resultaat van het punt (50,50,0) 10 graden geroteerd over de x-as is, met 3x3 matrices (1786, 1253, 8.68). Dit komt aardig overeen met hetgeen dat jij als resultaat kreeg.

De zelfde berekening met 4x4 matrices geeft als resultaat (250,100, 8.68). Dit is het punt dat op het scherm afgebeeld zou moeten worden.

De berekening is als volgt:

Mv=T*S

P'=Mv*Rx*P

Waar Mv de transformatiematrix is van worldspace naar viewspace.
T is de translatie van de oorsprong van het scherm naar (200,15)
S vermenigvuldigt de Y waarde met -1

Rx is de rotatie matrix om de x-as
P is het oorspronkelijke punt.
P' is het punt op het scherm

3x3

code:

 P'=T*S*Rx*P

| x' |   | 1 0 200 |   | 1  0 0 |   | 1   0    0 |   | x |
| y' | = | 0 1 150 | * | 0 -1 0 | * | 0 cos -sin | * | y |
| z' |   | 0 0   0 |   | 0  0 1 |   | 0 sin  cos |   | z |

geeft als resultaat voor (50,50,0) bij een rotatie van 10 graden

| 1786.481776 |
| 1253.120944 |
| 8.682408883 |

Dezelfde berekening met 4x4 matrices

code:

 P'=T*S*Rx*P

| x' |   | 1 0 0 200 |   | 1  0 0 0 |   | 1   0    0  0 |   | x |
| y' | = | 0 1 0 150 | * | 0 -1 0 0 | * | 0 cos -sin  0 | * | y |
| z' |   | 0 0 1   0 |   | 0  0 1 0 |   | 0 sin  cos  0 |   | z |
| 1  |   | 0 0 0   1 |   | 0  0 0 1 |   | 0   0    0  1 |   | 1 |

geeft als resultaat voor (50,50,0) bij een rotatie van 10 graden

|    250   |
| 100.7596 |
| 8.682408 |
|     1    |

[EfBe]

Het is 2D dus je hebt een 2x2 matrix nodig, niet een 3x3.

[Nexopheus]

EfBe schreef op 04 March 2003 @ 08:59:
Het is 2D dus je hebt een 2x2 matrix nodig, niet een 3x3.

Nee, ik wil mnet homogene coordinaten werken dus heb ik matrices nodig in de vorm [Dimensie+1][Dimensoe+1]

-->DaMike...

mmmm interressant, zal het gelijk even op die manier proberen.

[EfBe]

Nexopheus schreef op 04 maart 2003 @ 09:21:
[...]
Nee, ik wil mnet homogene coordinaten werken dus heb ik matrices nodig in de vorm [Dimensie+1][Dimensoe+1]

Dit lijkt me larie. Je bent puur 2D bezig, je hebt dus niets aan 3D rotaties. Je projecteert de 3D rotatie-resultaten toch ook niet met een orthogonale projectie op je beeld, maar negeert gewoon de Z toch?

Als je de 6 Euler formules uitschrijft, dan zie je dat in de Y een z waarde wordt meegenomen. Echter die is 0, en die exponent is dus ook 0, voegt dus niets toe aan je berekening.

Je kunt ook quaternions (4D vectors) gebruiken, voegt net zo min iets toe. Wat je wilt uittesten werkt ook in 2D met 2x2 matrices. Als je 3D coords wil gebruiken, roteer dan een 3D object om 3 assen.

[Nexopheus]

Als jij het zegt.....ik ben in alle theorie die ik bestudeerd heb (ook 2D) alleen maar homogene coordinaten tegengekomen. Zodat (wat ik al eerder vermeld heb) series van matrix vermenigvuldingen uitgevoerd kunnen worden).

Verder gebruik ik geen euler formules maar enkel matrix-operaties, dus schalen, transformeren, transleren, roteren etc.

[Janoz]

EfBe schreef op 04 March 2003 @ 09:26:
[...]

Dit lijkt me larie. Je bent puur 2D bezig, je hebt dus niets aan 3D rotaties. Je projecteert de 3D rotatie-resultaten toch ook niet met een orthogonale projectie op je beeld, maar negeert gewoon de Z toch?

Als je de 6 Euler formules uitschrijft, dan zie je dat in de Y een z waarde wordt meegenomen. Echter die is 0, en die exponent is dus ook 0, voegt dus niets toe aan je berekening.

Je kunt ook quaternions (4D vectors) gebruiken, voegt net zo min iets toe. Wat je wilt uittesten werkt ook in 2D met 2x2 matrices. Als je 3D coords wil gebruiken, roteer dan een 3D object om 3 assen.

Beiden hebben gelijk.

Het is larie om cos en sin in de 3e kolom/rij neer te zetten waneer je met 2D bezig bent. In 2D is er maar 1 mogelijke rotatie. De door de TS gebruikte matrix slaat dus eigenlijk nergens op wat ook past bij het resultaat (je bent immers normalisatie waarden aan het roteren!)

Waarom toch dimensie +1 wordt gebruikt komt bv naar voren bij transleren. dan heb je een matrix als:

code:

1 0 dx
0 1 dy
0 0 1

Hieraan is trouwens ook mooi te zien waarom een vertex 1 als laatste component heeft en een vector 0. De laatste is namelijk ongevoelig voor transleren .

@TS

Het om verschillende assen draaien is (zoals ik al zei) onmogelijk in 2D. Wat jij van plan bent is eerder een heel simpele 3D projectie (zonder perspectief). Hiervoor zul je dus ook 3d math moeten gebruiken! Niks normalizatie invullen voor de Z maar gewoon een waarde. Anders krijg je idd dit soort effecten.

[Nexopheus]

Ok, ik ga er mee bezig..

!Edit:
Werkt als een tierelier! Gek genoek is dit gezelfde als wat ik eerst had.
DUs alleen maar cosinus op 0,0 voor x en 1,1 voor y.!

Thx voor de input!!

[ Voor 85% gewijzigd door Nexopheus op 04-03-2003 09:55 ]

[Janoz]

Da's ook niet geheel onlogisch. De projectie die je nu toepast is 'negeer z coordinaten'. Zoals ik al zei, een projectie zonder perspectief. de normale rotatie matrix in het 3d geval zou zijn:

code:

1,   0,   0,   0
0, cos, sin,   0
0,-sin, cos,   0
0,   0,   0,   1

Waneer je dus op voorhand al de Z negeert (door deze weg te laten. en het 4e component te verplaatsen naar de 3e positie) zou je van deze matrix slechts de 4 waardes links boven overhouden samen met de kolom + de rij van de normalisatie. Vandaar dat je alleen de cos nodig hebt.

Normaal zou je je punten door kunnen blijven roteren, maar aangezien jij je z-waardes negeert lukt dat niet in jou geval.

[Nexopheus]

Ja, het begint me allemaal te dagen, potlood, papier een geodriekhoek en rekenmachine zijn zeer krachtige tools

[EfBe]

translatie in 2D kan ok met een 2x2 matrix. Je kunt die nl. vermenigvuldigen met je rotatie matrix en dan en roteren en transleren in 1 keer. Je vectoren hebben nl. maar 2 elementen, dus je hebt nooit een 3x3 matrix nodig

[Janoz]

EfBe schreef op 04 maart 2003 @ 13:01:
translatie in 2D kan ok met een 2x2 matrix. Je kunt die nl. vermenigvuldigen met je rotatie matrix en dan en roteren en transleren in 1 keer. Je vectoren hebben nl. maar 2 elementen, dus je hebt nooit een 3x3 matrix nodig

Ok, mag ik van jou dan de 2x2 matrix waarmee ik een punt over (dx,dy) verplaats?

[EfBe]

uit mn blote hoofd:

code:

dx, 0
0  , dy

[.oisyn]

dat is een schaling, geen translatie
test: we gaan vector (1, 2) transleren over (4, 4), dus dan zou ie op (5, 6) uit moeten komen

code:

  *       [ 4  0 ]
          [ 0  4 ]

[ 1  2 ]  [ 4  8 ]

hmm, dat klopt niet echt

[EfBe]

EfBe schreef op 04 March 2003 @ 16:34:
uit mn blote hoofd:

[code]
dx, 0
0 , dy
[/code]

(Edit)
je hebt gelijk. Ik zat wat te prutsen hiermee, en ik kreeg de optelling niet in de matrix die als vermenigvuldiging wordt gebruikt. Dat lukt alleen met dx, dy op de laatste rij en Z=1, waardoor ze automatisch in de x en y worden meegenomen.

[T.T.]

nee EfBe,

code:

[2] * [dx , 0] = [2*dx, 2*dy]
[2]   [0,  dy]

Als je dus punt (2,2) zou willen verplaatsen met (3,4), dan kom je op (2*3, 2*4) = (6,8) uit.
Dat is een schaling.

met een 3x3 matrix kun je wel gewoon transleren over 3,4:

code:

[2]* [1 , 0, 3] = [2+3, 2+4, 1]
[2]  [0,  1, 4]
[1]  [0,  0, 1]

fuck te laat

[ Voor 10% gewijzigd door T.T. op 04-03-2003 16:46 ]

[.oisyn]

EfBe schreef op 04 maart 2003 @ 16:44:
je hebt gelijk. Ik zat wat te prutsen hiermee, en ik kreeg de optelling niet in de matrix die als vermenigvuldiging wordt gebruikt. Dat lukt alleen met dx, dy op de laatste rij en Z=1, waardoor ze automatisch in de x en y worden meegenomen.

u hebt zojuist het homogene coordinatenstelsel ontdekt

[EfBe]

.oisyn schreef op 04 March 2003 @ 16:47:
u hebt zojuist het homogene coordinatenstelsel ontdekt

hehe Ja dat krijg je als mensen met als specialisatie alles met databases iets met 3D gaan doen