Emgu.CV.CvInvoke.cvCalibrateCamera2 C# (CSharp) Метод

        public static extern double cvCalibrateCamera2(
          IntPtr objectPoints,
          IntPtr imagePoints,
          IntPtr pointCounts,
          Size imageSize,
          IntPtr intrinsicMatrix,
          IntPtr distortionCoeffs,
          IntPtr rotationVectors,
          IntPtr translationVectors,
          CvEnum.CALIB_TYPE flags);

        /// <summary>
        /// Estimates intrinsic camera parameters and extrinsic parameters for each of the views
        /// </summary>
        /// <param name="objectPoints">The 3D location of the object points. The first index is the index of image, second index is the index of the point</param>
        /// <param name="imagePoints">The 2D image location of the points. The first index is the index of the image, second index is the index of the point</param>
        /// <param name="imageSize">The size of the image, used only to initialize intrinsic camera matrix</param>
        /// <param name="intrinsicParam">The intrisinc parameters, might contains some initial values. The values will be modified by this function.</param>
        /// <param name="calibrationType">cCalibration type</param>
        /// <param name="termCriteria">The termination criteria</param>
        /// <param name="extrinsicParams">The output array of extrinsic parameters.</param>
        /// <returns>The final reprojection error</returns>
        public static double CalibrateCamera(
            MCvPoint3D32f[][] objectPoints,
            PointF[][] imagePoints,
            Size imageSize,
            IntrinsicCameraParameters intrinsicParam,
            CvEnum.CALIB_TYPE calibrationType,
            MCvTermCriteria termCriteria,
            out ExtrinsicCameraParameters[] extrinsicParams)
        {
            Debug.Assert(objectPoints.Length == imagePoints.Length, "The number of images for objects points should be equal to the number of images for image points");
            int imageCount = objectPoints.Length;

            #region get the array that represent the point counts
            int[] pointCounts = new int[objectPoints.Length];
            for (int i = 0; i < objectPoints.Length; i++)
            {
                Debug.Assert(objectPoints[i].Length == imagePoints[i].Length, String.Format("Number of 3D points and image points should be equal in the {0}th image", i));
                pointCounts[i] = objectPoints[i].Length;
            }
            #endregion

            double reprojectionError = -1;
            using (Matrix <float> objectPointMatrix = ToMatrix(objectPoints))
                using (Matrix <float> imagePointMatrix = ToMatrix(imagePoints))
                    using (Matrix <int> pointCountsMatrix = new Matrix <int>(pointCounts))
                        using (Matrix <double> rotationVectors = new Matrix <double>(imageCount, 3))
                            using (Matrix <double> translationVectors = new Matrix <double>(imageCount, 3))
                            {
                                reprojectionError = CvInvoke.cvCalibrateCamera2(
                                    objectPointMatrix.Ptr,
                                    imagePointMatrix.Ptr,
                                    pointCountsMatrix.Ptr,
                                    imageSize,
                                    intrinsicParam.IntrinsicMatrix,
                                    intrinsicParam.DistortionCoeffs,
                                    rotationVectors,
                                    translationVectors,
                                    calibrationType,
                                    termCriteria);

                                extrinsicParams = new ExtrinsicCameraParameters[imageCount];
                                IntPtr matPtr = Marshal.AllocHGlobal(StructSize.MCvMat);
                                for (int i = 0; i < imageCount; i++)
                                {
                                    ExtrinsicCameraParameters p = new ExtrinsicCameraParameters();
                                    CvInvoke.cvGetRow(rotationVectors.Ptr, matPtr, i);
                                    CvInvoke.cvTranspose(matPtr, p.RotationVector.Ptr);
                                    CvInvoke.cvGetRow(translationVectors.Ptr, matPtr, i);
                                    CvInvoke.cvTranspose(matPtr, p.TranslationVector.Ptr);
                                    extrinsicParams[i] = p;
                                }
                                Marshal.FreeHGlobal(matPtr);
                            }
            return(reprojectionError);
        }