Add removeDataFromArrays.

Fix dataFilter to use transparams.

src/common/dataBlockCreation/removeDataFromArrays.cpp

@@ -0,0 +1,46 @@
+#include "removeDataFromArrays.h"
+#include "Function.h"
+#include "Function1D.h"
+#include "Function2D.h"
+#include "Matrix.h"
+#include <cstddef>
+#include <vector>
+
+using namespace Recon;
+using namespace Aurora;
+
+Aurora::Matrix Recon::removeDataFromArrays(const Aurora::Matrix& aOutPutMatrix, const Aurora::Matrix& aRemoveList)
+{
+    // Matrix result = aOutPutMatrix;
+    // int minusNum = 0;
+    // for(int i=0; i<aRemoveList.getDataSize(); ++i)
+    // {
+    //     if(aRemoveList[i] == 0)
+    //     {
+    //         result = deleteColumn(result, i - minusNum);
+    //         ++minusNum;
+    //     }       
+    // }
+
+    // return result;
+
+    size_t columnSize = sum(aRemoveList, FunctionDirection::All)[0];
+    double* resultData = Aurora::malloc(columnSize * aOutPutMatrix.getDimSize(0));
+    Matrix result = Matrix::New(resultData, aOutPutMatrix.getDimSize(0), columnSize);
+    std::vector<std::pair<int,int>> copyList;
+    size_t length = 0;
+    for(size_t i=0; i<aRemoveList.getDataSize(); ++i)
+    {
+        if(aRemoveList[i] == 1)
+        {
+            ++length;
+        }
+
+        if(aRemoveList[i] == 0 && length != 0)
+        {
+            copyList.push_back({});
+            length = 0;
+        }
+    }
+
+}

src/common/dataBlockCreation/removeDataFromArrays.h

@@ -0,0 +1,11 @@
+#ifndef REMOVEDATAFROMARRAYS_H
+#define REMOVEDATAFROMARRAYS_H
+
+#include "Matrix.h"
+
+namespace Recon
+{
+    Aurora::Matrix removeDataFromArrays(const Aurora::Matrix& aOutPutMatrix, const Aurora::Matrix& aRemoveList);
+}
+
+#endif

src/reflectionReconstruction/dataFilter.cpp

@@ -3,21 +3,22 @@
 #include "Function2D.h"
 #include "Function3D.h"
 
+#include "src/config/config.h"
+
 #define PI 3.141592653589793238462
 using namespace Aurora;
 namespace Recon {
 Matrix filterReflectionData(const Matrix &aVReceiverPositionBlock,
                             const Matrix &aVSenderPositionBlock,
                             const Matrix &aVSenderNormalBlock,
-                            int aConstrictReflectionAngles,
+                            int aConstrictReflectionAngles) {
-                            double aAngleLowerLimit, double aAngleUpperLimit) {
     auto reflectData = ones(1, aVReceiverPositionBlock.getDimSize(1));
     if (aConstrictReflectionAngles == 1) {
         auto positionDifs = aVReceiverPositionBlock - aVSenderPositionBlock;
         auto inbetweenAngle = acos(dot(aVSenderNormalBlock, positionDifs) /
                                 vecnorm(positionDifs, Norm2, 1));
-        auto flags = Aurora::auroraNot((inbetweenAngle < (PI * aAngleLowerLimit / 180)) +
+        auto flags = Aurora::auroraNot((inbetweenAngle < (PI * transParams::angleLowerLimit / 180)) +
-                    (inbetweenAngle > (PI * aAngleUpperLimit / 180)));
+                    (inbetweenAngle > (PI * transParams::angleUpperLimit / 180)));
         reflectData = reflectData * flags;
     }
     return reflectData;

src/reflectionReconstruction/dataFilter.h

@@ -6,9 +6,7 @@ namespace Recon {
     Aurora::Matrix filterReflectionData(const Aurora::Matrix &aVReceiverPositionBlock,
                                     const Aurora::Matrix &aVSenderPositionBlock,
                                     const Aurora::Matrix &aVSenderNormalBlock,
-                                    int aConstrictReflectionAngles,
+                                    int aConstrictReflectionAngles);
-                                    double aAngleLowerLimit,
-                                    double aAngleUpperLimit);
 }
 
 

src/transmissionReconstruction/dataFilter/dataFilter.cpp

@@ -1,4 +1,5 @@
 #include "dataFilter.h"
+#include "src/config/config.h"
 
 #include <cmath>
 #include <cstddef>
@@ -79,18 +80,17 @@ namespace Recon {
         return sosValues;
     }
     
-    Aurora::Matrix filterTransmissionData(int aFilterSensitivity, const Aurora::Matrix &aVslBlock,
+    Aurora::Matrix filterTransmissionData(const Aurora::Matrix &aVslBlock,
         const Aurora::Matrix &aVsnBlock, const Aurora::Matrix &aVrlBlock,
         const Aurora::Matrix &aVrnBlock, std::vector<Aurora::Matrix> &aMSensData,
         const Aurora::Matrix &aMSenderNormalBlock,
-        const Aurora::Matrix &aMReceiverNormalBlock,
+        const Aurora::Matrix &aMReceiverNormalBlock)
-        double* params)
     {
-        switch (aFilterSensitivity) {
+        switch (transParams::filterSensitivity) {
             case 1:
-                return filterTransmissionSensitivityMap(params[0], aVslBlock, aVsnBlock, aVrlBlock, aVrnBlock, aMSensData);
+                return filterTransmissionSensitivityMap(transParams::sensFilter, aVslBlock, aVsnBlock, aVrlBlock, aVrnBlock, aMSensData);
             case 2:
-                return filterTransmissionAngle(params[0], params[1], aMSenderNormalBlock, aMReceiverNormalBlock);
+                return filterTransmissionAngle(transParams::angleLowerLimit, transParams::angleUpperLimit, aMSenderNormalBlock, aMReceiverNormalBlock);
         }
         std::cerr<<"FilterSensitivity value error!"<<std::endl;
         return Aurora::Matrix();

src/transmissionReconstruction/dataFilter/dataFilter.h

@@ -25,7 +25,6 @@ Aurora::Matrix checkTofDetections(Aurora::Matrix &aVTofValues,
 /**
  * filterTransmissionData
  *
- * @param aFilterSensitivity
  * @param aVslBlock
  * @param aVsnBlock
  * @param aVrlBlock
@@ -33,17 +32,15 @@ Aurora::Matrix checkTofDetections(Aurora::Matrix &aVTofValues,
  * @param aMSensData
  * @param aMSenderNormalBlock
  * @param aMReceiverNormalBlock
- * @param params
  * 如果aFilterSensitivity为1，单个值sensFilter，如果为2，双值angleLowerLimit,
  * angleUpperLimit
  * @return Aurora::Matrix
  */
-Aurora::Matrix filterTransmissionData(
+Aurora::Matrix filterTransmissionData( const Aurora::Matrix &aVslBlock,
-    int aFilterSensitivity, const Aurora::Matrix &aVslBlock,
     const Aurora::Matrix &aVsnBlock, const Aurora::Matrix &aVrlBlock,
     const Aurora::Matrix &aVrnBlock, std::vector<Aurora::Matrix> &aMSensData,
     const Aurora::Matrix &aMSenderNormalBlock,
-    const Aurora::Matrix &aMReceiverNormalBlock, double *params);
+    const Aurora::Matrix &aMReceiverNormalBlock);
 
 Aurora::Matrix findDefectTransmissionData(const Aurora::Matrix &aVSNRList,double aSNRDifference);
 

test/Common_Test.cpp

@@ -8,6 +8,7 @@
 #include "common/getGeometryInfo.h"
 #include "common/dataBlockCreation/getAscanBlock.h"
 #include "common/dataBlockCreation/blockingGeometryInfo.h"
+#include "common/dataBlockCreation/removeDataFromArrays.h"
 
 #include "Parser.h"
 #include "MatlabReader.h"
@@ -328,3 +329,14 @@ TEST_F(Common_Test, blockingGeometryInfos) {
         EXPECT_DOUBLE_AE(senderPositionBlock[i], result.senderPositionBlock[i]);
     }
 }
+
+TEST_F(Common_Test, removeDataFromArrays) {
+    Aurora::Matrix a = Aurora::Matrix::fromRawData(new double[8]{1,2,3,4,5,6,7,8}, 1,8);
+    Aurora::Matrix b = Aurora::Matrix::fromRawData(new double[8]{0,0,1,1,1,1,0,0}, 1,8);
+    auto result = Recon::removeDataFromArrays(a, b);
+    EXPECT_DOUBLE_EQ(result.getDataSize(), 4);
+    EXPECT_DOUBLE_EQ(result[0], 3);
+    EXPECT_DOUBLE_EQ(result[1], 4);
+    EXPECT_DOUBLE_EQ(result[2], 5);
+    EXPECT_DOUBLE_EQ(result[3], 6);
+}

test/DataFilter_Test.cpp

@@ -122,9 +122,7 @@ TEST_F(DataFilter_Test, filterReflectionData) {
     auto senderPositionBlock = Aurora::transpose(Aurora::Matrix::fromRawData(new double[9]{-0.12,-0.12,-0.12,-0.01,-0.01,-0.01,0.03,0.03,0.03}, 3, 3));
     auto senderNormalBlock  = Aurora::transpose(Aurora::Matrix::fromRawData(new double[9]{0.99,0.99,0.99,0.10,0.10,0.10,0,0,0}, 3, 3));
     int constrictReflectionAngles = 1;
-    double lowerAngle = 45;
+    auto result = Recon::filterReflectionData(receiverPositionBlock, senderPositionBlock, senderNormalBlock, constrictReflectionAngles);
-    double upperAngle = 360;
-    auto result = Recon::filterReflectionData(receiverPositionBlock, senderPositionBlock, senderNormalBlock, constrictReflectionAngles, lowerAngle, upperAngle);
     EXPECT_EQ(3, result.getDataSize());
     EXPECT_DOUBLE_AE(result[0],1);
     EXPECT_DOUBLE_AE(result[1],1);