Normalize cvTry lambda body indentation across OpenCvSharpExtern

src/OpenCvSharp/Internal/PInvoke/NativeMethods/photo/NativeMethods_photo_HDR.cs

@@ -28,10 +28,10 @@ static partial class NativeMethods
     public static partial ExceptionStatus photo_CalibrateDebevec_setLambda(OpenCvSafeHandle obj, float value);
 
     [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
-    public static partial ExceptionStatus photo_CalibrateDebevec_getSamples(OpenCvSafeHandle obj, out float returnValue);
+    public static partial ExceptionStatus photo_CalibrateDebevec_getSamples(OpenCvSafeHandle obj, out int returnValue);
 
     [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
-    public static partial ExceptionStatus photo_CalibrateDebevec_setSamples(OpenCvSafeHandle obj, float value);
+    public static partial ExceptionStatus photo_CalibrateDebevec_setSamples(OpenCvSafeHandle obj, int value);
 
     [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
     public static partial ExceptionStatus photo_CalibrateDebevec_getRandom(OpenCvSafeHandle obj, out int returnValue);

src/OpenCvSharp/Modules/photo/CalibrateDebevec.cs

@@ -48,9 +48,9 @@ public float Lambda
     }
 
     /// <summary>
-    /// 
+    ///
     /// </summary>
-    public float Samples
+    public int Samples
     {
         get
         {

src/OpenCvSharpExtern/barcode.h

@@ -7,39 +7,39 @@
 CVAPI(ExceptionStatus) barcode_BarcodeDetector_create(const char *super_resolution_model_path, cv::barcode::BarcodeDetector **returnValue)
 {
     return cvTry([&] {
-    // OpenCV 5: BarcodeDetector takes a single ONNX super-resolution model path (Caffe dropped).
-    if (super_resolution_model_path == nullptr || super_resolution_model_path[0] == '\0')
-        *returnValue = new cv::barcode::BarcodeDetector();
-    else
-        *returnValue = new cv::barcode::BarcodeDetector(std::string(super_resolution_model_path));
+        // OpenCV 5: BarcodeDetector takes a single ONNX super-resolution model path (Caffe dropped).
+        if (super_resolution_model_path == nullptr || super_resolution_model_path[0] == '\0')
+            *returnValue = new cv::barcode::BarcodeDetector();
+        else
+            *returnValue = new cv::barcode::BarcodeDetector(std::string(super_resolution_model_path));
     });
 }
 
 CVAPI(ExceptionStatus) barcode_BarcodeDetector_delete(cv::barcode::BarcodeDetector *obj)
 {
     return cvTry([&] {
-    delete obj;
+        delete obj;
     });
 }
 
 CVAPI(ExceptionStatus) barcode_BarcodeDetector_setDownsamplingThreshold(cv::barcode::BarcodeDetector *obj, double thresh)
 {
     return cvTry([&] {
-    obj->setDownsamplingThreshold(thresh);
+        obj->setDownsamplingThreshold(thresh);
     });
 }
 
 CVAPI(ExceptionStatus) barcode_BarcodeDetector_setDetectorScales(cv::barcode::BarcodeDetector *obj, std::vector<float> *sizes)
 {
     return cvTry([&] {
-    obj->setDetectorScales(*sizes);
+        obj->setDetectorScales(*sizes);
     });
 }
 
 CVAPI(ExceptionStatus) barcode_BarcodeDetector_setGradientThreshold(cv::barcode::BarcodeDetector *obj, double thresh)
 {
     return cvTry([&] {
-    obj->setGradientThreshold(thresh);
+        obj->setGradientThreshold(thresh);
     });
 }
 
@@ -51,7 +51,7 @@ CVAPI(ExceptionStatus) barcode_BarcodeDetector_decodeWithType(
     std::vector<std::string> *detectorTypes)
 {
     return cvTry([&] {
-    obj->decodeWithType(InProxy(*inputImage), *points, *detectorInfos, *detectorTypes);
+        obj->decodeWithType(InProxy(*inputImage), *points, *detectorInfos, *detectorTypes);
     });
 }
 
@@ -63,7 +63,7 @@ CVAPI(ExceptionStatus) barcode_BarcodeDetector_detectAndDecodeWithType(
     std::vector<std::string> *detectorTypes)
 {
     return cvTry([&] {
-    obj->detectAndDecodeWithType(InProxy(*inputImage), *detectorInfos, *detectorTypes, *points);
+        obj->detectAndDecodeWithType(InProxy(*inputImage), *detectorInfos, *detectorTypes, *points);
     });
 }
 

src/OpenCvSharpExtern/bgsegm.h

@@ -18,73 +18,73 @@ CVAPI(ExceptionStatus) bgsegm_createBackgroundSubtractorMOG(
     cv::Ptr<cv::bgsegm::BackgroundSubtractorMOG> **returnValue)
 {
     return cvTry([&] {
-    const auto ptr = cv::bgsegm::createBackgroundSubtractorMOG(history, nmixtures, backgroundRatio, noiseSigma);
-    *returnValue = new cv::Ptr<cv::bgsegm::BackgroundSubtractorMOG>(ptr);
+        const auto ptr = cv::bgsegm::createBackgroundSubtractorMOG(history, nmixtures, backgroundRatio, noiseSigma);
+        *returnValue = new cv::Ptr<cv::bgsegm::BackgroundSubtractorMOG>(ptr);
     });
 }
 CVAPI(ExceptionStatus) bgsegm_Ptr_BackgroundSubtractorMOG_get(cv::Ptr<cv::bgsegm::BackgroundSubtractorMOG> *obj, cv::bgsegm::BackgroundSubtractorMOG **returnValue)
 {
     return cvTry([&] {
-    *returnValue = obj->get();
+        *returnValue = obj->get();
     });
 }
 CVAPI(ExceptionStatus) bgsegm_Ptr_BackgroundSubtractorMOG_delete(cv::Ptr<cv::bgsegm::BackgroundSubtractorMOG> *obj)
 {
     return cvTry([&] {
-    delete obj;
+        delete obj;
     });
 }
 
 
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorMOG_getHistory(cv::Ptr<cv::bgsegm::BackgroundSubtractorMOG> *ptr, int *returnValue)
 {
     return cvTry([&] {
-    *returnValue = (*ptr)->getHistory();
+        *returnValue = (*ptr)->getHistory();
     });
 }
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorMOG_setHistory(cv::Ptr<cv::bgsegm::BackgroundSubtractorMOG> *ptr, int value)
 {
     return cvTry([&] {
-    (*ptr)->setHistory(value);
+        (*ptr)->setHistory(value);
     });
 }
 
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorMOG_getNMixtures(cv::Ptr<cv::bgsegm::BackgroundSubtractorMOG> *ptr, int *returnValue)
 {
     return cvTry([&] {
-    *returnValue = (*ptr)->getNMixtures();
+        *returnValue = (*ptr)->getNMixtures();
     });
 }
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorMOG_setNMixtures(cv::Ptr<cv::bgsegm::BackgroundSubtractorMOG> *ptr, int value)
 {
     return cvTry([&] {
-    (*ptr)->setNMixtures(value);
+        (*ptr)->setNMixtures(value);
     });
 }
 
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorMOG_getBackgroundRatio(cv::Ptr<cv::bgsegm::BackgroundSubtractorMOG> *ptr, double *returnValue)
 {
     return cvTry([&] {
-    *returnValue = (*ptr)->getBackgroundRatio();
+        *returnValue = (*ptr)->getBackgroundRatio();
     });
 }
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorMOG_setBackgroundRatio(cv::Ptr<cv::bgsegm::BackgroundSubtractorMOG> *ptr, double value)
 {
     return cvTry([&] {
-    (*ptr)->setBackgroundRatio(value);
+        (*ptr)->setBackgroundRatio(value);
     });
 }
 
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorMOG_getNoiseSigma(cv::Ptr<cv::bgsegm::BackgroundSubtractorMOG> *ptr, double *returnValue)
 {
     return cvTry([&] {
-    *returnValue = (*ptr)->getNoiseSigma();
+        *returnValue = (*ptr)->getNoiseSigma();
     });
 }
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorMOG_setNoiseSigma(cv::Ptr<cv::bgsegm::BackgroundSubtractorMOG> *ptr, double value)
 {
     return cvTry([&] {
-    (*ptr)->setNoiseSigma(value);
+        (*ptr)->setNoiseSigma(value);
     });
 }
 
@@ -95,14 +95,14 @@ CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorMOG_apply(
     double learningRate)
 {
     return cvTry([&] {
-    obj->apply(InProxy(*image), OutProxy(*fgmask), learningRate);
+        obj->apply(InProxy(*image), OutProxy(*fgmask), learningRate);
     });
 }
 
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorMOG_getBackgroundImage(cv::bgsegm::BackgroundSubtractorMOG *obj, const interop::OutputArrayProxy* backgroundImage)
 {
     return cvTry([&] {
-    obj->getBackgroundImage(OutProxy(*backgroundImage));
+        obj->getBackgroundImage(OutProxy(*backgroundImage));
     });
 }
 
@@ -116,151 +116,151 @@ CVAPI(ExceptionStatus) bgsegm_createBackgroundSubtractorGMG(
     cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> **returnValue)
 {
     return cvTry([&] {
-    const auto ptr = cv::bgsegm::createBackgroundSubtractorGMG(initializationFrames, decisionThreshold);
-    *returnValue = new cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG>(ptr);
+        const auto ptr = cv::bgsegm::createBackgroundSubtractorGMG(initializationFrames, decisionThreshold);
+        *returnValue = new cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG>(ptr);
     });
 }
 CVAPI(ExceptionStatus) bgsegm_Ptr_BackgroundSubtractorGMG_get(cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> *obj, cv::bgsegm::BackgroundSubtractorGMG **returnValue)
 {
     return cvTry([&] {
-    *returnValue = obj->get();
+        *returnValue = obj->get();
     });
 }
 CVAPI(ExceptionStatus) bgsegm_Ptr_BackgroundSubtractorGMG_delete(cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> *obj)
 {
     return cvTry([&] {
-    delete obj;
+        delete obj;
     });
 }
 
 
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorGMG_getMaxFeatures(cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> *ptr, int *returnValue)
 {
     return cvTry([&] {
-    *returnValue = (*ptr)->getMaxFeatures();
+        *returnValue = (*ptr)->getMaxFeatures();
     });
 }
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorGMG_setMaxFeatures(cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> *ptr, int value)
 {
     return cvTry([&] {
-    (*ptr)->setMaxFeatures(value);
+        (*ptr)->setMaxFeatures(value);
     });
 }
 
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorGMG_getDefaultLearningRate(cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> *ptr, double *returnValue)
 {
     return cvTry([&] {
-    *returnValue = (*ptr)->getDefaultLearningRate();
+        *returnValue = (*ptr)->getDefaultLearningRate();
     });
 }
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorGMG_setDefaultLearningRate(cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> *ptr, double value)
 {
     return cvTry([&] {
-    (*ptr)->setDefaultLearningRate(value);
+        (*ptr)->setDefaultLearningRate(value);
     });
 }
 
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorGMG_getNumFrames(cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> *ptr, int *returnValue)
 {
     return cvTry([&] {
-    *returnValue = (*ptr)->getNumFrames();
+        *returnValue = (*ptr)->getNumFrames();
     });
 }
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorGMG_setNumFrames(cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> *ptr, int value)
 {
     return cvTry([&] {
-    (*ptr)->setNumFrames(value);
+        (*ptr)->setNumFrames(value);
     });
 }
 
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorGMG_getQuantizationLevels(cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> *ptr, int *returnValue)
 {
     return cvTry([&] {
-    *returnValue = (*ptr)->getQuantizationLevels();
+        *returnValue = (*ptr)->getQuantizationLevels();
     });
 }
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorGMG_setQuantizationLevels(cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> *ptr, int value)
 {
     return cvTry([&] {
-    (*ptr)->setQuantizationLevels(value);
+        (*ptr)->setQuantizationLevels(value);
     });
 }
 
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorGMG_getBackgroundPrior(cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> *ptr, double *returnValue)
 {
     return cvTry([&] {
-    *returnValue = (*ptr)->getBackgroundPrior();
+        *returnValue = (*ptr)->getBackgroundPrior();
     });
 }
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorGMG_setBackgroundPrior(cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> *ptr, double value)
 {
     return cvTry([&] {
-    (*ptr)->setBackgroundPrior(value);
+        (*ptr)->setBackgroundPrior(value);
     });
 }
 
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorGMG_getSmoothingRadius(cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> *ptr, int *returnValue)
 {
     return cvTry([&] {
-    *returnValue = (*ptr)->getSmoothingRadius();
+        *returnValue = (*ptr)->getSmoothingRadius();
     });
 }
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorGMG_setSmoothingRadius(cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> *ptr, int value)
 {
     return cvTry([&] {
-    (*ptr)->setSmoothingRadius(value);
+        (*ptr)->setSmoothingRadius(value);
     });
 }
 
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorGMG_getDecisionThreshold(cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> *ptr, double *returnValue)
 {
     return cvTry([&] {
-    *returnValue = (*ptr)->getDecisionThreshold();
+        *returnValue = (*ptr)->getDecisionThreshold();
     });
 }
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorGMG_setDecisionThreshold(cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> *ptr, double value)
 {
     return cvTry([&] {
-    (*ptr)->setDecisionThreshold(value);
+        (*ptr)->setDecisionThreshold(value);
     });
 }
 
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorGMG_getUpdateBackgroundModel(cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> *ptr, int *returnValue)
 {
     return cvTry([&] {
-    *returnValue = (*ptr)->getUpdateBackgroundModel() ? 1 : 0;
+        *returnValue = (*ptr)->getUpdateBackgroundModel() ? 1 : 0;
     });
 }
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorGMG_setUpdateBackgroundModel(cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> *ptr, int value)
 {
     return cvTry([&] {
-    (*ptr)->setUpdateBackgroundModel(value != 0);
+        (*ptr)->setUpdateBackgroundModel(value != 0);
     });
 }
 
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorGMG_getMinVal(cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> *ptr, double *returnValue)
 {
     return cvTry([&] {
-    *returnValue = (*ptr)->getMinVal();
+        *returnValue = (*ptr)->getMinVal();
     });
 }
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorGMG_setMinVal(cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> *ptr, double value)
 {
     return cvTry([&] {
-    (*ptr)->setMinVal(value);
+        (*ptr)->setMinVal(value);
     });
 }
 
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorGMG_getMaxVal(cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> *ptr, double *returnValue)
 {
     return cvTry([&] {
-    *returnValue = (*ptr)->getMaxVal();
+        *returnValue = (*ptr)->getMaxVal();
     });
 }
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorGMG_setMaxVal(cv::Ptr<cv::bgsegm::BackgroundSubtractorGMG> *ptr, double value)
 {
     return cvTry([&] {
-    (*ptr)->setMaxVal(value);
+        (*ptr)->setMaxVal(value);
     });
 }
 
@@ -271,14 +271,14 @@ CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorGMG_apply(
     double learningRate)
 {
     return cvTry([&] {
-    obj->apply(InProxy(*image), OutProxy(*fgmask), learningRate);
+        obj->apply(InProxy(*image), OutProxy(*fgmask), learningRate);
     });
 }
 
 CVAPI(ExceptionStatus) bgsegm_BackgroundSubtractorGMG_getBackgroundImage(cv::bgsegm::BackgroundSubtractorGMG *obj, const interop::OutputArrayProxy* backgroundImage)
 {
     return cvTry([&] {
-    obj->getBackgroundImage(OutProxy(*backgroundImage));
+        obj->getBackgroundImage(OutProxy(*backgroundImage));
     });
 }