3d point to 2d screen position

[crydrk]

I need to take a position in 3d space and figure out where in my rendered image that point will be. I found this: http://www.185vfx.com/2003/03/convert-a-3d-point-to-2d-screen-space-in-maya/ which talks about doing pretty much what I want. I've translated it to python and it works mostly. (I get expected results on the x axis at least) But the main problem is I need to be able to do this for an orthographic camera that has been rotated at a certain angle. It seems like this would be even easier, but I don't quite understand the math behind it. Has anyone else done this and possibly have some insight about how this would work?

[nowayfra]

The script you found also does not take any post projection edits into account, so it only works pretty good with default cams. Here is a mel script that matrix multiplies the world space point into camera space and then again using the camera projection matrix it multiplies the camera object space point  into screen space. But beware, if you use orthographic cameras and a camera scale factor of an other than default 1.0 it will fail retreiving the right image coordinate if you use mental ray as renderer. Looks like that mental ray interpretes the camera scale at orthographic cams differently (in this case it almost always ignores it). The scale value at orthographic camers seems the be the only issue so far that might produce wrong results, perspectivic cameras however work fine.
Example: float $xy[] = cWorldSpaceToImageSpace("persp", {$x,$y,$z})

global proc float[] cTtransformPoint(float $mtx[], float $pt[]) // multiply 4x4 matrix with 4x vector
 {
	float $res[] = {};
	if(`size $pt` == 3)
 		$pt[3] = 1.0;
 
	for($i=0;$i<4;$i++){
		float $tmp = 0;
		for($k=0;$k<4;$k++){
			$tmp += $pt[$k] * $mtx[$k * 4 + $i];
		};
		$res[$i] = $tmp;
	};
	return $res;
 };
 
 
 global proc float[] cGetProjectionMatrix(string $shape) //get camera projection matrix
 {
	float $res[] = {};
	if(`objExists $shape` && `nodeType $shape` == "camera"){
		python "import maya.OpenMaya as om";
		python "list = om.MSelectionList()";
		python ("list.add(' " + $shape + "')"); 
		python "depNode = om.MObject()";
		python "list.getDependNode(0, depNode)";
		python "camFn = om.MFnCamera(depNode)";
		python "pMtx = om.MFloatMatrix()";
		python "pMtx = camFn.projectionMatrix()";
		for($i=0;$i<=3;$i++){
			for($k=0;$k<=3;$k++)
				$res[`size $res`] = `python ("pMtx(" + $i + ", " + $k + ")")`;
		};
	};
	return $res;
 };
 
 global proc float[] cWorldSpaceToImageSpace(string $camera, float $worldPt[])
 {
	string $camShape[] = `ls -dag -type "camera" $camera`;
	if(! `size $camShape`)
		return {};
 
	string $cam[] = `listRelatives -p -f $camShape`;
	int $resX = `getAttr "defaultResolution.width"`;
	int $resY = `getAttr "defaultResolution.height"`;
 
	float $cam_inverseMatrix[] = `getAttr ($cam[0] + ".worldInverseMatrix")`;
	float $cam_projectionMatrix[] = `cGetProjectionMatrix $camShape[0]`;
 
	float $ptInCamSpace[] = `cTtransformPoint $cam_inverseMatrix $worldPt`;
	float $projectedPoint[] = `cTtransformPoint $cam_projectionMatrix $ptInCamSpace`;
 
	float $resultX = (($projectedPoint[0] / $projectedPoint[3]) / 2 + .5) * $resX;
	float $resultY = (($projectedPoint[1] / $projectedPoint[3]) / 2 + .5) * $resY;
 
	return {$resultX, $resultY};
 };

[joojaa]

one can be neater (and magnitudes faster) in python (since maya knows the operations directly with api calls*) same problems apply.

import maya.OpenMaya as om
 
def pointWorldToCam(cameraName, point, res):
    sel = om.MSelectionList()
    dag = om.MDagPath()
 
    sel.add(cameraName)
    sel.getDagPath(0,dag)
 
    cam = om.MFnCamera(dag)
    floatMat = cam.projectionMatrix()
    projMat = om.MMatrix(floatMat.matrix)
    floatMat = cam.postProjectionMatrix()
    postProjMat = om.MMatrix(floatMat.matrix)
    transMat = dag.inclusiveMatrix()
 
    #long form ensures compatibility with MPoint and any iterable
    point = om.MPoint(point[0],point[1],point[2]) 
 
    fullMat =  transMat.inverse() * projMat * postProjMat 
    nuPoint = point * fullMat
    return [(nuPoint[0]/nuPoint[3]/2+0.5)*res[0],
            (1-(nuPoint[1]/nuPoint[3]/2+0.5))*res[1]]
 
#test 
print pointWorldToCam('persp', (0,0,0), (640,480))

Mayas cordinates are measured form center positive being up. For example adobbe shows points in editors form top left hence the /2+0.5 and inverse for other axis. However many programs including adobe (eg illustrator, pdf, eps etc.) do internally use lower left corners as starting point. Modify to suit your need.

BTW while searched for my old codes i stumbled across:

http://koichitamura.blogspot.fi/2008/07/world-point-to-point-on-image-maya.html

that does much the same except for a bit of unnecceserily extra code for floatmatrix to mmatrix transform. i guess its the same base source as your code above. But yeah common ogl code style. Whileas i have a Lisplike dialect of coding.

PS: if you need many points then cache the fullMatrix

• It looks a bit long because c is like that you need to declare thinkgs as types up front and the om is a c++ wrapper. So it makes it unneccery longwinded. Only the last 3 lines actually do anything other than fetching data. If you use somepthing like pymel it gets shorter to write