Add blockingGeometryInfos.

src/common/dataBlockCreation/blockingGeometryInfo.cpp

@@ -0,0 +1,74 @@
+#include "blockingGeometryInfo.h"
+#include "Function.h"
+#include "Function2D.h"
+#include "Function3D.h"
+
+using namespace Aurora;
+using namespace Recon;
+
+GeometryBlock Recon::blockingGeometryInfos(const GeometryInfo& aGeom, const Aurora::Matrix& aRnBlock, const Aurora::Matrix& aRlBlock,
+                                           const Aurora::Matrix& aSnBlock, const Aurora::Matrix& aSlBlock, const Aurora::Matrix& aMpBlock)
+{
+    GeometryBlock result;
+    int numData = aRnBlock.getDimSize(1);
+    Matrix arrayOfDataSize = zeros(1, numData, 1) + 1;
+    int dim = aGeom.receiverPositions[0].getDimSize(0);
+    double* receiverPositionBlockData = Aurora::malloc(dim * numData);
+    double* receiverNormalBlockData = Aurora::malloc(dim * numData);
+    result.receiverPositionBlock = Matrix::New(receiverPositionBlockData, dim, numData);
+    result.receiverNormalBlock = Matrix::New(receiverNormalBlockData, dim, numData);
+
+    double* sizeData = Aurora::malloc(4);
+    sizeData[0] = aGeom.receiverPositions[0].getDimSize(0);
+    sizeData[1] = aGeom.receiverPositions[0].getDimSize(1);
+    sizeData[2] = aGeom.receiverPositions[0].getDimSize(2);
+    sizeData[3] = aGeom.receiverPositions.size();
+    size_t matrixSize = aGeom.receiverPositions[0].getDataSize();
+    Matrix receiverPositionsSize = Matrix::New(sizeData, 1, 4);
+    for(int i=0; i<dim; ++i)
+    {
+        Matrix idx = sub2ind(receiverPositionsSize, {arrayOfDataSize * (i+1), aRnBlock, aRlBlock, aMpBlock});
+        for(int j=0; j<idx.getDataSize(); ++j)
+        {
+
+            unsigned long long index4D = (idx[j] - 1) / matrixSize;
+            unsigned long long index3D = idx[j] - 1;
+            if(index4D > 0)
+            {
+                index3D -= matrixSize;
+            }
+            receiverPositionBlockData[dim*j + i] = aGeom.receiverPositions[index4D][index3D];
+            receiverNormalBlockData[dim*j + i] = aGeom.receiverNormals[index4D][index3D];
+        }
+    }
+
+    double* senderPositionBlockData = Aurora::malloc(dim * numData);
+    double* senderNormalBlockData = Aurora::malloc(dim * numData);
+    result.senderPositionBlock = Matrix::New(senderPositionBlockData, dim, numData);
+    result.senderNormalBlock = Matrix::New(senderNormalBlockData, dim, numData);
+    sizeData = Aurora::malloc(4);
+    sizeData[0] = aGeom.senderPositions[0].getDimSize(0);
+    sizeData[1] = aGeom.senderPositions[0].getDimSize(1);
+    sizeData[2] = aGeom.senderPositions[0].getDimSize(2);
+    sizeData[3] = aGeom.senderPositions.size();
+    matrixSize = aGeom.receiverPositions[0].getDataSize();
+    Matrix senderPositionsSize = Matrix::New(sizeData, 1, 4);
+    dim = aGeom.senderPositions[0].getDimSize(0);
+    for(int i=0; i<dim; ++i)
+    {
+        Matrix idx = sub2ind(senderPositionsSize, {arrayOfDataSize * (i+1), aSnBlock, aSlBlock, aMpBlock});
+        for(int j=0; j<idx.getDataSize(); ++j)
+        {
+
+            unsigned long long index4D = (idx[j] - 1) / matrixSize;
+            unsigned long long index3D = idx[j] - 1;
+            if(index4D > 0)
+            {
+                index3D -= matrixSize;
+            }
+            senderPositionBlockData[dim*j + i] = aGeom.senderPositions[index4D][index3D];
+            senderNormalBlockData[dim*j + i] = aGeom.senderNormals[index4D][index3D];
+        }
+    }
+    return result;
+}

src/common/dataBlockCreation/blockingGeometryInfo.h

@@ -0,0 +1,22 @@
+#ifndef BLOCKING_GEOMETRYINFO_H
+#define BLOCKING_GEOMETRYINFO_H
+
+#include "Matrix.h"
+#include "src/common/getGeometryInfo.h"
+
+namespace Recon
+{
+    struct GeometryBlock
+    {
+        Aurora::Matrix senderPositionBlock;
+        Aurora::Matrix senderNormalBlock;
+        Aurora::Matrix receiverPositionBlock;
+        Aurora::Matrix receiverNormalBlock;
+    };
+
+    GeometryBlock blockingGeometryInfos(const GeometryInfo& aGeom, const Aurora::Matrix& aRnBlock, const Aurora::Matrix& aRlBlock,
+                                        const Aurora::Matrix& aSnBlock, const Aurora::Matrix& aSlBlock, const Aurora::Matrix& aMpBlock);
+                                        
+}
+
+#endif

test/Common_Test.cpp

@@ -1,11 +1,13 @@
 #include <gtest/gtest.h>
 
+#include "Function2D.h"
 #include "Matrix.h"
 #include "common/ceMatchedFilterHandling.h"
 #include "common/common.h"
 #include "common/convertfp16tofloat.h"
 #include "common/getGeometryInfo.h"
-#include "common/daraBlockCreation/getAscanBlock.h"
+#include "common/dataBlockCreation/getAscanBlock.h"
+#include "common/dataBlockCreation/blockingGeometryInfo.h"
 
 #include "Parser.h"
 #include "MatlabReader.h"
@@ -232,7 +234,7 @@ TEST_F(Common_Test, getAscanBlock) {
                                         Aurora::Matrix::fromRawData(new double[18]{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18}, 18),
                                         Aurora::Matrix::fromRawData(new double[1]{1}, 1),
                                         Aurora::Matrix::fromRawData(new double[18]{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18}, 18));
-    for(int i=0; i<ascanBlock.getDataSize(); ++i)
+    for(int i=0; i<result.ascanBlock.getDataSize(); ++i)
     {
         EXPECT_DOUBLE_AE(ascanBlock[i], result.ascanBlock[i]);
     }
@@ -240,7 +242,7 @@ TEST_F(Common_Test, getAscanBlock) {
     EXPECT_DOUBLE_EQ(ascanBlock.getDimSize(1), result.ascanBlock.getDimSize(1));
 
     auto gainBlock = m.read("gainBlock");
-    for(int i=0; i<gainBlock.getDataSize(); ++i)
+    for(int i=0; i<result.gainBlock.getDataSize(); ++i)
     {
         EXPECT_DOUBLE_AE(gainBlock[i], result.gainBlock[i]);
     }
@@ -248,7 +250,7 @@ TEST_F(Common_Test, getAscanBlock) {
     EXPECT_DOUBLE_EQ(gainBlock.getDimSize(1), result.gainBlock.getDimSize(1));
 
     auto mpBlock = m.read("mpBlock");
-    for(int i=0; i<mpBlock.getDataSize(); ++i)
+    for(int i=0; i<result.mpBlock.getDataSize(); ++i)
     {
         EXPECT_DOUBLE_AE(mpBlock[i], result.mpBlock[i]);
     }
@@ -256,7 +258,7 @@ TEST_F(Common_Test, getAscanBlock) {
     EXPECT_DOUBLE_EQ(mpBlock.getDimSize(1), result.mpBlock.getDimSize(1));
 
     auto rlBlock = m.read("rlBlock");
-    for(int i=0; i<rlBlock.getDataSize(); ++i)
+    for(int i=0; i<result.rlBlock.getDataSize(); ++i)
     {
         EXPECT_DOUBLE_AE(rlBlock[i], result.rlBlock[i]);
     }
@@ -264,7 +266,7 @@ TEST_F(Common_Test, getAscanBlock) {
     EXPECT_DOUBLE_EQ(rlBlock.getDimSize(1), result.rlBlock.getDimSize(1));
 
     auto rnBlock = m.read("rnBlock");
-    for(int i=0; i<rnBlock.getDataSize(); ++i)
+    for(int i=0; i<result.rnBlock.getDataSize(); ++i)
     {
         EXPECT_DOUBLE_AE(rnBlock[i], result.rnBlock[i]);
     }
@@ -272,7 +274,7 @@ TEST_F(Common_Test, getAscanBlock) {
     EXPECT_DOUBLE_EQ(rnBlock.getDimSize(1), result.rnBlock.getDimSize(1));
 
     auto slBlock = m.read("slBlock");
-    for(int i=0; i<slBlock.getDataSize(); ++i)
+    for(int i=0; i<result.slBlock.getDataSize(); ++i)
     {
         EXPECT_DOUBLE_AE(slBlock[i], result.slBlock[i]);
     }
@@ -280,10 +282,49 @@ TEST_F(Common_Test, getAscanBlock) {
     EXPECT_DOUBLE_EQ(slBlock.getDimSize(1), result.slBlock.getDimSize(1));
 
     auto snBlock = m.read("snBlock");
-    for(int i=0; i<snBlock.getDataSize(); ++i)
+    for(int i=0; i<result.snBlock.getDataSize(); ++i)
     {
         EXPECT_DOUBLE_AE(snBlock[i], result.snBlock[i]);
     }
     EXPECT_DOUBLE_EQ(snBlock.getDimSize(0), result.snBlock.getDimSize(0));
     EXPECT_DOUBLE_EQ(snBlock.getDimSize(1), result.snBlock.getDimSize(1));
 }
+
+TEST_F(Common_Test, blockingGeometryInfos) {
+    Recon::GeometryInfo geom;
+    MatlabReader geomReader("/home/sun/testData/getGeometryInfo.mat");
+    geom.receiverNormals = geomReader.read4d("receiverNormals");
+    geom.receiverPositions = geomReader.read4d("receiverPositions");
+    geom.senderNormals = geomReader.read4d("senderNormals");
+    geom.senderPositions = geomReader.read4d("senderPositions");
+
+    MatlabReader m("/home/sun/testData/blockingGeometryInfo.mat");
+    std::string dataPath = "/home/AScans_Data/volunteer_20230328/20230328T123237/";
+    Parser parser(dataPath);
+    auto rnBlock = m.read("rnBlock");
+    auto rlBlock = m.read("rlBlock");
+    auto snBlock = m.read("snBlock");
+    auto slBlock = m.read("slBlock");
+    auto mpBlock = m.read("mpBlock");
+    auto result = Recon::blockingGeometryInfos(geom, rnBlock, rlBlock, snBlock, slBlock, mpBlock);
+    auto receiverNormalBlock = m.read("receiverNormalBlock");
+    for(int i=0; i<result.receiverNormalBlock.getDataSize(); ++i)
+    {
+        EXPECT_DOUBLE_AE(receiverNormalBlock[i], result.receiverNormalBlock[i]);
+    }
+    auto receiverPositionBlock = m.read("receiverPositionBlock");
+    for(int i=0; i<result.receiverPositionBlock.getDataSize(); ++i)
+    {
+        EXPECT_DOUBLE_AE(receiverPositionBlock[i], result.receiverPositionBlock[i]);
+    }
+    auto senderNormalBlock = m.read("senderNormalBlock");
+    for(int i=0; i<result.senderNormalBlock.getDataSize(); ++i)
+    {
+        EXPECT_DOUBLE_AE(senderNormalBlock[i], result.senderNormalBlock[i]);
+    }
+    auto senderPositionBlock = m.read("senderPositionBlock");
+    for(int i=0; i<result.senderPositionBlock.getDataSize(); ++i)
+    {
+        EXPECT_DOUBLE_AE(senderPositionBlock[i], result.senderPositionBlock[i]);
+    }
+}