3D Point to 2D Function Not Working Properly - math

Question

I have been researching this topic for some time now and I am finally trying to implement it myself; however, for some reason the 3d point is not converting to a 2d point correctly, which means that my function is returning the wrong value. This could be from 2 different cases:
1) My math is incorrect
2) My Matrix has the incorrect values
Since I am reversing and using addresses, I am unsure of the matrix. Is it possible for someone to check my math to see if it is the math that is incorrect? Any help on this function will be appreciated. Thank you in advance for any advice.
private bool ConvertToScreen(Vector3 position3D, ref Point screenPoint)
{
// r is the right rotation (x-axis)
// u is the up rotation (y-axis)
// f is the forward rotation (z-axis)
// p is the position (transform)
Point returnPoint = new Point(300, 400);
// Set Values of Matrix
Matrix matrix = GetMatrix();
// Do the math calculations here
float xPrime = matrix.rX * position3D.x + matrix.rY * position3D.y + matrix.rZ * position3D.z + matrix.rW;
float yPrime = matrix.uX * position3D.x + matrix.uY * position3D.y + matrix.uZ * position3D.z + matrix.uW;
// Dont need zPrime
float wPrime = matrix.pX * position3D.x + matrix.pY * position3D.y + matrix.pZ * position3D.z + matrix.pW;
// If wPrime > 0 we can see the point
if (wPrime <= 0)
{
return false;
}
xPrime *= 1 / wPrime;
yPrime *= 1 / wPrime;
// Relative To Screen Center
xPrime = rect.left + 0.5f * xPrime * (rect.right - rect.left) + 0.5f;
yPrime = rect.top + 0.5f * yPrime * (rect.bottom - rect.top) + 0.5f;
returnPoint = new Point((int)xPrime, (int)yPrime);
screenPoint = returnPoint;
return true;
}

Answer 1

There are several steps to this calculation, and I advise to split it up into corresponding sections and test each one.
Model to camera coordinates - This is the rotation of position = (x,y,z) points from model coordinates into camera coordinates. Here we assume that the target of the camera is at the origin.
local = rot * (position - target)
| x' | | rx ry rz | | x | | rx*x + ry*y + rz*z |
| y' | = | ux uy yz | * | y | = | ux*x + uy*y + uz*z |
| z' | | fx fy fz | | z | | fx*x + fy*y + fz*z |
Perspective Projection - You need a definition of the distance between the target and the camera, as well as the size of the model that would cover the view. Let's call those, distance and size. The result is in view coordinates that vary between 0..1 in both x and y.
| vx | | (distance/size)*(x'/(distance+z')) |
| | = | | |
| vy | | (distance/size)*(y'/(distance+z')) |
This comes out of similar triangles. If x'=size and z'=0 then vx=1. The larger z' is the smaller vx becomes.
Pixel Coordinates
Here you map the view coordinates into pixels. Your viewport has a width and a height and you want [0,0] pixels on the top left, and [width-1,height-1] to the bottom right.
width
+-------------------+
|(-1,1) : (1,1)|
| : |
| : (0,0) |
+- - - - -+- - - - -+ height
| : |
| : |
|(-1,-1) : (1,-1)|
+-------------------+
px = (width-1)*(vx+1.0)/2.0
py = (height-1)*(1.0-vy)/2.0
Finally, I recommend using OOP programming (if possible) to separate the vector/matrix math to the intent. Consider the following example in c#.
public static Vector3 ThroughCamera(Vector3 point, Vector3 target, Matrix3 camera)
{
return camera.Transpose()*(point-target);
}
public static Vector2 Perspective(Vector3 point, double distance, double size=1)
{
return new Vector2(
(distance/size)*(point.X/(distance+point.Z)),
(distance/size)*(point.Y/(distance+point.Z)) );
}
public static PointF Pixel(Vector2 point, int width, int height)
{
return new PointF(
(float) ((width-1)*(point.X+1)/2),
(float) ((height-1)*(1-point.Y)/2) );
}
static void dlg_Paint(object sender, PaintEventArgs e)
{
Form dlg=sender as Form;
// Set camera rotation
Matrix3 camera=Matrix3.Ry(0.67);
double distance=25;
double size=20;
for(int i=0; i<10; i++)
{
for(int j=0; j<10; j++)
{
// this is the model points
Vector3 pt=new Vector3(5*(i-5), 5*(j-5), 0);
// these are the points through the camera
Vector3 pt_local=ThroughCamera(pt, Vector3.O, camera);
// these are the view coordinates
Vector2 pt_view=Perspective(pt_local, distance, size);
// these are the pixel coordinates
PointF px=Pixel(pt_view, dlg.ClientSize.Width, dlg.ClientSize.Height);
e.Graphics.DrawRectangle(Pens.Blue, px.X, px.Y, 1f, 1f);
}
}
}