Add transmission dataPreperation

test/Common_Test.cpp

@@ -30,7 +30,7 @@ protected:
 
 TEST_F(Common_Test, adaptFrequency) {
     // MatlabReader m("/home/krad/TestData/adaptFrequency.mat");
-    MatlabReader m("/home/sun/Aurora/build/a.mat");
+    MatlabReader m("/home/sun/Aurora_back/build/a.mat");
 
     auto mCe = m.read("input");
     mCe = Recon::adaptFrequency(mCe,40000000.0,10000000.0);

test/TransRecon_DataPreperation_Test.cpp

@@ -0,0 +1,73 @@
+#include <gtest/gtest.h>
+
+#include "Function3D.h"
+#include "transmissionReconstruction/dataPreperation.h"
+
+inline double fourDecimalRound(double src){
+    return round(src*10000.0)/10000.0;
+}
+
+#define EXPECT_DOUBLE_AE(valueA,valueB)\
+    EXPECT_DOUBLE_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
+
+class TransRecon_DataPreperation_Test : public ::testing::Test {
+protected:
+    static void SetUpTransRecon_DataPreperationTester() {
+
+    }
+
+    static void TearDownTestCase() {
+    }
+
+    void SetUp() {
+    }
+
+    void TearDown() {
+    }
+};
+
+TEST_F(TransRecon_DataPreperation_Test, distanceBetweenTwoPoints) {
+        double *dataA = new double[9]{1, 9, 4, 0, .01, 1.9, 300,22, -93};
+        auto A = Aurora::Matrix::fromRawData(dataA, 3, 3);
+        double *dataB = new double[9]{2,3,3,2,2,1,3,3,-3};
+        auto B = Aurora::Matrix::fromRawData(dataB, 3, 3);
+        auto output =Recon::distanceBetweenTwoPoints(B,A);
+        EXPECT_EQ(3, output.getDataSize());
+        EXPECT_DOUBLE_AE(6.1644,output.getData()[0]);
+        EXPECT_DOUBLE_AE(2.9614,output.getData()[1]);
+        EXPECT_DOUBLE_AE(310.9180,output.getData()[2]);
+}
+
+TEST_F(TransRecon_DataPreperation_Test, calculateWaterTemperature) {
+
+        auto waterTempS = Aurora::ones(3, 2) * 25.9;
+        auto waterTempR = Aurora::ones(4, 2) * 20 + 1.1;
+        double *xD = new double[6]{1, 2, 3, 1, 2, 3};
+        Aurora::Matrix sl(
+            std::shared_ptr<double>(xD, std::default_delete<double[]>()),
+            std::vector<int>{6});
+        xD = new double[6]{1, 1, 1, 1, 1, 1};
+        Aurora::Matrix rl(
+            std::shared_ptr<double>(xD, std::default_delete<double[]>()),
+            std::vector<int>{6});
+        xD = new double[6]{1, 1, 1, 2, 2, 2};
+        Aurora::Matrix mp(
+            std::shared_ptr<double>(xD, std::default_delete<double[]>()),
+            std::vector<int>{6});
+
+        auto output = Recon::calculateWaterTemperature(waterTempS, waterTempR,
+                                                       sl, rl, mp);
+        EXPECT_EQ(6, output.getDataSize());
+        EXPECT_DOUBLE_AE(23.5, output.getData()[0]);
+        EXPECT_DOUBLE_AE(23.5, output.getData()[1]);
+}
+
+TEST_F(TransRecon_DataPreperation_Test, prepareAScansForTransmissionDetection){
+        auto aScanBlock = Aurora::ones(300, 10) * 21.1;
+        auto gainBlock = Aurora::ones(1, 10) * 20 + 66.6;
+        auto result = Recon::prepareAScansForTransmissionDetection(aScanBlock,gainBlock);
+        EXPECT_EQ(300, result.getDimSize(0));
+        EXPECT_EQ(10, result.getDimSize(1));
+        EXPECT_DOUBLE_AE(0, result.getData()[0]);
+}
+