manolas
/
vcglib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

fix some comments about the assumption made by the Shot

This commit is contained in:
Massimiliano Corsini 2011-05-19 08:46:38 +00:00
parent c35b1c84ff
commit 9349591548
1 changed files with 166 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
vcg/math/shot.h
View File

@ -94,15 +94,23 @@ creation
****************************************************************************/
/** class Shot
The shot is made of two things:
* the Instrinsics paramaters, which are stored as a Camera type (check vcg/math/camera) and that
Shot is made of two elements:
* the Instrinsics paramaters, which are stored as a Camera type (see vcg/math/camera) and that
determines how a point in the frame of the camera is projected in the 2D projection plane
* the Extrinsics parameters, which are stored in the class Shot (che the type ReferenceFrame)
and that tell viewpoint and view direction.
* the Extrinsics parameters, which are stored in the class Shot (type ReferenceFrame)
and that describe viewpoint and view direction.
The Extrinsics parameters are kept as a rotation matrix "rot" and a translation vector "tra"
NOTE: the translation matrix "tra" corresponds to -viewpoint while the rotation matrix
Some important notes about the usage of this class:
* The World coordinates system is assumed to be RIGHT-HANDED.
* The Shot reference frame is assumed to be RIGHT-HANDED.
* The associated Camera is assumed to point in the negative direction of the Z axis of the Shot coordinates system (reference frame).
As a consequence, the Camera coordinates system is LEFT-HANDED.
* The Extrinsics parameters are kept as a rotation matrix "rot" and a translation vector "tra"
The translation matrix "tra" corresponds to the viewpoint of the Shot while the rotation matrix
"rot" corresponds to the axis of the reference frame by row, i.e.
rot[0][0|1|2] == X axis
rot[1][0|1|2] == Y axis
@ -185,27 +193,29 @@ public:
/// look towards (dir+up)
void LookTowards(const vcg::Point3<S> & z_dir,const vcg::Point3<S> & up);
/// convert a 3d point from world to camera coordinates
/// convert a 3d point from world to camera coordinates (do not confuse with the Shot reference frame)
vcg::Point3<S> ConvertWorldToCameraCoordinates(const vcg::Point3<S> & p) const;
/// convert a 3d point from camera to world coordinates
/// convert a 3d point from camera (do not confuse with the Shot reference frame) to world coordinates
vcg::Point3<S> ConvertCameraToWorldCoordinates(const vcg::Point3<S> & p) const;
/// convert a 3d point from camera to world coordinates, uses inverse instead of trranspose
/// for non-exactly-rigid rotation matrices (such as calculated by tsai and garcia)
/* convert a 3d point from camera (do not confuse with the Shot reference frame) to world coordinates
* it uses inverse instead of transpose for non-exactly-rigid rotation matrices (such as calculated by tsai and garcia)
*/
vcg::Point3<S> ConvertCameraToWorldCoordinates_Substitute(const vcg::Point3<S> & p) const;
/// project a 3d point from world coordinates to 2d camera viewport (pixel)
/// project a 3d point from world coordinates to 2d camera viewport (the value returned is in pixels)
vcg::Point2<S> Project(const vcg::Point3<S> & p) const;
/// inverse projection from 2d camera viewport (pixel) + Zdepth to 3d world coordinates
/// inverse projection from 2d camera viewport (in pixels) to 3d world coordinates (it requires the original depth of the projected point)
vcg::Point3<S> UnProject(const vcg::Point2<S> & p, const S & d) const;
/// inverse projection from 2d camera viewport (pixel) + Zdepth to 3d world coordinates, uses inverse instead of trranspose
/// for non-exactly-rigid rotation matrices (such as calculated by tsai and garcia)
/* inverse projection from 2d camera viewport (in pixels) to 3d world coordinates (it requires the original depth of the projected point)
* uses inverse instead of trranspose for non-exactly-rigid rotation matrices (such as calculated by tsai and garcia)
*/
vcg::Point3<S> UnProject_Substitute(const vcg::Point2<S> & p, const S & d) const;
/// returns distance of point p from camera plane (z depth), used for unprojection
/// returns the distance of point p from camera plane (z depth), required for unprojection operation
S Depth(const vcg::Point3<S> & p)const;
@ -232,7 +242,6 @@ public:
/* multiply the current reference frame for the matrix passed
note: it is up to the caller to check the the matrix passed is a pure rototraslation
the matrix can have a scaling component, but is assumed uniform over the rows
*/
void MultMatrix( vcg::Matrix44<S> m44)
{
@ -240,7 +249,6 @@ public:
m44[0][3] = m44[1][3] = m44[2][3] = 0.0; //set no translation
const S k = m44.GetRow3(0).Norm(); //compute scaling (assumed uniform)
Extrinsics.rot = Extrinsics.rot * m44.transpose() * (1/k);
Extrinsics.rot.ElementAt(3,3)=S(1.0); //fix back after scaling
}
/* multiply the current reference frame for the similarity passed
@ -335,43 +343,42 @@ void Shot<S,RotationType>::LookTowards(const vcg::Point3<S> & z_dir,const vcg::P
//--- Space transformation methods
/// convert a 3d point from world to camera coordinates
/// convert a 3d point from world to camera coordinates (do not confuse with the Shot reference frame)
template <class S, class RotationType>
vcg::Point3<S> Shot<S,RotationType>::ConvertWorldToCameraCoordinates(const vcg::Point3<S> & p) const
{
Matrix44<S> rotM;
Extrinsics.rot.ToMatrix(rotM);
vcg::Point3<S> cp = rotM * (p - GetViewPoint() );
cp[2]=-cp[2]; // note: camera reference system is right handed
cp[2]=-cp[2];
return cp;
}
/// convert a 3d point from camera to world coordinates
/// convert a 3d point from camera coordinates (do not confuse with the Shot reference frame) to world coordinates
template <class S, class RotationType>
vcg::Point3<S> Shot<S,RotationType>::ConvertCameraToWorldCoordinates(const vcg::Point3<S> & p) const
{
Matrix44<S> rotM;
vcg::Point3<S> cp = p;
cp[2]=-cp[2]; // note: World reference system is left handed
cp[2]=-cp[2];
Extrinsics.rot.ToMatrix(rotM);
cp = rotM.transpose() * cp + GetViewPoint();
return cp;
}
/// convert a 3d point from camera to world coordinates, uses inverse instead of trranspose
/// for non-exactly-rigid rotation matrices (such as calculated by tsai and garcia)
/// convert a 3d point from camera to world coordinates, uses inverse instead of trranspose for non-exactly-rigid rotation matrices (such as calculated by tsai and garcia)
template <class S, class RotationType>
vcg::Point3<S> Shot<S,RotationType>::ConvertCameraToWorldCoordinates_Substitute(const vcg::Point3<S> & p) const
{
Matrix44<S> rotM;
vcg::Point3<S> cp = p;
cp[2]=-cp[2]; // note: World reference system is left handed
cp[2]=-cp[2];
Extrinsics.rot.ToMatrix(rotM);
cp = Inverse(rotM) * cp + GetViewPoint(); // use invert istead of transpose to dela with non-rigid cases
cp = Inverse(rotM) * cp + GetViewPoint();
return cp;
}
/// project a 3d point from world coordinates to 2d camera viewport (pixel)
/// project a 3d point from world coordinates to 2d camera viewport (the value returned is in pixel)
template <class S, class RotationType>
vcg::Point2<S> Shot<S,RotationType>::Project(const vcg::Point3<S> & p) const
{
@ -381,7 +388,7 @@ vcg::Point2<S> Shot<S,RotationType>::Project(const vcg::Point3<S> & p) const
return vp;
}
/// inverse projection from 2d camera viewport (pixel) + Zdepth to 3d world coordinates
/// inverse projection from 2d camera viewport (in pixels) to 3d world coordinates (it requires the original depth of the point to unproject)
template <class S, class RotationType>
vcg::Point3<S> Shot<S,RotationType>::UnProject(const vcg::Point2<S> & p, const S & d) const
{
@ -391,8 +398,9 @@ vcg::Point3<S> Shot<S,RotationType>::UnProject(const vcg::Point2<S> & p, const S
return wp;
}
/// inverse projection from 2d camera viewport (pixel) + Zdepth to 3d world coordinates, uses inverse instead of trranspose
/// for non-exactly-rigid rotation matrices (such as calculated by tsai and garcia)
/* inverse projection from 2d camera viewport (in pixels) to 3d world coordinates (it requires the original depth of the projected point)
* uses inverse instead of trranspose for non-exactly-rigid rotation matrices (such as calculated by tsai and garcia)
*/
template <class S, class RotationType>
vcg::Point3<S> Shot<S,RotationType>::UnProject_Substitute(const vcg::Point2<S> & p, const S & d) const
{
@ -402,7 +410,7 @@ vcg::Point3<S> Shot<S,RotationType>::UnProject_Substitute(const vcg::Point2<S> &
return wp;
}
/// returns distance of point p from camera plane (z depth), used for unprojection
/// returns the distance of point p from camera plane (z depth), required for unprojection operation
template <class S, class RotationType>
S Shot<S,RotationType>::Depth(const vcg::Point3<S> & p)const
{