Optimize some coding style

hceng123 · May 31, 2019 · f49b827 · f49b827
1 parent 1c56558
commit f49b827
Show file tree

Hide file tree

Showing 4 changed files with 73 additions and 34 deletions.
diff --git a/TestVisionLibrary/Test3D.cpp b/TestVisionLibrary/Test3D.cpp
@@ -1087,12 +1087,12 @@ void TestCalcFrameValue_2() {
 VectorOfMat ReadFrameImage(const std::string &path)
 {
     VectorOfMat vecImages;
-    for (int i = 1; i <= IMAGE_COUNT * 4; ++ i) {
+    for (int i = 1; i <= IMAGE_COUNT * NUM_OF_DLP; ++i) {
         char chArrFileName[100];
-        _snprintf( chArrFileName, sizeof (chArrFileName), "%02d.bmp", i );
+        _snprintf(chArrFileName, sizeof(chArrFileName), "%02d.bmp", i);
         std::string strImageFile = path + chArrFileName;
-        cv::Mat mat = cv::imread ( strImageFile, cv::IMREAD_GRAYSCALE );
-        if ( mat.empty() ) {
+        cv::Mat mat = cv::imread(strImageFile, cv::IMREAD_GRAYSCALE);
+        if (mat.empty()) {
             std::cout << "Failed to read image " << strImageFile << std::endl;
             return vecImages;
         }
@@ -1439,6 +1439,37 @@ void TestCalc4DLPHeight()
     std::cout << "Success to calculate 4 DLP height" << std::endl;
 }
 
+void SaveCalcMergeHeightData(const PR_SET_DLP_PARAMS_TO_GPU_CMD& stSetDlpCmd, const PR_CALC_MERGE_4_DLP_HEIGHT_CMD& stCalc4DlpHeightCmd) {
+    for (int dlp = 0; dlp < NUM_OF_DLP; ++dlp) {
+        {
+            char baseCalibResultFileName[100];
+            _snprintf(baseCalibResultFileName, sizeof(baseCalibResultFileName), "calibration3D_dlp%d.yml", dlp + 1);
+            cv::FileStorage fs(baseCalibResultFileName, cv::FileStorage::WRITE);
+            cv::write(fs, "K1", stCalc4DlpHeightCmd.arrCalcHeightCmd[dlp].matThickToThinK);
+            cv::write(fs, "K2", stCalc4DlpHeightCmd.arrCalcHeightCmd[dlp].matThickToThinnestK);
+            cv::write(fs, "ProjectDir", ToInt32(stCalc4DlpHeightCmd.arrCalcHeightCmd[dlp].enProjectDir));
+            cv::write(fs, "ScanDir", ToInt32(stCalc4DlpHeightCmd.arrCalcHeightCmd[dlp].enScanDir));
+            cv::write(fs, "ReverseSeq", ToInt32(stCalc4DlpHeightCmd.arrCalcHeightCmd[dlp].bReverseSeq));
+
+            cv::write(fs, "BaseWrappedAlpha", stSetDlpCmd.vecMatAlphaBase[dlp]);
+            cv::write(fs, "BaseWrappedBeta", stSetDlpCmd.vecMatBetaBase[dlp]);
+            cv::write(fs, "BaseWrappedGamma", stSetDlpCmd.vecMatGammaBase[dlp]);
+            fs.release();
+        }
+
+        {
+            char heightCalibResultFileName[100];
+            _snprintf(heightCalibResultFileName, sizeof(heightCalibResultFileName), "NewIntegrateCalibResult%d.yml", dlp + 1);
+            cv::FileStorage fs(heightCalibResultFileName, cv::FileStorage::WRITE);
+            cv::write(fs, "MaxPhase", stCalc4DlpHeightCmd.arrCalcHeightCmd[dlp].fMaxPhase);
+            cv::write(fs, "MinPhase", stCalc4DlpHeightCmd.arrCalcHeightCmd[dlp].fMinPhase);
+            cv::write(fs, "BezierK", stCalc4DlpHeightCmd.arrCalcHeightCmd[dlp].mat3DBezierK);
+            cv::write(fs, "BezierSurface", stSetDlpCmd.vec3DBezierSurface[dlp]);
+            fs.release();
+        }
+    }
+}
+
 void TestCalc4DLPHeightOnePass()
 {
     std::string strParentFolder = "C:/Data/3D_20190408/PCBFOV20190104/";
@@ -1459,42 +1490,40 @@ void TestCalc4DLPHeightOnePass()
     //float dlpOffset[4] = {0.0193f, -0.0032f, -0.0899, 0};
     float dlpOffset[4] = {0.f, 0.f, 0.f, 0.f};
 
-    {
-        PR_SET_DLP_PARAMS_TO_GPU_CMD stSetDlpCmd;
-        PR_SET_DLP_PARAMS_TO_GPU_RPY stSetDlpRpy;
-        for (int nDlp = 0; nDlp < NUM_OF_DLP; ++nDlp) {
-            char filePath[100];
-            _snprintf(filePath, sizeof(filePath), "./data/3D/Config/IntegrateCalibResult%d_new3D.yml", nDlp + 1);
-            cv::FileStorage fsIntegrated(filePath, cv::FileStorage::READ);
-
-            cv::FileNode fileNode = fsIntegrated["BezierSurface"];
-            cv::read(fileNode, stSetDlpCmd.vec3DBezierSurface[nDlp], cv::Mat());
+    PR_SET_DLP_PARAMS_TO_GPU_CMD stSetDlpCmd;
+    PR_SET_DLP_PARAMS_TO_GPU_RPY stSetDlpRpy;
+    for (int nDlp = 0; nDlp < NUM_OF_DLP; ++nDlp) {
+        char filePath[100];
+        _snprintf(filePath, sizeof(filePath), "./data/3D/Config/IntegrateCalibResult%d_new3D.yml", nDlp + 1);
+        cv::FileStorage fsIntegrated(filePath, cv::FileStorage::READ);
 
-            fsIntegrated.release();
+        cv::FileNode fileNode = fsIntegrated["BezierSurface"];
+        cv::read(fileNode, stSetDlpCmd.vec3DBezierSurface[nDlp], cv::Mat());
 
-            {
-                _snprintf(filePath, sizeof(filePath), "./data/3D/Config/CalibPP_Matlab_dlp%d.yml", nDlp + 1);
-                cv::FileStorage fs(filePath, cv::FileStorage::READ);
+        fsIntegrated.release();
 
-                cv::FileNode fileNode = fs["BaseWrappedAlpha"];
-                cv::read(fileNode, stSetDlpCmd.vecMatAlphaBase[nDlp], cv::Mat());
-                fileNode = fs["BaseWrappedBeta"];
-                cv::read(fileNode, stSetDlpCmd.vecMatBetaBase[nDlp], cv::Mat());
-                fileNode = fs["BaseWrappedGamma"];
-                cv::read(fileNode, stSetDlpCmd.vecMatGammaBase[nDlp], cv::Mat());
-                fs.release();
-            }
-        }
+        {
+            _snprintf(filePath, sizeof(filePath), "./data/3D/Config/CalibPP_Matlab_dlp%d.yml", nDlp + 1);
+            cv::FileStorage fs(filePath, cv::FileStorage::READ);
 
-        PR_SetDlpParamsToGpu(&stSetDlpCmd, &stSetDlpRpy);
-        if (stSetDlpRpy.enStatus != VisionStatus::OK) {
-            std::cout << "PR_SetDlpParamsToGpu failed" << std::endl;
-            return;
+            cv::FileNode fileNode = fs["BaseWrappedAlpha"];
+            cv::read(fileNode, stSetDlpCmd.vecMatAlphaBase[nDlp], cv::Mat());
+            fileNode = fs["BaseWrappedBeta"];
+            cv::read(fileNode, stSetDlpCmd.vecMatBetaBase[nDlp], cv::Mat());
+            fileNode = fs["BaseWrappedGamma"];
+            cv::read(fileNode, stSetDlpCmd.vecMatGammaBase[nDlp], cv::Mat());
+            fs.release();
         }
+    }
 
-        std::cout << "PR_SetDlpParamsToGpu success" << std::endl;
+    PR_SetDlpParamsToGpu(&stSetDlpCmd, &stSetDlpRpy);
+    if (stSetDlpRpy.enStatus != VisionStatus::OK) {
+        std::cout << "PR_SetDlpParamsToGpu failed" << std::endl;
+        return;
     }
 
+    std::cout << "PR_SetDlpParamsToGpu success" << std::endl;
+
     for (int nDlp = 0; nDlp < NUM_OF_DLP; ++ nDlp) {
         stCalc4DlpHeightCmd.arrCalcHeightCmd[nDlp].bEnableGaussianFilter = b3DDetectGaussionFilter;
         stCalc4DlpHeightCmd.arrCalcHeightCmd[nDlp].bUseThinnestPattern = b3DDetectCaliUseThinPattern;
@@ -1550,6 +1579,8 @@ void TestCalc4DLPHeightOnePass()
 
     stCalc4DlpHeightCmd.fHeightDiffThreshold = 0.1f;
 
+    SaveCalcMergeHeightData(stSetDlpCmd, stCalc4DlpHeightCmd);
+
     PR_CalcMerge4DlpHeight(&stCalc4DlpHeightCmd, &stCalc4DlpHeightRpy);
     if (stCalc4DlpHeightRpy.enStatus != VisionStatus::OK)
     {

diff --git a/VisionLibrary/Unwrap.cpp b/VisionLibrary/Unwrap.cpp
@@ -872,7 +872,7 @@ static inline cv::Mat calcOrder5BezierCoeff(const cv::Mat &matU) {
 
 /*static*/ cv::cuda::GpuMat Unwrap::_calcHeightGpuCore(
     const PR_CALC_3D_HEIGHT_GPU_CMD *const pstCmd,
-    const std::vector<cv::cuda::GpuMat>& vecGpuImages,
+    const VectorOfGpuMat& vecGpuImages,
     cv::cuda::GpuMat& matNanMask,
     cv::cuda::Stream& stream) {
         float fMinimumAlpitudeSquare = pstCmd->fMinAmplitude * pstCmd->fMinAmplitude;

diff --git a/VisionLibrary/Unwrap.h b/VisionLibrary/Unwrap.h
@@ -108,7 +108,7 @@ class Unwrap
     static cv::Mat _pickPointInterval(const cv::Mat& matInput, int interval);
     static cv::cuda::GpuMat _calcHeightGpuCore(
         const PR_CALC_3D_HEIGHT_GPU_CMD *const pstCmd,
-        const std::vector<cv::cuda::GpuMat>& vecGpuImages,
+        const VectorOfGpuMat& vecGpuImages,
         cv::cuda::GpuMat& matNanMask,
         cv::cuda::Stream& stream);
     static cv::Mat _merge4DlpHeightCore(

diff --git a/VisionLibrary/VisionAlgorithm.cpp b/VisionLibrary/VisionAlgorithm.cpp
@@ -7905,6 +7905,14 @@ VisionStatus VisionAlgorithm::_findLineByCaliper(const cv::Mat &matInputImg, con
         return pstRpy->enStatus;
     }
 
+    for (const auto& matImage : pstCmd->vecInputImages) {
+        if (matImage.empty()) {
+            WriteLog("Input image matrix is empty");
+            pstRpy->enStatus = VisionStatus::INVALID_PARAM;
+            return pstRpy->enStatus;
+        }
+    }
+
     if (pstCmd->vecVecFrameCtr.empty()) {
         WriteLog("Input image frame center is empty");
         pstRpy->enStatus = VisionStatus::INVALID_PARAM;