Add transmission dataPreperation

src/common/convertfp16tofloat.cpp

@@ -16,7 +16,7 @@ namespace  {
         _mm_set_epi16(2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048);
     const uint CONVERT_ADD_VALUE = UINT32_MAX - 4095;
     void convert(short * ptr, double* des,bool single = false){
-                // 初始化值
+        // 初始化值
         auto value = _mm_set_epi16(ptr[0], ptr[1], ptr[2], ptr[3], single?ptr[0]:ptr[4], single?ptr[0]:ptr[5],
                                     single?ptr[0]:ptr[6], single?ptr[0]:ptr[7]);
         auto uvalue = _mm_set_epi16(

src/transmissionReconstruction/dataPreperation.cpp

@@ -0,0 +1,37 @@
+#include "dataPreperation.h"
+#include "Function1D.h"
+#include "Function2D.h"
+#include "Function3D.h"
+#include <cstddef>
+
+
+namespace Recon
+{
+    Aurora::Matrix distanceBetweenTwoPoints(Aurora::Matrix aPtsA, Aurora::Matrix aPtsB)
+    {
+        return Aurora::sqrt(Aurora::sum((aPtsA-aPtsB)^2));
+    }
+    
+    Aurora::Matrix calculateWaterTemperature(Aurora::Matrix aMWaterTempS,
+                                             Aurora::Matrix aMWaterTempR,
+                                             Aurora::Matrix aVsl,
+                                             Aurora::Matrix aVrl,
+                                             Aurora::Matrix aVmp)
+    {
+        auto idx1 = Aurora::sub2ind(Aurora::size(aMWaterTempS), {aVsl, aVmp});
+        auto idx2 = Aurora::sub2ind(Aurora::size(aMWaterTempR), {aVrl, aVmp});
+        auto waterTemp  = Aurora::zeros(idx1.getDataSize(),1);
+        for (size_t i = 0; i<idx1.getDataSize(); ++i) {
+            waterTemp.getData()[i] = (aMWaterTempS.getData()[(int)idx1.getData()[i]]+
+            aMWaterTempR.getData()[(int)idx2.getData()[i]])/2;
+        }
+        return waterTemp;
+    }
+    
+    Aurora::Matrix prepareAScansForTransmissionDetection(const Aurora::Matrix& aMaScanBlock, const Aurora::Matrix aVGainBlock)
+    {
+        auto ret = aMaScanBlock/Aurora::repmat(aVGainBlock,aMaScanBlock.getDimSize(0),1);
+        ret = ret-Aurora::repmat(Aurora::mean(ret),aMaScanBlock.getDimSize(0),1);
+        return ret;
+    }
+}

src/transmissionReconstruction/dataPreperation.h

@@ -0,0 +1,18 @@
+#ifndef __DATAPREPERATION_H__
+#define __DATAPREPERATION_H__
+#include "Matrix.h"
+namespace Recon {
+
+Aurora::Matrix distanceBetweenTwoPoints(Aurora::Matrix aPtsA,
+                                        Aurora::Matrix aPtsB);
+
+Aurora::Matrix calculateWaterTemperature(Aurora::Matrix aMWaterTempS,
+                                         Aurora::Matrix aMWaterTempR,
+                                         Aurora::Matrix aVsl,
+                                         Aurora::Matrix aVrl,
+                                         Aurora::Matrix aVmp);
+                                         
+Aurora::Matrix prepareAScansForTransmissionDetection(const Aurora::Matrix& aMaScanBlock, const Aurora::Matrix aVGainBlock);
+} // namespace Recon
+
+#endif // __DATAPREPERATION_H__

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]);
+}
+