last fixes

Author: justadudewhohacks

cc/core/MatCalib3d.cc

@@ -49,287 +49,287 @@ void MatCalib3d::Init(v8::Local<v8::FunctionTemplate> ctor) {
 NAN_METHOD(MatCalib3d::Rodrigues) {
   FF::SyncBinding(
     std::make_shared<MatCalib3dBindings::RodriguesWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::Rodrigues",
+    "Mat::Rodrigues",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::RodriguesAsync) {
   FF::AsyncBinding(
     std::make_shared<MatCalib3dBindings::RodriguesWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::RodriguesAsync",
+    "Mat::RodriguesAsync",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::RQDecomp3x3) {
   FF::SyncBinding(
     std::make_shared<MatCalib3dBindings::RQDecomp3x3Worker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::RQDecomp3x3",
+    "Mat::RQDecomp3x3",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::RQDecomp3x3Async) {
   FF::AsyncBinding(
     std::make_shared<MatCalib3dBindings::RQDecomp3x3Worker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::RQDecomp3x3Async",
+    "Mat::RQDecomp3x3Async",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::DecomposeProjectionMatrix) {
   FF::SyncBinding(
     std::make_shared<MatCalib3dBindings::DecomposeProjectionMatrixWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::DecomposeProjectionMatrix",
+    "Mat::DecomposeProjectionMatrix",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::DecomposeProjectionMatrixAsync) {
   FF::AsyncBinding(
     std::make_shared<MatCalib3dBindings::DecomposeProjectionMatrixWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::DecomposeProjectionMatrixAsync",
+    "Mat::DecomposeProjectionMatrixAsync",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::MatMulDeriv) {
   FF::SyncBinding(
     std::make_shared<MatCalib3dBindings::MatMulDerivWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::MatMulDeriv",
+    "Mat::MatMulDeriv",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::MatMulDerivAsync) {
   FF::AsyncBinding(
     std::make_shared<MatCalib3dBindings::MatMulDerivWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::MatMulDerivAsync",
+    "Mat::MatMulDerivAsync",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::FindChessboardCorners) {
   FF::SyncBinding(
     std::make_shared<MatCalib3dBindings::FindChessboardCornersWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::FindChessboardCorners",
+    "Mat::FindChessboardCorners",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::FindChessboardCornersAsync) {
   FF::AsyncBinding(
     std::make_shared<MatCalib3dBindings::FindChessboardCornersWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::FindChessboardCornersAsync",
+    "Mat::FindChessboardCornersAsync",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::DrawChessboardCorners) {
   FF::SyncBinding(
     std::make_shared<MatCalib3dBindings::DrawChessboardCornersWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::DrawChessboardCorners",
+    "Mat::DrawChessboardCorners",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::DrawChessboardCornersAsync) {
   FF::AsyncBinding(
     std::make_shared<MatCalib3dBindings::DrawChessboardCornersWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::DrawChessboardCornersAsync",
+    "Mat::DrawChessboardCornersAsync",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::Find4QuadCornerSubpix) {
   FF::SyncBinding(
     std::make_shared<MatCalib3dBindings::Find4QuadCornerSubpixWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::Find4QuadCornerSubpix",
+    "Mat::Find4QuadCornerSubpix",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::Find4QuadCornerSubpixAsync) {
   FF::AsyncBinding(
     std::make_shared<MatCalib3dBindings::Find4QuadCornerSubpixWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::Find4QuadCornerSubpixAsync",
+    "Mat::Find4QuadCornerSubpixAsync",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::CalibrationMatrixValues) {
   FF::SyncBinding(
     std::make_shared<MatCalib3dBindings::CalibrationMatrixValuesWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::CalibrationMatrixValues",
+    "Mat::CalibrationMatrixValues",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::CalibrationMatrixValuesAsync) {
   FF::AsyncBinding(
     std::make_shared<MatCalib3dBindings::CalibrationMatrixValuesWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::CalibrationMatrixValuesAsync",
+    "Mat::CalibrationMatrixValuesAsync",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::StereoRectify) {
   FF::SyncBinding(
     std::make_shared<MatCalib3dBindings::StereoRectifyWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::StereoRectify",
+    "Mat::StereoRectify",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::StereoRectifyAsync) {
   FF::AsyncBinding(
     std::make_shared<MatCalib3dBindings::StereoRectifyWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::StereoRectifyAsync",
+    "Mat::StereoRectifyAsync",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::Rectify3Collinear) {
   FF::SyncBinding(
     std::make_shared<MatCalib3dBindings::Rectify3CollinearWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::Rectify3Collinear",
+    "Mat::Rectify3Collinear",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::Rectify3CollinearAsync) {
   FF::AsyncBinding(
     std::make_shared<MatCalib3dBindings::Rectify3CollinearWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::Rectify3CollinearAsync",
+    "Mat::Rectify3CollinearAsync",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::GetOptimalNewCameraMatrix) {
   FF::SyncBinding(
     std::make_shared<MatCalib3dBindings::GetOptimalNewCameraMatrixWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::GetOptimalNewCameraMatrix",
+    "Mat::GetOptimalNewCameraMatrix",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::GetOptimalNewCameraMatrixAsync) {
   FF::AsyncBinding(
     std::make_shared<MatCalib3dBindings::GetOptimalNewCameraMatrixWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::GetOptimalNewCameraMatrixAsync",
+    "Mat::GetOptimalNewCameraMatrixAsync",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::DecomposeEssentialMat) {
   FF::SyncBinding(
     std::make_shared<MatCalib3dBindings::DecomposeEssentialMatWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::DecomposeEssentialMat",
+    "Mat::DecomposeEssentialMat",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::DecomposeEssentialMatAsync) {
   FF::AsyncBinding(
     std::make_shared<MatCalib3dBindings::DecomposeEssentialMatWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::DecomposeEssentialMatAsync",
+    "Mat::DecomposeEssentialMatAsync",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::TriangulatePoints) {
   FF::SyncBinding(
     std::make_shared<MatCalib3dBindings::TriangulatePointsWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::TriangulatePoints",
+    "Mat::TriangulatePoints",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::TriangulatePointsAsync) {
   FF::AsyncBinding(
     std::make_shared<MatCalib3dBindings::TriangulatePointsWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::TriangulatePointsAsync",
+    "Mat::TriangulatePointsAsync",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::CorrectMatches) {
   FF::SyncBinding(
     std::make_shared<MatCalib3dBindings::CorrectMatchesWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::CorrectMatches",
+    "Mat::CorrectMatches",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::CorrectMatchesAsync) {
   FF::AsyncBinding(
     std::make_shared<MatCalib3dBindings::CorrectMatchesWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::CorrectMatchesAsync",
+    "Mat::CorrectMatchesAsync",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::FilterSpeckles) {
   FF::SyncBinding(
     std::make_shared<MatCalib3dBindings::FilterSpecklesWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::FilterSpeckles",
+    "Mat::FilterSpeckles",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::FilterSpecklesAsync) {
   FF::AsyncBinding(
     std::make_shared<MatCalib3dBindings::FilterSpecklesWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::FilterSpecklesAsync",
+    "Mat::FilterSpecklesAsync",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::ValidateDisparity) {
   FF::SyncBinding(
     std::make_shared<MatCalib3dBindings::ValidateDisparityWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::ValidateDisparity",
+    "Mat::ValidateDisparity",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::ValidateDisparityAsync) {
   FF::AsyncBinding(
     std::make_shared<MatCalib3dBindings::ValidateDisparityWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::ValidateDisparityAsync",
+    "Mat::ValidateDisparityAsync",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::ReprojectImageTo3D) {
   FF::SyncBinding(
     std::make_shared<MatCalib3dBindings::ReprojectImageTo3DWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::ReprojectImageTo3D",
+    "Mat::ReprojectImageTo3D",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::ReprojectImageTo3DAsync) {
   FF::AsyncBinding(
     std::make_shared<MatCalib3dBindings::ReprojectImageTo3DWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::ReprojectImageTo3DAsync",
+    "Mat::ReprojectImageTo3DAsync",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::DecomposeHomographyMat) {
   FF::SyncBinding(
     std::make_shared<MatCalib3dBindings::DecomposeHomographyMatWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::DecomposeHomographyMat",
+    "Mat::DecomposeHomographyMat",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::DecomposeHomographyMatAsync) {
   FF::AsyncBinding(
     std::make_shared<MatCalib3dBindings::DecomposeHomographyMatWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::DecomposeHomographyMatAsync",
+    "Mat::DecomposeHomographyMatAsync",
     info
   );
 }
@@ -339,31 +339,31 @@ NAN_METHOD(MatCalib3d::DecomposeHomographyMatAsync) {
 NAN_METHOD(MatCalib3d::FindEssentialMat) {
   FF::SyncBinding(
     std::make_shared<MatCalib3dBindings::FindEssentialMatWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::FindEssentialMat",
+    "Mat::FindEssentialMat",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::FindEssentialMatAsync) {
   FF::AsyncBinding(
     std::make_shared<MatCalib3dBindings::FindEssentialMatWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::FindEssentialMatAsync",
+    "Mat::FindEssentialMatAsync",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::RecoverPose) {
   FF::SyncBinding(
     std::make_shared<MatCalib3dBindings::RecoverPoseWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::RecoverPose",
+    "Mat::RecoverPose",
     info
   );
 }
 
 NAN_METHOD(MatCalib3d::RecoverPoseAsync) {
   FF::AsyncBinding(
     std::make_shared<MatCalib3dBindings::RecoverPoseWorker>(Mat::Converter::unwrap(info.This())),
-    "MatCalib3d::RecoverPoseAsync",
+    "Mat::RecoverPoseAsync",
     info
   );
 }