/// <summary>
/// performs perspective transformation of each element of multi-channel input matrix
/// </summary>
/// <param name="src">The source two-channel or three-channel floating-point array;
/// each element is 2D/3D vector to be transformed</param>
/// <param name="m">3x3 or 4x4 transformation matrix</param>
/// <returns>The destination array; it will have the same size and same type as src</returns>
public static Point2d[] PerspectiveTransform(IEnumerable<Point2d> src, Mat m)
{
if (src == null)
throw new ArgumentNullException("src");
if (m == null)
throw new ArgumentNullException("m");
using (var srcMat = MatOfPoint2d.FromArray(src))
using (var dstMat = new MatOfPoint2d())
{
NativeMethods.core_perspectiveTransform_Mat(srcMat.CvPtr, dstMat.CvPtr, m.CvPtr);
return dstMat.ToArray();
}
}
/// <summary>
/// projects points from the model coordinate space to the image coordinates.
/// Also computes derivatives of the image coordinates w.r.t the intrinsic
/// and extrinsic camera parameters
/// </summary>
/// <param name="objectPoints">Array of object points, 3xN/Nx3 1-channel or
/// 1xN/Nx1 3-channel, where N is the number of points in the view.</param>
/// <param name="rvec">Rotation vector (3x1).</param>
/// <param name="tvec">Translation vector (3x1).</param>
/// <param name="cameraMatrix">Camera matrix (3x3)</param>
/// <param name="distCoeffs">Input vector of distortion coefficients
/// (k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]]) of 4, 5, or 8 elements.
/// If the vector is null, the zero distortion coefficients are assumed.</param>
/// <param name="imagePoints">Output array of image points, 2xN/Nx2 1-channel
/// or 1xN/Nx1 2-channel</param>
/// <param name="jacobian">Optional output 2Nx(10 + numDistCoeffs) jacobian matrix
/// of derivatives of image points with respect to components of the rotation vector,
/// translation vector, focal lengths, coordinates of the principal point and
/// the distortion coefficients. In the old interface different components of
/// the jacobian are returned via different output parameters.</param>
/// <param name="aspectRatio">Optional “fixed aspect ratio” parameter.
/// If the parameter is not 0, the function assumes that the aspect ratio (fx/fy)
/// is fixed and correspondingly adjusts the jacobian matrix.</param>
public static void ProjectPoints(IEnumerable<Point3d> objectPoints,
double[] rvec, double[] tvec,
double[,] cameraMatrix, double[] distCoeffs,
out Point2d[] imagePoints,
out double[,] jacobian,
double aspectRatio = 0)
{
if (objectPoints == null)
throw new ArgumentNullException("objectPoints");
if (rvec == null)
throw new ArgumentNullException("rvec");
if (rvec.Length != 3)
throw new ArgumentException("rvec.Length != 3");
if (tvec == null)
throw new ArgumentNullException("tvec");
if (tvec.Length != 3)
throw new ArgumentException("tvec.Length != 3");
if (cameraMatrix == null)
throw new ArgumentNullException("cameraMatrix");
if (cameraMatrix.GetLength(0) != 3 || cameraMatrix.GetLength(1) != 3)
throw new ArgumentException("cameraMatrix must be double[3,3]");
Point3d[] objectPointsArray = EnumerableEx.ToArray(objectPoints);
using (var objectPointsM = new Mat(objectPointsArray.Length, 1, MatType.CV_64FC3, objectPointsArray))
using (var rvecM = new Mat(3, 1, MatType.CV_64FC1, rvec))
using (var tvecM = new Mat(3, 1, MatType.CV_64FC1, tvec))
using (var cameraMatrixM = new Mat(3, 3, MatType.CV_64FC1, cameraMatrix))
using (var imagePointsM = new MatOfPoint2d())
{
var distCoeffsM = new Mat();
if (distCoeffs != null)
distCoeffsM = new Mat(distCoeffs.Length, 1, MatType.CV_64FC1, distCoeffs);
var jacobianM = new MatOfDouble();
NativeMethods.calib3d_projectPoints_Mat(objectPointsM.CvPtr,
rvecM.CvPtr, tvecM.CvPtr, cameraMatrixM.CvPtr, distCoeffsM.CvPtr,
imagePointsM.CvPtr, jacobianM.CvPtr, aspectRatio);
imagePoints = imagePointsM.ToArray();
jacobian = jacobianM.ToRectangularArray();
}
}