Moin,
ich muss gerade bei meiner Viewing Pipeline die Matrix für den Übergang von den View Reference Coordinates in den Einheitswürfel machen allerdings ist
die Matrix die in meiner Methode rauskommt verschieden von der Musterlösung…
hat jemand eine Idee woran das liegen könnte ich sehe den Fehler nicht!
*
*/
package model;
/**
* Repräsentiert die synthetische Kamera der Viewing-Pipeline. Enthält alle
* Methoden zur Berechnung der nötigen Matrizen und aus Convenience Gründen auch
* die zum Mapping auf das Device.
*
* @author Nicolas Neubauer
*
*/
public class Camera {
private Vertex eyePoint; // =prp
private Vertex lookAtPoint; // =vrp
private Vertex upVector; // vuv
private double dmin; // Abstand zur Nearplane
private double dmax; // Abstand zur Farplane
private double fov; // Blickwinkel in Grad (=Field of View)
private double aspect; // Seitenverhältnis
private int xsize; // Breite des Ausgabegeräts in Pixeln
private int ysize; // Höhe des Ausgabegeräts in Pixeln
/**
* Erstellt eine neue Kamera
*
* @param eyePoint
* @param lookAtPoint
* @param upVector
* @param fov
* @param xsize
* @param ysize
* @param near
* @param far
*/
public Camera(Vertex eyePoint, Vertex lookAtPoint, Vertex upVector,
double fov, int xsize, int ysize, double near, double far) {
this.eyePoint = eyePoint;
this.lookAtPoint = lookAtPoint;
this.upVector = upVector;
this.fov = fov;
this.xsize = xsize;
this.ysize = ysize;
this.dmin = near;
this.dmax = far;
this.aspect = xsize / (double) ysize;
}
/**
* Berechnet die Matrix zur Transformation aus den Weltkoordinaten in die
* View-Reference-Koordinaten auf Basis der angegeben Kameradaten
*
* @return die Matrix
*/
public Matrix WC2VRC() {
// N ist ein Basisvektor für das VRC Koordinatensystem.
Vertex N = eyePoint.minus(lookAtPoint);
// V ist ein weiterer Basisvektor.
Vertex V = N.crossProduct(upVector).crossProduct(N);
// U ist der letzte Basisvektor.
Vertex U = V.crossProduct(N);
//einmal alle Basisvektoren normieren.
U.normalize();
V.normalize();
N.normalize();
double[][] neueBasis = { {U.x, U.y, U.z, U.w} , {V.x,V.y, V.z, V.w} , {N.x, N.y, N.z, N.w} , {lookAtPoint.x, lookAtPoint.y, lookAtPoint.z, lookAtPoint.w} };
Matrix transMat = new Matrix(neueBasis);
transMat.invert();
return transMat ;
}
/**
* Berechnet die Matrix zur Transformation aus dem
* View-Reference-Koordinatensystem in das
* Normalized-Projection-Koordinatensystem auf Basis der angegebenen
* Kameradaten
*
* @return die berechnete Matrix
*/
public Matrix VRC2NPC() {
double [][] helpArray = { {1.0,0.0,0.0,0.0} , {0.0,1.0,0.0,0.0} , {0.0,0.0,1.0,0.0}, {0.0,0.0,-14.697,1.0}};
Matrix helpMat = new Matrix(helpArray);
Vertex newEyePoint = helpMat.multiply(eyePoint);
//jetzt muss der Augenpunkt in den Koordinatenursprung des VRC Koordinatensystems geschoben werden.
Matrix transUrsprung = Matrix.createIdentity(4);
transUrsprung.setValue(3, 3, -14.697);
double[][] ersteSpiegelung = { {1.0,0.0,0.0,0.0} , {0.0,1.0,0.0,0.0} , {0.0,0.0,-1.0,0.0} , {0.0,0.0,0.0,1.0} } ;
Matrix firstRefl = new Matrix (ersteSpiegelung);
// der Abstand zur View Plane.
double abstand = eyePoint.minus(lookAtPoint).norm();
double maxX = Math.tan((2 * Math.PI / 360) * 22.5 / 2.0) * abstand;
double minX = - maxX;
double maxY = (480.0 / 640.0) * maxX;
double minY = - maxY;
double[][] transMat = { {abstand/(maxX-minX),0.0,0.0,0.0} , {0.0,abstand/(maxY-minY),0.0,0.0} , {0.5 * (1.0-((maxX+minX)/(maxX-minX))),0.5 * (1.0-((maxY+minY)/(maxY-minY))), 100.0 / (100.0 - 0.1),1.0} , {0.0,0.0, (-100.0 * 0.1) /(100.0-0.1),0.0}};
Matrix transform = new Matrix (transMat);
double [][] transLation = { {1.0,0.0,0.0,0.0}, {0.0,1.0,0.0,0.0}, {0.0,0.0,1.0,0.0}, {0.0,0.0,-1.0,1.0}};
Matrix zweiteTranslation = new Matrix (transLation);
Matrix gesamtMatrix = firstRefl.multiply(zweiteTranslation).multiply(transform).multiply(firstRefl).multiply(transUrsprung);
System.out.println(gesamtMatrix.toString());
// diese Matrix sollte rauskommen !!!
// 2.514 0.0 -0.5 7.348
// 0.0 3.352 -0.5 7.348
// 0.0 0.0 0.001 0.085
// 0.0 0.0 -1.0 14.697
return null;
}
/**
* Berechnet die Transformationsmatrix vom NPC in das
* Device-Koordinatensystem
*
* @return die berechnete Matrix
*/
public Matrix NPC2DC() {
//Noch zu implementieren
return null;
}
/**
* Die Methode setzt den Augenpunkt der Kamera.
*/
public void setEyePoint() {
}
/**
* die Methode liefert den Augenpunkt der Kamera zurück.
* @return
*/
public Vertex getEyePoint() {
return this.eyePoint;
}
}
mit freundlichen Grüßen:) (Im Anhang nochmal das ganze kleine Projekt als jar-File)
*** Edit ***
hat sich schon erledigt ich hatte die Matrizen nur in der falschen Reihenfolge multipliziert
