transformationsmatrix immer zurücksetzen?

[Jokeman]

zuerst wollte ich jede transformation, die ich anklicke mit meiner transformationsmatrix multiplizieren und dann in der draw methode immer von der originalen vertexTable die transformierten vertices ausrechnen und sie zeichnen...

doch eigentlich ist dies doch relativ zeitaufwändig, weil ich die koordinaten von transformed bei jedem aufruf von draw wieder durch die aus vertexTable ersetzen muss, um sie dann neu zu transformieren...


1: for(int i = 0; i < anzVertex; i++)
2: {
3: transformed[i] = vertexTable[i];
4: vertexTM.transformPoint(transformed[i]);
5: }


da wäre es doch effizienter, die matrix bei jedem klicken zurückzusetzen und mit der neuen transformation zu füttern.
dann kann man immer von der vorigen position der transformierten vertices die neuen berechnen, ohne sie zuerst wieder auf die originalen zu setzen (zeile 3 würde wegfallen)


welche der 2 varianten habt ihr verwendet?

[Filz]

Du kannst auch einfach die Methode
M.transformPoints(anzVertex,vertexTable,transforme d)
verwenden, dann ersparst du dir die FOR-Schleife und das doppelte Zuweisen...

[Jokeman]

oh...

das is wohl war... THX für den hinweis... das is natürlich noch eleganter :)

[Usher]

public void transformPoint(double[] pt)
{
double x=pt[0], y=pt[1], z=pt[2];

for (int j=0; j<3; j++)
pt[j] = m[j][0]*x + m[j][1]*y + m[j][2]*z + m[j][3];
}

--> das ist ein Auszug aus dieser 4x4 Matrix-Klasse...

Es ist schon abend, und ich hab vielleicht längst den Verstand verloren....deswegen stellt sich mir folgende Frage:

Was nützt das, wenn man dieser Methode transformPoint ein Array pt mitgibt, den Inhalt dieses Arrays in einer Schleife auf irgendwelche Werte setzt, das Array aber nach Beendigung der Methode gleich ist wie beim Aufruf?
In Java übergibt man doch keine Zeiger oder? neee....
Und dieses pt ist auch keine globale Variable? neee....

Wie kann sich das dann aufs Programm auswirken, wenn man diesem pt (, das doch java-intern nur eine Kopie sein sollte, von dem Argument, das man der Methode mitgibt,) irgendeine Variable übergibt? Ist die Variable nicht nach Beendigung der Methode, egal, was man innerhalb der Methode damit anstellt, gleich wie vor dem Aufruf?

Für eine Aufklärung wäre ich sehr dankbar ;o)

[Filz]

Original geschrieben von Usher

Was nützt das, wenn man dieser Methode transformPoint ein Array pt mitgibt, den Inhalt dieses Arrays in einer Schleife auf irgendwelche Werte setzt, das Array aber nach Beendigung der Methode gleich ist wie beim Aufruf?

In Java übergibt man doch keine Zeiger oder? neee....


Ich glaube schon, dass das pt hier wie ein Zeiger wirkt, du übergibst ihm ja nur den Namen (bzw. die Speicher-Position) des Arrays -
zum Beispiel transformPoint( Punkt )
- es wird dann erst in der Methode selbst darauf mit pt [ x ] (also Punkt [ x ] ) darauf zugegriffen und so das echte Element referenziert.

(Ist allerdings nur meine Interpretation, keine Ahnung ob das so genau stimmt)

Florian

[Usher]

Danke, ich werd das checken sobald ich Zeit habe.
Vielen Dank für die Reaktion :)

[Usher]

Ich werd deppat.
Das geht wirklich. Ich muss wohl meine Java-Argument-Übergabe ein bisschen (sehr) überdenken.

Hab's gerade ausprobiert mit einem Test-programm.


public class Test extends EprogIO
{
public static void main (String[] args) throws EprogException
{
double[] speicher = new double[3];

Zeiger p = new Zeiger();
p.zeigerTesten (speicher);

println (speicher[2]);
}
}

class Zeiger
{
public void zeigerTesten (double[] z)
{
for (int i=0; i < 3; i++)
z[i] = i+7;
}
}


Speicher[2] hat dann wirklich den Wert 9 gehabt...
Wenn man die Methode zeigerTesten nicht aufruft, hat Speicher[2] den Wert 0.0
Echt interessant...

[Filz]

Also dass es auf jeden Fall funktioniert, hätte ich dir auch schnell so sagen können :)

[Deep Thought]

Um das Thema wieder auf den richtigen Thread zu lenken...
Es ist nicht sinnvoll, die Punkte bei jeder Transformation zu berechnen und diese Punkte dann weiterzuverwenden, da Rotationen immer um die eigene Achse durchgeführt werden sollen. Nach deiner Methode kann eine Rotation nach einer Translation durchgeführt werden, damit würde das Objekt aber um den Weltursprung rotieren.

Wegen der Performance:
Der große Vorteil der Matrizen ist, dass man zusammengesetzte Operationen mit einer Matrix darstellen kann. Das heißt es dauert genau gleich lang die Punkte mit allen bisher durchgeführten Transformationen umzurechnen, wie das Zwischenergebnis mit einer neuen Transformationsmatrix.

[Filz]

Eine Möglichkeit ist, dass man bei den Button-Klicks einfach nur den Gesamtwert der Transformationen als Zahl speichert (also scaleX=;scaleY=;scaleZ=;rotateX=;....)

und dann direkt vorm Draw-Aufruf mit

transMatrix.setIdentity();
transMatrix.scale(sx,sy,sz);
transMatrix.rotateX(rx);
transMatrix.rotateY(ry);
transMatrix.rotateZ(rz);
transMatrix.translate(tx,ty,tz);
transmatrixTransformPoints(.....)

die Punkte neu berechnet.

[Jokeman]

Original geschrieben von Deep Thought
Um das Thema wieder auf den richtigen Thread zu lenken...
Es ist nicht sinnvoll, die Punkte bei jeder Transformation zu berechnen und diese Punkte dann weiterzuverwenden, da Rotationen immer um die eigene Achse durchgeführt werden sollen. Nach deiner Methode kann eine Rotation nach einer Translation durchgeführt werden, damit würde das Objekt aber um den Weltursprung rotieren.

nach meiner methode wird eine rotation tatsächlich teilweise nach einer translation durchgeführt... natürlich muss ich dann zuerst in den ursprung zurückverschieben...
dies is aus performancegründen auf jeden fall besser, weil ich dann mit nur einer matrix arbeiten kann und nicht mit einer rotations/skalierungs und einer translations matrix multiplizieren muss

Original geschrieben von Deep Thought
Wegen der Performance:
Der große Vorteil der Matrizen ist, dass man zusammengesetzte Operationen mit einer Matrix darstellen kann. Das heißt es dauert genau gleich lang die Punkte mit allen bisher durchgeführten Transformationen umzurechnen, wie das Zwischenergebnis mit einer neuen Transformationsmatrix.

das is mir natürlich klar... ich hab auch nicht gemeint, die performance ist schlechter, weil ich alle transformationen ausführe, sonden weil ich (wie oben beschrieben) jedes mal das transformed array auf die originalkoordinaten setzen muss, was bei komplexeren objekten durchaus relativ lange dauern kann...
aber mit der methode M.transformPoints(anzVertex,vertexTable,transforme d) erledigt sich das problem

[Deep Thought]

So geht's natürlich auch, ich hab die einzelnen Matrizen dann miteinander multipliziert und auf diesem Weg eine erhalten, durch die ich die Punkte schleuse.

[Jokeman]

stimmt... is auch eine möglichkeit