sunwen/UR
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: fix all TEST and add DICOM export TEST

Browse Source
This commit is contained in:
kradchen
2024-09-19 15:37:02 +08:00
parent 4c4ab3794e
commit 01210045bc
10 changed files with 287 additions and 377 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
CMakeLists.txt
View File

@@ -60,7 +60,8 @@ INCLUDE_DIRECTORIES(${GTEST_INCLUDE_DIRS})
enable_testing()
file(GLOB_RECURSE test_cpp test/*.cpp)
add_executable(UR_Test ${cpp_files} ${header_files} ${Aurora_Source} ${test_cpp} )
add_executable(UR_Test ${cpp_files} ${header_files} ${Aurora_Source} ${test_cpp} ${cu_files} ${Aurora_Source} ${Aurora_Source_Cu} ./src/Aurora.cu ${Aurora_DIR}/src/CudaMatrixPrivate.cu)
target_include_directories(UR_Test PUBLIC ./test/ ./src/)
# target_compile_options(UR_Test PUBLIC ${Aurora_Complie_Options} "-march=native")
target_include_directories(UR_Test PUBLIC ${DCMTK_INCLUDE_DIRS})
@@ -79,5 +80,12 @@ target_link_libraries(UR_Test PUBLIC URDepends::eikonal)
target_link_libraries(UR_Test PUBLIC URDepends::TVALGPU)
target_link_libraries(UR_Test PUBLIC URDepends::SaftTofi)
# target_link_libraries(UR_Test PUBLIC URDepends::SaftATT)
target_include_directories(UR_Test PRIVATE ./src /usr/local/cuda/include)
set_target_properties(UR_Test PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_compile_options(UR_Test PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:
-arch=sm_75 --expt-extended-lambda
>)
target_link_libraries(UR_Test PRIVATE ${CUDA_RUNTIME_LIBRARY} CUDA::cufft CUDA::cudart)
gtest_discover_tests(UR_Test)

137
src/reflectionReconstruction/startReflectionReconstruction.cpp.orig
View File

@@ -1,137 +0,0 @@
#include "startReflectionReconstruction.h"
#include "Function.h"
#include "Function2D.h"
#include "Function3D.h"
#include "Matrix.h"
#include "MatlabWriter.h"
#include "common/getGeometryInfo.h"
#include "common/precalculateChannelList.h"
#include "common/dataBlockCreation/getAScanBlockPreprocessed.h"
#include "common/dataBlockCreation/removeDataFromArrays.h"
#include "log/notify.h"
#include "reflectionReconstruction/preprocessData/determineOptimalPulse.h"
#include "reflectionReconstruction/reconstructionSAFT/reconstructionSAFT.h"
#include "src/reflectionReconstruction/preprocessData/preprocessAScanBlockForReflection.h"
#include "config/config.h"
#include "log/log.h"
#include "CudaEnvInit.h"
#include <cstdio>
#include <iostream>
#include <queue>
#include <thread>
#include <vector>
using namespace Aurora;
using namespace Recon;
namespace
{
std::queue<preprocessAScanRResult> PRODUCER_PROCESSDATAS;
std::queue<AscanBlockPreprocessed> PRODUCER_BLOCKDATAS;
std::mutex PRODUCER_MUTEX;
std::condition_variable PRODUCER_CONDITION;
std::mutex CUSTOMER_MUTEX;
std::condition_variable CUSTOMER_CONDITION;
}
void producerThread( Parser* aParser, const Aurora::Matrix& aMotorPos,
const Aurora::Matrix& aSlList, const Aurora::Matrix& aSnList,
const Aurora::Matrix& aRlList, const Aurora::Matrix& aRnList,
GeometryInfo& aGeom, MeasurementInfo& aExpInfo, PreComputes& aPreComputes)
{
if(reflectParams::useOptPulse==1 && reflectParams::runReflectionReco)
{
aPreComputes.sincPeak_ft = determineOptimalPulse(aPreComputes.timeInterval, aExpInfo.expectedAScanLength);
}
printf(" - channel list");
auto channelList = precalculateChannelList(aRlList, aRnList, aExpInfo, aPreComputes);
size_t numScans = aMotorPos.getDataSize() * aSlList.getDataSize() *
aSnList.getDataSize() * aRlList.getDataSize() *
aRnList.getDataSize();
int numTakenScans = 0,numProcessedScans = 0,numPossibleScans = 0;
for(int i=0; i<aMotorPos.getDataSize(); ++i)
{
//#pragma omp parallel for num_threads(24)
for(int j=0; j<aSlList.getDataSize() / transParams::senderTASSize; ++j)
{
for(int k=0; k<aSnList.getDataSize() / transParams::senderElementSize; ++k)
{
Matrix mp = aMotorPos(i).toMatrix();
Matrix sl = aSlList.block(0, transParams::senderTASSize*j, transParams::senderTASSize*j+transParams::senderTASSize - 1);
Matrix sn = aSnList.block(0, transParams::senderElementSize*k, transParams::senderElementSize*k+transParams::senderElementSize - 1);
auto blockData = getAscanBlockPreprocessed(aParser, mp, sl, sn, aRlList, aRnList, aGeom, aExpInfo, true, false);
float* channelListSizeData = Aurora::malloc(2);
channelListSizeData[0] = channelList.getDimSize(0);
channelListSizeData[1] = channelList.getDimSize(1);
Matrix channelListSize = Matrix::New(channelListSizeData, 2, 1);
Matrix ind = sub2ind(channelListSize, {blockData.rlBlock, blockData.rnBlock});
size_t channelBlockSize = ind.getDataSize();
float* channelBlockData = Aurora::malloc(channelBlockSize);
for(size_t i=0; i<channelBlockSize; ++i)
{
channelBlockData[i] = channelList[ind[i] - 1];
}
Matrix channelBlock = Matrix::New(channelBlockData, 1, channelBlockSize);
RECON_INFO("start cpu---------preprocessAScanBlockForReflection");
auto preprocessData = preprocessAScanBlockForReflection(blockData.ascanBlockPreprocessed, blockData.mpBlock, blockData.slBlock,
blockData.snBlock, blockData.rlBlock, blockData.rnBlock, blockData.senderPositionBlock,
blockData.receiverPositionBlock, blockData.gainBlock, channelBlock, aExpInfo, aPreComputes);
PRODUCER_BLOCKDATAS.push(blockData);
PRODUCER_PROCESSDATAS.push(preprocessData);
}
}
}
}
Aurora::Matrix Recon::startReflectionReconstruction( Parser* aParser, int aSAFT_mode, const Aurora::Matrix& aMotorPos,
const Aurora::Matrix& aSlList, const Aurora::Matrix& aSnList,
const Aurora::Matrix& aRlList, const Aurora::Matrix& aRnList,
GeometryInfo& aGeom, TransRecos& aTransRecos,
MeasurementInfo& aExpInfo, PreComputes& aPreComputes)
{
printf("Reflection reconstruction is carried out.");
printf("Preperations for reconstructions.");
printf(" - reset GPUs");
for (size_t i = 0; i < reflectParams::gpuSelectionList.getDataSize(); i++)
{
std::string msg;
if (!resetGPUDevice((int)reflectParams::gpuSelectionList[i],msg))
{
std::cerr<<msg<<std::endl;
}
}
std::thread thread = std::thread(producerThread, aParser, aMotorPos, aSlList, aSnList, aRlList, aRnList, aGeom, aExpInfo, aPreComputes);
Matrix Env = Aurora::zeros((int)reflectParams::imageXYZ[0],(int)reflectParams::imageXYZ[1],(int)reflectParams::imageXYZ[2]);
for(int i=0; i<aMotorPos.getDataSize(); ++i)
{
//#pragma omp parallel for num_threads(24)
for(int j=0; j<aSlList.getDataSize() / transParams::senderTASSize; ++j)
{
for(int k=0; k<aSnList.getDataSize() / transParams::senderElementSize; ++k)
{
RECON_INFO("start gpu---------recontructSAFT");
Env = recontructSAFT(removeDataFromArrays(preprocessData.AscanBlock, preprocessData.usedData),
removeDataFromArrays(blockData.senderPositionBlock, preprocessData.usedData),
removeDataFromArrays(blockData.receiverPositionBlock, preprocessData.usedData),
removeDataFromArrays(blockData.mpBlock, preprocessData.usedData),
aSAFT_mode, aTransRecos, Env);
std::cout<<Env[0]<<"-" << Env[1] <<"-" << Env[2] <<"-" << Env[3]<<std::endl;
RECON_INFO("Reflection Reconstructon: " + std::to_string(j));
}
//Recon::notifyProgress(25+73*((j*i)/(aMotorPos.getDataSize() * aSlList.getDataSize())));
}
}
return Env;
}

192
test/Common_Test.cpp
View File

@@ -14,12 +14,12 @@
#include "Parser.h"
#include "MatlabReader.h"
inline double fourDecimalRound(double src){
inline float fourDecimalRound(float src){
return round(src*10000.0)/10000.0;
}
#define EXPECT_DOUBLE_AE(valueA,valueB)\
EXPECT_DOUBLE_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
#define EXPECT_float_AE(valueA,valueB)\
EXPECT_FLOAT_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
class Common_Test : public ::testing::Test {
protected:
@@ -47,7 +47,7 @@ TEST_F(Common_Test, adaptFrequency) {
auto output = m.read("output");
for (size_t i = 0; i < 4096; i++)
{
EXPECT_DOUBLE_AE(mCe.getData()[i],output.getData()[i])<<", index:"<<i;
EXPECT_float_AE(mCe.getData()[i],output.getData()[i])<<", index:"<<i;
}
}
@@ -57,7 +57,7 @@ TEST_F(Common_Test, convertfp16tofloat) {
size_t count = 0;
auto input = m.readint16("input",count);
auto ma = Aurora::Matrix::copyFromRawData((double*)input.get(),count/4);
auto ma = Aurora::Matrix::copyFromRawData((float*)input.get(),count/4);
auto resultM = Recon::convertfp16tofloat(ma);
auto result = resultM.getData();
auto output = m.read("output");
@@ -70,24 +70,24 @@ TEST_F(Common_Test, convertfp16tofloat) {
TEST_F(Common_Test, convertToLinearIndices) {
//2D
{
double *dataA = new double[6]{1, 9, 4, 0, .01, 1.9};
float *dataA = new float[6]{1, 9, 4, 0, .01, 1.9};
auto A = Aurora::Matrix::fromRawData(dataA, 3, 2);
double *dataB = new double[2]{3, 2};
float *dataB = new float[2]{3, 2};
auto B = Aurora::Matrix::fromRawData(dataB, 2, 1);
auto output =Recon::convertToLinearIndices(B,A);
EXPECT_DOUBLE_AE(-2,output.getData()[0]);
EXPECT_DOUBLE_AE(6.03,output.getData()[1]);
EXPECT_DOUBLE_AE(6.7,output.getData()[2]);
EXPECT_float_AE(-2,output.getData()[0]);
EXPECT_float_AE(6.03,output.getData()[1]);
EXPECT_float_AE(6.7,output.getData()[2]);
}
//3D
{
double *dataA = new double[12]{1, 9, 4, 0, .01, 1.9, 1, 9, 4, 0, .01, 1.9};
float *dataA = new float[12]{1, 9, 4, 0, .01, 1.9, 1, 9, 4, 0, .01, 1.9};
auto A = Aurora::Matrix::fromRawData(dataA, 2, 3, 2);
double *dataB = new double[3]{3, 2, 2};
float *dataB = new float[3]{3, 2, 2};
auto B = Aurora::Matrix::fromRawData(dataB, 3, 1);
auto output =Recon::convertToLinearIndices(B,A);
EXPECT_DOUBLE_AE(4.06,output.getData()[0]);
EXPECT_DOUBLE_AE(11.4,output.getData()[1]);
EXPECT_float_AE(4.06,output.getData()[0]);
EXPECT_float_AE(11.4,output.getData()[1]);
}
@@ -110,121 +110,121 @@ TEST_F(Common_Test, getGeometryInfo) {
auto receiverPositions = geom.receiverPositions;
auto senderNormals = geom.senderNormals;
auto senderPositions = geom.senderPositions;
EXPECT_DOUBLE_EQ(correctReceiverNormals.size(), receiverNormals.size());
EXPECT_FLOAT_EQ(correctReceiverNormals.size(), receiverNormals.size());
for(int i=0;i<correctReceiverNormals.size();++i)
{
EXPECT_DOUBLE_EQ(correctReceiverNormals[i].getDimSize(0), receiverNormals[i].getDimSize(0));
EXPECT_DOUBLE_EQ(correctReceiverNormals[i].getDimSize(1), receiverNormals[i].getDimSize(1));
EXPECT_DOUBLE_EQ(correctReceiverNormals[i].getDimSize(2), receiverNormals[i].getDimSize(2));
EXPECT_FLOAT_EQ(correctReceiverNormals[i].getDimSize(0), receiverNormals[i].getDimSize(0));
EXPECT_FLOAT_EQ(correctReceiverNormals[i].getDimSize(1), receiverNormals[i].getDimSize(1));
EXPECT_FLOAT_EQ(correctReceiverNormals[i].getDimSize(2), receiverNormals[i].getDimSize(2));
for(int j=0;j<correctReceiverNormals[i].getDataSize();++j)
{
EXPECT_DOUBLE_AE(correctReceiverNormals[i][j], receiverNormals[i][j]);
EXPECT_float_AE(correctReceiverNormals[i][j], receiverNormals[i][j]);
}
}
EXPECT_DOUBLE_EQ(correctReceiverPositions.size(), receiverPositions.size());
EXPECT_FLOAT_EQ(correctReceiverPositions.size(), receiverPositions.size());
for(int i=0;i<correctReceiverPositions.size();++i)
{
EXPECT_DOUBLE_EQ(correctReceiverPositions[i].getDimSize(0), receiverPositions[i].getDimSize(0));
EXPECT_DOUBLE_EQ(correctReceiverPositions[i].getDimSize(1), receiverPositions[i].getDimSize(1));
EXPECT_DOUBLE_EQ(correctReceiverPositions[i].getDimSize(2), receiverPositions[i].getDimSize(2));
EXPECT_FLOAT_EQ(correctReceiverPositions[i].getDimSize(0), receiverPositions[i].getDimSize(0));
EXPECT_FLOAT_EQ(correctReceiverPositions[i].getDimSize(1), receiverPositions[i].getDimSize(1));
EXPECT_FLOAT_EQ(correctReceiverPositions[i].getDimSize(2), receiverPositions[i].getDimSize(2));
for(int j=0;j<correctReceiverPositions[i].getDataSize();++j)
{
EXPECT_DOUBLE_AE(correctReceiverPositions[i][j], receiverPositions[i][j]);
EXPECT_float_AE(correctReceiverPositions[i][j], receiverPositions[i][j]);
}
}
EXPECT_DOUBLE_EQ(correctSenderNormals.size(), senderNormals.size());
EXPECT_FLOAT_EQ(correctSenderNormals.size(), senderNormals.size());
for(int i=0;i<correctSenderNormals.size();++i)
{
EXPECT_DOUBLE_EQ(correctSenderNormals[i].getDimSize(0), senderNormals[i].getDimSize(0));
EXPECT_DOUBLE_EQ(correctSenderNormals[i].getDimSize(1), senderNormals[i].getDimSize(1));
EXPECT_DOUBLE_EQ(correctSenderNormals[i].getDimSize(2), senderNormals[i].getDimSize(2));
EXPECT_FLOAT_EQ(correctSenderNormals[i].getDimSize(0), senderNormals[i].getDimSize(0));
EXPECT_FLOAT_EQ(correctSenderNormals[i].getDimSize(1), senderNormals[i].getDimSize(1));
EXPECT_FLOAT_EQ(correctSenderNormals[i].getDimSize(2), senderNormals[i].getDimSize(2));
for(int j=0;j<correctSenderNormals[i].getDataSize();++j)
{
EXPECT_DOUBLE_AE(correctSenderNormals[i][j], senderNormals[i][j]);
EXPECT_float_AE(correctSenderNormals[i][j], senderNormals[i][j]);
}
}
EXPECT_DOUBLE_EQ(correctSenderPositions.size(), senderPositions.size());
EXPECT_FLOAT_EQ(correctSenderPositions.size(), senderPositions.size());
for(int i=0;i<correctSenderPositions.size();++i)
{
EXPECT_DOUBLE_EQ(correctSenderPositions[i].getDimSize(0), senderPositions[i].getDimSize(0));
EXPECT_DOUBLE_EQ(correctSenderPositions[i].getDimSize(1), senderPositions[i].getDimSize(1));
EXPECT_DOUBLE_EQ(correctSenderPositions[i].getDimSize(2), senderPositions[i].getDimSize(2));
EXPECT_FLOAT_EQ(correctSenderPositions[i].getDimSize(0), senderPositions[i].getDimSize(0));
EXPECT_FLOAT_EQ(correctSenderPositions[i].getDimSize(1), senderPositions[i].getDimSize(1));
EXPECT_FLOAT_EQ(correctSenderPositions[i].getDimSize(2), senderPositions[i].getDimSize(2));
for(int j=0;j<correctSenderPositions[i].getDataSize();++j)
{
EXPECT_DOUBLE_AE(correctSenderPositions[i][j], senderPositions[i][j]);
EXPECT_float_AE(correctSenderPositions[i][j], senderPositions[i][j]);
}
}
Aurora::Matrix sensChar = m.read("sensChar");
EXPECT_DOUBLE_EQ(geom.sensChar.getDataSize(), sensChar.getDataSize());
EXPECT_FLOAT_EQ(geom.sensChar.getDataSize(), sensChar.getDataSize());
for(int i=0;i<geom.sensChar.getDataSize();++i)
{
EXPECT_DOUBLE_AE(geom.sensChar.getData()[i], sensChar.getData()[i]);
EXPECT_float_AE(geom.sensChar.getData()[i], sensChar.getData()[i]);
}
Aurora::Matrix headTable = m.read("headTable");
EXPECT_DOUBLE_EQ(geom.headTable.getDataSize(), headTable.getDataSize());
EXPECT_FLOAT_EQ(geom.headTable.getDataSize(), headTable.getDataSize());
for(int i=0;i<geom.headTable.getDataSize();++i)
{
EXPECT_DOUBLE_AE(geom.headTable.getData()[i], headTable.getData()[i]);
EXPECT_float_AE(geom.headTable.getData()[i], headTable.getData()[i]);
}
Aurora::Matrix minEmitter = m.read("minEmitter");
EXPECT_DOUBLE_EQ(geom.minEmitter.getDataSize(), minEmitter.getDataSize());
EXPECT_FLOAT_EQ(geom.minEmitter.getDataSize(), minEmitter.getDataSize());
for(int i=0;i<geom.minEmitter.getDataSize();++i)
{
EXPECT_DOUBLE_AE(geom.minEmitter.getData()[i], minEmitter.getData()[i]);
EXPECT_float_AE(geom.minEmitter.getData()[i], minEmitter.getData()[i]);
}
Aurora::Matrix minReceiver = m.read("minReceiver");
EXPECT_DOUBLE_EQ(geom.minReceiver.getDataSize(), minReceiver.getDataSize());
EXPECT_FLOAT_EQ(geom.minReceiver.getDataSize(), minReceiver.getDataSize());
for(int i=0;i<geom.minReceiver.getDataSize();++i)
{
EXPECT_DOUBLE_AE(geom.minReceiver.getData()[i], minReceiver.getData()[i]);
EXPECT_float_AE(geom.minReceiver.getData()[i], minReceiver.getData()[i]);
}
Aurora::Matrix minSize = m.read("minSize");
EXPECT_DOUBLE_EQ(geom.minSize.getDataSize(), minSize.getDataSize());
EXPECT_FLOAT_EQ(geom.minSize.getDataSize(), minSize.getDataSize());
for(int i=0;i<geom.minSize.getDataSize();++i)
{
EXPECT_DOUBLE_AE(geom.minSize.getData()[i], minSize.getData()[i]);
EXPECT_float_AE(geom.minSize.getData()[i], minSize.getData()[i]);
}
Aurora::Matrix maxEmitter = m.read("maxEmitter");
EXPECT_DOUBLE_EQ(geom.maxEmitter.getDataSize(), maxEmitter.getDataSize());
EXPECT_FLOAT_EQ(geom.maxEmitter.getDataSize(), maxEmitter.getDataSize());
for(int i=0;i<geom.maxEmitter.getDataSize();++i)
{
EXPECT_DOUBLE_AE(geom.maxEmitter.getData()[i], maxEmitter.getData()[i]);
EXPECT_float_AE(geom.maxEmitter.getData()[i], maxEmitter.getData()[i]);
}
Aurora::Matrix maxReceiver = m.read("maxReceiver");
EXPECT_DOUBLE_EQ(geom.maxReceiver.getDataSize(), maxReceiver.getDataSize());
EXPECT_FLOAT_EQ(geom.maxReceiver.getDataSize(), maxReceiver.getDataSize());
for(int i=0;i<geom.maxReceiver.getDataSize();++i)
{
EXPECT_DOUBLE_AE(geom.maxReceiver.getData()[i], maxReceiver.getData()[i]);
EXPECT_float_AE(geom.maxReceiver.getData()[i], maxReceiver.getData()[i]);
}
Aurora::Matrix maxSize = m.read("maxSize");
EXPECT_DOUBLE_EQ(geom.maxSize.getDataSize(), maxSize.getDataSize());
EXPECT_FLOAT_EQ(geom.maxSize.getDataSize(), maxSize.getDataSize());
for(int i=0;i<geom.maxSize.getDataSize();++i)
{
EXPECT_DOUBLE_AE(geom.maxSize.getData()[i], maxSize.getData()[i]);
EXPECT_float_AE(geom.maxSize.getData()[i], maxSize.getData()[i]);
}
Aurora::Matrix maxSL = m.read("maxSL");
EXPECT_DOUBLE_EQ(geom.maxSL, maxSL[0]);
EXPECT_FLOAT_EQ(geom.maxSL, maxSL[0]);
Aurora::Matrix maxSN = m.read("maxSN");
EXPECT_DOUBLE_EQ(geom.maxSN, maxSN[0]);
EXPECT_FLOAT_EQ(geom.maxSN, maxSN[0]);
Aurora::Matrix maxRL = m.read("maxRL");
EXPECT_DOUBLE_EQ(geom.maxRL, maxRL[0]);
EXPECT_FLOAT_EQ(geom.maxRL, maxRL[0]);
Aurora::Matrix maxRN = m.read("maxRN");
EXPECT_DOUBLE_EQ(geom.maxRN, maxRN[0]);
EXPECT_FLOAT_EQ(geom.maxRN, maxRN[0]);
}
TEST_F(Common_Test, getAscanBlock) {
@@ -232,64 +232,64 @@ TEST_F(Common_Test, getAscanBlock) {
std::string dataPath = "/home/AScans_Data/volunteer_20230328/20230328T123237/";
Parser parser(dataPath);
auto ascanBlock = m.read("AscanBlock");
auto result = Recon::getAscanBlock(&parser, Aurora::Matrix::fromRawData(new double[1]{1}, 1), 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),
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));
auto result = Recon::getAscanBlock(&parser, Aurora::Matrix::fromRawData(new float[1]{1}, 1), Aurora::Matrix::fromRawData(new float[1]{1}, 1),
Aurora::Matrix::fromRawData(new float[18]{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18}, 18),
Aurora::Matrix::fromRawData(new float[1]{1}, 1),
Aurora::Matrix::fromRawData(new float[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<result.ascanBlock.getDataSize(); ++i)
{
EXPECT_DOUBLE_AE(ascanBlock[i], result.ascanBlock[i]);
EXPECT_float_AE(ascanBlock[i], result.ascanBlock[i]);
}
EXPECT_DOUBLE_EQ(ascanBlock.getDimSize(0), result.ascanBlock.getDimSize(0));
EXPECT_DOUBLE_EQ(ascanBlock.getDimSize(1), result.ascanBlock.getDimSize(1));
EXPECT_FLOAT_EQ(ascanBlock.getDimSize(0), result.ascanBlock.getDimSize(0));
EXPECT_FLOAT_EQ(ascanBlock.getDimSize(1), result.ascanBlock.getDimSize(1));
auto gainBlock = m.read("gainBlock");
for(int i=0; i<result.gainBlock.getDataSize(); ++i)
{
EXPECT_DOUBLE_AE(gainBlock[i], result.gainBlock[i]);
EXPECT_float_AE(gainBlock[i], result.gainBlock[i]);
}
EXPECT_DOUBLE_EQ(gainBlock.getDimSize(0), result.gainBlock.getDimSize(0));
EXPECT_DOUBLE_EQ(gainBlock.getDimSize(1), result.gainBlock.getDimSize(1));
EXPECT_FLOAT_EQ(gainBlock.getDimSize(0), result.gainBlock.getDimSize(0));
EXPECT_FLOAT_EQ(gainBlock.getDimSize(1), result.gainBlock.getDimSize(1));
auto mpBlock = m.read("mpBlock");
for(int i=0; i<result.mpBlock.getDataSize(); ++i)
{
EXPECT_DOUBLE_AE(mpBlock[i], result.mpBlock[i]);
EXPECT_float_AE(mpBlock[i], result.mpBlock[i]);
}
EXPECT_DOUBLE_EQ(mpBlock.getDimSize(0), result.mpBlock.getDimSize(0));
EXPECT_DOUBLE_EQ(mpBlock.getDimSize(1), result.mpBlock.getDimSize(1));
EXPECT_FLOAT_EQ(mpBlock.getDimSize(0), result.mpBlock.getDimSize(0));
EXPECT_FLOAT_EQ(mpBlock.getDimSize(1), result.mpBlock.getDimSize(1));
auto rlBlock = m.read("rlBlock");
for(int i=0; i<result.rlBlock.getDataSize(); ++i)
{
EXPECT_DOUBLE_AE(rlBlock[i], result.rlBlock[i]);
EXPECT_float_AE(rlBlock[i], result.rlBlock[i]);
}
EXPECT_DOUBLE_EQ(rlBlock.getDimSize(0), result.rlBlock.getDimSize(0));
EXPECT_DOUBLE_EQ(rlBlock.getDimSize(1), result.rlBlock.getDimSize(1));
EXPECT_FLOAT_EQ(rlBlock.getDimSize(0), result.rlBlock.getDimSize(0));
EXPECT_FLOAT_EQ(rlBlock.getDimSize(1), result.rlBlock.getDimSize(1));
auto rnBlock = m.read("rnBlock");
for(int i=0; i<result.rnBlock.getDataSize(); ++i)
{
EXPECT_DOUBLE_AE(rnBlock[i], result.rnBlock[i]);
EXPECT_float_AE(rnBlock[i], result.rnBlock[i]);
}
EXPECT_DOUBLE_EQ(rnBlock.getDimSize(0), result.rnBlock.getDimSize(0));
EXPECT_DOUBLE_EQ(rnBlock.getDimSize(1), result.rnBlock.getDimSize(1));
EXPECT_FLOAT_EQ(rnBlock.getDimSize(0), result.rnBlock.getDimSize(0));
EXPECT_FLOAT_EQ(rnBlock.getDimSize(1), result.rnBlock.getDimSize(1));
auto slBlock = m.read("slBlock");
for(int i=0; i<result.slBlock.getDataSize(); ++i)
{
EXPECT_DOUBLE_AE(slBlock[i], result.slBlock[i]);
EXPECT_float_AE(slBlock[i], result.slBlock[i]);
}
EXPECT_DOUBLE_EQ(slBlock.getDimSize(0), result.slBlock.getDimSize(0));
EXPECT_DOUBLE_EQ(slBlock.getDimSize(1), result.slBlock.getDimSize(1));
EXPECT_FLOAT_EQ(slBlock.getDimSize(0), result.slBlock.getDimSize(0));
EXPECT_FLOAT_EQ(slBlock.getDimSize(1), result.slBlock.getDimSize(1));
auto snBlock = m.read("snBlock");
for(int i=0; i<result.snBlock.getDataSize(); ++i)
{
EXPECT_DOUBLE_AE(snBlock[i], result.snBlock[i]);
EXPECT_float_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));
EXPECT_FLOAT_EQ(snBlock.getDimSize(0), result.snBlock.getDimSize(0));
EXPECT_FLOAT_EQ(snBlock.getDimSize(1), result.snBlock.getDimSize(1));
}
TEST_F(Common_Test, blockingGeometryInfos) {
@@ -312,34 +312,34 @@ TEST_F(Common_Test, blockingGeometryInfos) {
auto receiverNormalBlock = m.read("receiverNormalBlock");
for(int i=0; i<result.receiverNormalBlock.getDataSize(); ++i)
{
EXPECT_DOUBLE_AE(receiverNormalBlock[i], result.receiverNormalBlock[i]);
EXPECT_float_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]);
EXPECT_float_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]);
EXPECT_float_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]);
EXPECT_float_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);
Aurora::Matrix a = Aurora::Matrix::fromRawData(new float[8]{1,2,3,4,5,6,7,8}, 1,8);
Aurora::Matrix b = Aurora::Matrix::fromRawData(new float[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);
EXPECT_FLOAT_EQ(result.getDataSize(), 4);
EXPECT_FLOAT_EQ(result[0], 3);
EXPECT_FLOAT_EQ(result[1], 4);
EXPECT_FLOAT_EQ(result[2], 5);
EXPECT_FLOAT_EQ(result[3], 6);
}
TEST_F(Common_Test, meshgrid) {
@@ -352,21 +352,21 @@ TEST_F(Common_Test, meshgrid) {
auto yy = m.read("yy");
auto zz = m.read("zz");
EXPECT_DOUBLE_AE(xx.getDataSize(), result.xx.getDataSize());
EXPECT_float_AE(xx.getDataSize(), result.xx.getDataSize());
for(int i=0; i<xx.getDataSize(); ++i)
{
EXPECT_DOUBLE_AE(xx[i], result.xx[i]);
EXPECT_float_AE(xx[i], result.xx[i]);
}
EXPECT_DOUBLE_AE(yy.getDataSize(), result.yy.getDataSize());
EXPECT_float_AE(yy.getDataSize(), result.yy.getDataSize());
for(int i=0; i<yy.getDataSize(); ++i)
{
EXPECT_DOUBLE_AE(yy[i], result.yy[i]);
EXPECT_float_AE(yy[i], result.yy[i]);
}
EXPECT_DOUBLE_AE(zz.getDataSize(), result.zz.getDataSize());
EXPECT_float_AE(zz.getDataSize(), result.zz.getDataSize());
for(int i=0; i<zz.getDataSize(); ++i)
{
EXPECT_DOUBLE_AE(zz[i], result.zz[i]);
EXPECT_float_AE(zz[i], result.zz[i]);
}
}

39
test/DICOM_Test.cpp Normal file
View File

@@ -0,0 +1,39 @@
#include <cstdio>
#include <gtest/gtest.h>
#include "Matrix.h"
#include "Function3D.h"
#include "Parser.h"
#include "common/DICOMExporter.h"
#include "config/config.h"
class DICOM_Test : public ::testing::Test {
protected:
static void SetUpCommonTester() {
}
static void TearDownTestCase() {
}
void SetUp() {
}
void TearDown() {
}
};
TEST_F(DICOM_Test, export) {
Recon::reflectParams::imageStartpoint = Aurora::Matrix::fromRawData(new float[3]{0, 0, 0}, 3, 1);
Recon::reflectParams::imageEndpoint = Aurora::Matrix::fromRawData(new float[3]{1, 1, 1}, 3, 1);
Parser dataParser("/home/krad/Storage/Raw/0020ceff713b_20240814T113556/");
GTEST_LOG_(INFO)<<"IS empty data:"<<(dataParser.getPatientData().getIsEmptyData()?"T":"F")<<", AccNo:"<<dataParser.getPatientData().getAccessionNumber()
<<", StudyUID:"<<dataParser.getPatientData().getStudyUID()<<", measurementID:"<<dataParser.getMetaData().getMeasurementID();
Recon::DICOMExporter exporter(dataParser.getPatientData(), dataParser.getMetaData());
exporter.setExportBasePath("/home/krad/workdir/UR/build/export/");
exporter.exportDICOM(Aurora::zeros(100,100,30), Recon::DICOMExporter::ImageType::ATT);
}

56
test/DataFilter_Test.cpp
View File

@@ -12,12 +12,12 @@
inline double fourDecimalRound(double src){
inline float fourDecimalRound(float src){
return round(src*10000.0)/10000.0;
}
#define EXPECT_DOUBLE_AE(valueA,valueB)\
EXPECT_DOUBLE_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
#define EXPECT_FLOAT_AE(valueA,valueB)\
EXPECT_FLOAT_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
class DataFilter_Test : public ::testing::Test {
protected:
@@ -36,41 +36,41 @@ protected:
};
TEST_F(DataFilter_Test, filterTransmissionSensitivityMap) {
double *dataA = new double[4]{1, 1, 1, 1};
float *dataA = new float[4]{1, 1, 1, 1};
auto slBlock = Aurora::Matrix::fromRawData(dataA, 4, 1);
double *dataB = new double[4]{1, 1, 1, 1};
float *dataB = new float[4]{1, 1, 1, 1};
auto snBlock = Aurora::Matrix::fromRawData(dataB, 4, 1);
double *data3 = new double[4]{1, 1, 1, 2};
float *data3 = new float[4]{1, 1, 1, 2};
auto rlBlock = Aurora::Matrix::fromRawData(data3, 4, 1);
double *data4 = new double[4]{1, 2, 3, 1};
float *data4 = new float[4]{1, 2, 3, 1};
auto rnBlock = Aurora::Matrix::fromRawData(data4, 4, 1);
std::vector<Aurora::Matrix> a66;
double *data6 = new double[6]{3, 2, 1, 9, 8, 6};
float *data6 = new float[6]{3, 2, 1, 9, 8, 6};
auto sensData0 = Aurora::Matrix::fromRawData(data6, 3, 2, 1);
a66.push_back(sensData0);
auto result = Recon::filterTransmissionSensitivityMap(0.3, slBlock, snBlock, rlBlock, rnBlock, a66);
EXPECT_EQ(4,result.getDataSize());
for (size_t i = 0; i < 4; i++)
{
EXPECT_DOUBLE_EQ(1.0,result.getData()[i]);
EXPECT_FLOAT_EQ(1.0,result.getData()[i]);
}
}
TEST_F(DataFilter_Test, filterTransmissionAngle) {
double *dataA = new double[12]{0.99,0.99,0.99,0.99,0.10,0.10,0.10,0.10,0,0,0,0};
float *dataA = new float[12]{0.99,0.99,0.99,0.99,0.10,0.10,0.10,0.10,0,0,0,0};
auto senderNormalBlock = Aurora::transpose(Aurora::Matrix::fromRawData(dataA, 4, 3));
double *dataB = new double[12]{0.99,0.99,0.99,0.98,0.10,0.10,0.10,-0.15,0,0,0,0};
float *dataB = new float[12]{0.99,0.99,0.99,0.98,0.10,0.10,0.10,-0.15,0,0,0,0};
auto receiverNormalBlock = Aurora::transpose(Aurora::Matrix::fromRawData(dataB, 4, 3));
double angleLowerLimit = 10;
double angleUpperLimit = 180;
float angleLowerLimit = 10;
float angleUpperLimit = 180;
auto result = Recon::filterTransmissionAngle(angleLowerLimit, angleUpperLimit, senderNormalBlock, receiverNormalBlock);
EXPECT_EQ(4,result.getDataSize());
EXPECT_DOUBLE_EQ(0.0,result.getData()[0]);
EXPECT_DOUBLE_EQ(0.0,result.getData()[1]);
EXPECT_DOUBLE_EQ(0.0,result.getData()[2]);
EXPECT_DOUBLE_EQ(1.0,result.getData()[3]);
EXPECT_FLOAT_EQ(0.0,result.getData()[0]);
EXPECT_FLOAT_EQ(0.0,result.getData()[1]);
EXPECT_FLOAT_EQ(0.0,result.getData()[2]);
EXPECT_FLOAT_EQ(1.0,result.getData()[3]);
}
@@ -88,12 +88,12 @@ TEST_F(DataFilter_Test, checkTofDetections) {
for (size_t i = 0; i < result.valid.getDataSize(); i++)
{
EXPECT_DOUBLE_AE(valid.getData()[i],result.valid.getData()[i]) << " :"<<i;
EXPECT_FLOAT_AE(valid.getData()[i],result.valid.getData()[i]) << " :"<<i;
}
for (size_t i = 0; i < result.tofValues.getDataSize(); i++)
{
EXPECT_DOUBLE_AE(tofValues.getData()[i],result.tofValues.getData()[i])<< " :"<<i;
EXPECT_FLOAT_AE(tofValues.getData()[i],result.tofValues.getData()[i])<< " :"<<i;
}
}
@@ -106,13 +106,13 @@ TEST_F(DataFilter_Test, calculateSnr) {
for (size_t i = 0; i < snrBlock.getDataSize(); i++)
{
EXPECT_DOUBLE_AE(snrBlock.getData()[i],result.getData()[i]);
EXPECT_FLOAT_AE(snrBlock.getData()[i],result.getData()[i]);
}
}
TEST_F(DataFilter_Test, findDefectTransmissionData) {
MatlabReader m("/home/sun/testData/findDefectTransmissionData.mat");
double *dataA = new double[3]{1, std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity()};
float *dataA = new float[3]{1, std::numeric_limits<float>::infinity(), -std::numeric_limits<float>::infinity()};
auto SNRList = m.read("vsnrlist");
auto SNRList2 = m.read("snrdifference");
auto validOut = m.read("validOut");
@@ -122,19 +122,19 @@ TEST_F(DataFilter_Test, findDefectTransmissionData) {
auto valid = valid1*valid2;
for (size_t i = 0; i < valid.getDataSize(); i++)
{
EXPECT_DOUBLE_AE(validOut[i],valid[i]);
EXPECT_FLOAT_AE(validOut[i],valid[i]);
}
}
TEST_F(DataFilter_Test, filterReflectionData) {
auto receiverPositionBlock = 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.04}, 3, 3));
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));
auto receiverPositionBlock = Aurora::transpose(Aurora::Matrix::fromRawData(new float[9]{-0.12,-0.12,-0.12,-0.01,-0.01,-0.01,0.03,0.03,0.04}, 3, 3));
auto senderPositionBlock = Aurora::transpose(Aurora::Matrix::fromRawData(new float[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 float[9]{0.99,0.99,0.99,0.10,0.10,0.10,0,0,0}, 3, 3));
int constrictReflectionAngles = 1;
auto result = Recon::filterReflectionData(receiverPositionBlock, senderPositionBlock, senderNormalBlock, constrictReflectionAngles);
EXPECT_EQ(3, result.getDataSize());
EXPECT_DOUBLE_AE(result[0],1);
EXPECT_DOUBLE_AE(result[1],1);
EXPECT_DOUBLE_AE(result[2],0);
EXPECT_FLOAT_AE(result[0],1);
EXPECT_FLOAT_AE(result[1],1);
EXPECT_FLOAT_AE(result[2],0);
}

14
test/Detection_Test.cpp
View File

@@ -12,7 +12,7 @@
inline double fourDecimalRound(double src){
inline float fourDecimalRound(float src){
return round(src*10000.0)/10000.0;
}
@@ -48,7 +48,7 @@ TEST_F(Detection_Test, detectTofAndAttMex) {
auto distBlockRef = m.read("distRefBlock");
auto sosWaterBlock = Recon::temperatureToSoundSpeed(m.read("waterTempBlock"),"marczak");
auto sosWaterRefBlock = Recon::temperatureToSoundSpeed(m.read("waterTempRefBlock"),"marczak");
double expectedSOSWater = 1.512677498767504e+03;
float expectedSOSWater = 1.512677498767504e+03;
auto result = Recon::detectTofAndAttMex(
AscanBlock, AscanRefBlock, distBlock, distBlockRef, sosWaterBlock,
@@ -87,7 +87,7 @@ TEST_F(Detection_Test, detectTofAndAtt) {
auto distBlockRef = m.read("distRefBlock");
auto sosWaterBlock = Recon::temperatureToSoundSpeed(m.read("waterTempBlock"), "marczak");
auto sosWaterRefBlock = Recon::temperatureToSoundSpeed(m.read("waterTempRefBlock"), "marczak");
double expectedSOSWater = 1.512677498767504e+03;
float expectedSOSWater = 1.512677498767504e+03;
auto result = Recon::detectTofAndAtt(
@@ -141,7 +141,7 @@ TEST_F(Detection_Test, detectAttVectorized) {
MatlabReader m2("/home/krad/TestData/tofResult.mat");
auto tof = m2.read("tof");
double expectedSOSWater = 1.511948131508464e+03;
float expectedSOSWater = 1.511948131508464e+03;
auto result = Recon::detectAttVectorized(
AscanBlock, AscanRefBlock, distBlockRef,sosWaterRefBlock,
@@ -157,8 +157,8 @@ TEST_F(Detection_Test, detectAttVectorized) {
TEST_F(Detection_Test, calculateStarEndSearchPosition) {
auto distBlock = Aurora::Matrix::fromRawData(new double[3]{0.22, 0.21, 0.11}, 3, 1);
auto sosOffsetBlock = Aurora::Matrix::fromRawData(new double[3]{-0.8, 0, 0.9}, 3, 1);
auto distBlock = Aurora::Matrix::fromRawData(new float[3]{0.22, 0.21, 0.11}, 3, 1);
auto sosOffsetBlock = Aurora::Matrix::fromRawData(new float[3]{-0.8, 0, 0.9}, 3, 1);
auto result = Recon::calculateStarEndSearchPosition(distBlock, 1400.0, 1650.0, 10000000, 9999, sosOffsetBlock,97.3,250);
EXPECT_EQ(3,result.endSearch.getDataSize());
@@ -218,7 +218,7 @@ TEST_F(Detection_Test, detectTofVectorized) {
auto distBlockRef = m.read("distRefBlock");
auto sosWaterBlock = m.read("waterTempBlock");
auto sosWaterRefBlock = m.read("waterTempRefBlock");
double expectedSOSWater = 1.511948131508464e+03;
float expectedSOSWater = 1.511948131508464e+03;
auto result = Recon::detectTofVectorized(
AscanBlock, AscanRefBlock, distBlock, distBlockRef, sosWaterBlock,

12
test/GetTransmissionData_Test.cpp
View File

@@ -21,7 +21,7 @@ using namespace Aurora;
using namespace Recon;
inline double fourDecimalRound(double src) {
inline float fourDecimalRound(float src) {
return round(src*10000.0)/10000.0;
}
@@ -63,7 +63,7 @@ TEST_F(GetTransmissionData_Test, getTransmissionData) {
// //getMeasurementMetaData
// double maxNumTAS = Aurora::max(auroraUnion(slList, rlList)).getData()[0];
// float maxNumTAS = Aurora::max(auroraUnion(slList, rlList)).getData()[0];
// MeasurementInfo expInfo = loadMeasurementInfos(&dataParser);
// TempInfo temp = getTemperatureInfo(&dataParser, maxNumTAS);
// CEInfo ce = getCEInfo(&dataParser, expInfo);
@@ -84,7 +84,7 @@ TEST_F(GetTransmissionData_Test, getTransmissionData) {
// motorPosAvailableRef = transformationInfo.motorPos;
// if(transformationMatricesRef.isNull())
// {
// Matrix motorPos1 = Matrix::fromRawData(new double[1] {1}, 1);
// Matrix motorPos1 = Matrix::fromRawData(new float[1] {1}, 1);
// transformationMatricesRef = getTransformationMatrix(&refParser, motorPos1).rotationMatrix;
// }
// else
@@ -112,12 +112,12 @@ TEST_F(GetTransmissionData_Test, getTransmissionData) {
// if(expInfo.sampleRate != reflectParams::aScanReconstructionFrequency)
// {
// reflectParams::expectedAScanDataLength = ceil(expInfo.numberSamples * ((double)reflectParams::aScanReconstructionFrequency / expInfo.sampleRate));
// reflectParams::expectedAScanDataLength = ceil(expInfo.numberSamples * ((float)reflectParams::aScanReconstructionFrequency / expInfo.sampleRate));
// }
// preComputes.matchedFilterRef = createMatchedFilter(ceRef.ce, ceRef.measuredCEUsed, reflectParams::findDefects, reconParams::removeOutliersFromCEMeasured, expInfo.Hardware);
// preComputes.timeInterval = (double)1 / reflectParams::aScanReconstructionFrequency;
// preComputes.timeInterval = (float)1 / reflectParams::aScanReconstructionFrequency;
// preComputes.measuredCEUsed = ce.measuredCEUsed;
// preComputes.measuredCE_TASIndices = ce.tasIndices;
// preComputes.measuredCE_receiverIndices = ce.receiverIndices;
@@ -141,7 +141,7 @@ TEST_F(GetTransmissionData_Test, getTransmissionData) {
// Matrix iMp;
// Matrix mp_inter = intersect(motorPosAvailable, transParams::motorPos, iMp);
// double* mpRef_interData = Aurora::malloc(iMp.getDataSize());
// float* mpRef_interData = Aurora::malloc(iMp.getDataSize());
// for(int i=0; i<iMp.getDataSize(); ++i)
// {
// mpRef_interData[i] = motorPosAvailableRef[iMp[i] - 1];

150
test/Reconstruction_Test.cpp
View File

@@ -26,15 +26,15 @@
inline double fourDecimalRound(double src){
inline float fourDecimalRound(float src){
return round(src*10000.0)/10000.0;
}
#define EXPECT_DOUBLE_AE(valueA,valueB)\
EXPECT_DOUBLE_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
#define EXPECT_FLOAT_AE(valueA,valueB)\
EXPECT_FLOAT_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
#define ASSERT_DOUBLE_AE(valueA,valueB)\
ASSERT_DOUBLE_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
#define ASSERT_FLOAT_AE(valueA,valueB)\
ASSERT_FLOAT_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
class Reconstruction_Test : public ::testing::Test {
protected:
@@ -61,7 +61,7 @@ TEST_F(Reconstruction_Test, determineOptimalPulse) {
auto f1 = m2.read("sincPeak_ft");
for(size_t i=0; i<f1.getDataSize(); ++i)
{
EXPECT_DOUBLE_AE(f1[i], 0)<<"index:"<<i;
EXPECT_FLOAT_AE(f1[i], 0)<<"index:"<<i;
}
}
@@ -101,7 +101,7 @@ TEST_F(Reconstruction_Test, reconstructionSAFT) {
auto result = Recon::recontructSAFT(Ascans, senderPos, receiverPos, mpIndex, 2, transRecos, Env);
for(size_t i=0; i<result.getDataSize(); ++i)
{
EXPECT_DOUBLE_AE(result[i], EnvOut[i])<<"index:"<<i;
EXPECT_FLOAT_AE(result[i], EnvOut[i])<<"index:"<<i;
}
}
@@ -135,7 +135,7 @@ TEST_F(Reconstruction_Test, preprocessAScanBlockForReflection) {
size_t size = result.AscanBlock.getDataSize();
// for(size_t i=0; i<result.AscanBlock.getDataSize(); ++i)
// {
// ASSERT_DOUBLE_AE(f1[i], result[i])<<"index:"<<i;
// ASSERT_FLOAT_AE(f1[i], result[i])<<"index:"<<i;
// }
}
@@ -154,7 +154,7 @@ TEST_F(Reconstruction_Test, reconstructArt) {
auto result = Recon::reconstructArt(data, dataAtt, dims, senderList, receiverList, res, SOS_IN_WATER[0]);
for(size_t i=0; i<f1.getDataSize(); ++i)
{
ASSERT_DOUBLE_AE(f1[i], result.outSOS[i])<<"index:"<<i;
ASSERT_FLOAT_AE(f1[i], result.outSOS[i])<<"index:"<<i;
}
}
@@ -183,49 +183,49 @@ TEST_F(Reconstruction_Test, buildMatrix) {
auto result = Recon::buildMatrix(senderList, receiverList, res, dims, false, potentialMap);
for(size_t i=0; i<i1.getDataSize(); ++i)
{
EXPECT_DOUBLE_AE(i1[i] - 1, result.M.getColVector()[i]);
EXPECT_FLOAT_AE(i1[i] - 1, result.M.getColVector()[i]);
}
for(size_t i=0; i<j1.getDataSize(); ++i)
{
EXPECT_DOUBLE_AE(j1[i]- 1, result.M.getRowVector()[i]);
EXPECT_FLOAT_AE(j1[i]- 1, result.M.getRowVector()[i]);
}
for(size_t i=0; i<s1.getDataSize(); ++i)
{
EXPECT_DOUBLE_AE(s1[i], result.M.getValVector()[i]);
EXPECT_FLOAT_AE(s1[i], result.M.getValVector()[i]);
}
}
TEST_F(Reconstruction_Test, calculateMinimalMaximalTransducerPositions) {
auto senderList = Aurora::Matrix::fromRawData(new double[6]{1, 2, 3, 1, 2, 4}, 3, 2);
auto receiverList = Aurora::Matrix::fromRawData(new double[6]{1, 8, 3, 1, 2, 1}, 3, 2);
auto senderList = Aurora::Matrix::fromRawData(new float[6]{1, 2, 3, 1, 2, 4}, 3, 2);
auto receiverList = Aurora::Matrix::fromRawData(new float[6]{1, 8, 3, 1, 2, 1}, 3, 2);
auto result = Recon::calculateMinimalMaximalTransducerPositions(senderList,receiverList);
EXPECT_DOUBLE_EQ(1.0,result.getData()[0]);
EXPECT_DOUBLE_EQ(2,result.getData()[1]);
EXPECT_DOUBLE_EQ(1.0,result.getData()[2]);
EXPECT_DOUBLE_EQ(1.0,result.getData()[3]);
EXPECT_DOUBLE_EQ(8,result.getData()[4]);
EXPECT_DOUBLE_EQ(4,result.getData()[5]);
EXPECT_FLOAT_EQ(1.0,result.getData()[0]);
EXPECT_FLOAT_EQ(2,result.getData()[1]);
EXPECT_FLOAT_EQ(1.0,result.getData()[2]);
EXPECT_FLOAT_EQ(1.0,result.getData()[3]);
EXPECT_FLOAT_EQ(8,result.getData()[4]);
EXPECT_FLOAT_EQ(4,result.getData()[5]);
}
TEST_F(Reconstruction_Test, calculateResolution) {
auto ddims = Aurora::Matrix::fromRawData(new double[6]{-0.1296,-0.1296,0.0185,0.1296,0.1295,0.1682}, 1, 6);
auto dims = Aurora::Matrix::fromRawData(new double[3]{128,128,74}, 1, 3);
auto ddims = Aurora::Matrix::fromRawData(new float[6]{-0.1296,-0.1296,0.0185,0.1296,0.1295,0.1682}, 1, 6);
auto dims = Aurora::Matrix::fromRawData(new float[3]{128,128,74}, 1, 3);
auto result = Recon::calculateResolution(ddims, dims);
EXPECT_DOUBLE_AE(0.0020,result[0]);
EXPECT_DOUBLE_AE(0.0020,result[1]);
EXPECT_DOUBLE_AE(0.0021,result[2]);
EXPECT_FLOAT_AE(0.0020,result[0]);
EXPECT_FLOAT_AE(0.0020,result[1]);
EXPECT_FLOAT_AE(0.0021,result[2]);
}
TEST_F(Reconstruction_Test, getDimensions) {
auto ddims = Aurora::Matrix::fromRawData(new double[6]{-0.1296,-0.1296,0.0185,0.1296,0.1295,0.1682}, 1, 6);
double numPixelXY = 128;
auto ddims = Aurora::Matrix::fromRawData(new float[6]{-0.1296,-0.1296,0.0185,0.1296,0.1295,0.1682}, 1, 6);
float numPixelXY = 128;
auto result = Recon::getDimensions(numPixelXY,ddims);
EXPECT_DOUBLE_AE(128,result[0]);
EXPECT_DOUBLE_AE(128,result[1]);
EXPECT_DOUBLE_AE(74,result[2]);
EXPECT_FLOAT_AE(128,result[0]);
EXPECT_FLOAT_AE(128,result[1]);
EXPECT_FLOAT_AE(74,result[2]);
}
TEST_F(Reconstruction_Test, discretizePositions) {
@@ -240,34 +240,34 @@ TEST_F(Reconstruction_Test, discretizePositions) {
auto result = Recon::discretizePositions(senderList,receiverList,Recon::transParams::numPixelXY);
EXPECT_DOUBLE_AE(senderListResult.getDataSize(), result.senderCoordList.getDataSize());
EXPECT_FLOAT_AE(senderListResult.getDataSize(), result.senderCoordList.getDataSize());
for(size_t i=0; i<senderListResult.getDataSize(); ++i)
{
EXPECT_DOUBLE_AE(senderListResult[i], result.senderCoordList[i]);
EXPECT_FLOAT_AE(senderListResult[i], result.senderCoordList[i]);
}
EXPECT_DOUBLE_AE(receiverListResult.getDataSize(), result.receiverCoordList.getDataSize());
EXPECT_FLOAT_AE(receiverListResult.getDataSize(), result.receiverCoordList.getDataSize());
for(size_t i=0; i<receiverListResult.getDataSize(); ++i)
{
EXPECT_DOUBLE_AE(receiverListResult[i], result.receiverCoordList[i]);
EXPECT_FLOAT_AE(receiverListResult[i], result.receiverCoordList[i]);
}
EXPECT_DOUBLE_AE(dims.getDataSize(), result.dims.getDataSize());
EXPECT_FLOAT_AE(dims.getDataSize(), result.dims.getDataSize());
for(size_t i=0; i<dims.getDataSize(); ++i)
{
EXPECT_DOUBLE_AE(dims[i], result.dims[i]);
EXPECT_FLOAT_AE(dims[i], result.dims[i]);
}
EXPECT_DOUBLE_AE(ddims.getDataSize(), result.ddims.getDataSize());
EXPECT_FLOAT_AE(ddims.getDataSize(), result.ddims.getDataSize());
for(size_t i=0; i<ddims.getDataSize(); ++i)
{
EXPECT_DOUBLE_AE(ddims[i], result.ddims[i]);
EXPECT_FLOAT_AE(ddims[i], result.ddims[i]);
}
EXPECT_DOUBLE_AE(res.getDataSize(), result.res.getDataSize());
EXPECT_FLOAT_AE(res.getDataSize(), result.res.getDataSize());
for(size_t i=0; i<res.getDataSize(); ++i)
{
EXPECT_DOUBLE_AE(res[i], result.res[i]);
EXPECT_FLOAT_AE(res[i], result.res[i]);
}
}
@@ -280,36 +280,36 @@ TEST_F(Reconstruction_Test, DGradient) {
auto result = Recon::DGradient(x,1,2);
for (size_t i = 0; i < result.getDataSize(); i++)
{
EXPECT_DOUBLE_AE(result.getData()[i],y.getData()[i])<<"index:"<<i;
EXPECT_FLOAT_AE(result.getData()[i],y.getData()[i])<<"index:"<<i;
}
}
TEST_F(Reconstruction_Test, correctPath) {
auto path = Aurora::Matrix::fromRawData(new double[6]{1,1,10,9,1,1},2,3);
auto startPt = Aurora::Matrix::fromRawData(new double[3]{1, .5, 1}, 1, 3);
auto endPt = Aurora::Matrix::fromRawData(new double[3]{1, 10, 1}, 1, 3);
auto path = Aurora::Matrix::fromRawData(new float[6]{1,1,10,9,1,1},2,3);
auto startPt = Aurora::Matrix::fromRawData(new float[3]{1, .5, 1}, 1, 3);
auto endPt = Aurora::Matrix::fromRawData(new float[3]{1, 10, 1}, 1, 3);
Recon::correctPath(path,startPt,endPt);
for (size_t i = 0; i < 10; i++)
{
EXPECT_DOUBLE_EQ(path[i],1.0);
EXPECT_DOUBLE_EQ(path[i+10],1.0+i);
EXPECT_DOUBLE_EQ(path[i+20],1.0);
EXPECT_FLOAT_EQ(path[i],1.0);
EXPECT_FLOAT_EQ(path[i+10],1.0+i);
EXPECT_FLOAT_EQ(path[i+20],1.0);
}
}
TEST_F(Reconstruction_Test,getPixelLengthApproximation){
auto startPt = Aurora::Matrix::fromRawData(new double[3]{1, 1, 1}, 1, 3);
auto endPt = Aurora::Matrix::fromRawData(new double[3]{4, 5, 6}, 1, 3);
auto res = Aurora::Matrix::fromRawData(new double[3]{.1, .1, .1}, 1, 3);
auto startPt = Aurora::Matrix::fromRawData(new float[3]{1, 1, 1}, 1, 3);
auto endPt = Aurora::Matrix::fromRawData(new float[3]{4, 5, 6}, 1, 3);
auto res = Aurora::Matrix::fromRawData(new float[3]{.1, .1, .1}, 1, 3);
auto weight = Recon::getPixelLengthApproximation(startPt, endPt, res, 10);
EXPECT_DOUBLE_AE(weight[0],.0707);
EXPECT_FLOAT_AE(weight[0],.0707);
}
TEST_F(Reconstruction_Test,traceLine3D){
auto p1 = Aurora::Matrix::fromRawData(new double[3]{1, 10, 12}, 1, 3);
auto p2 = Aurora::Matrix::fromRawData(new double[3]{20, 2, 13}, 1, 3);
auto discretization = Aurora::Matrix::fromRawData(new double[3]{1, 1, 1}, 1, 3);
auto p1 = Aurora::Matrix::fromRawData(new float[3]{1, 10, 12}, 1, 3);
auto p2 = Aurora::Matrix::fromRawData(new float[3]{20, 2, 13}, 1, 3);
auto discretization = Aurora::Matrix::fromRawData(new float[3]{1, 1, 1}, 1, 3);
auto result = Recon::traceLine3D(p1, p2, discretization);
MatlabReader m("/home/krad/TestData/traceLine3D.mat");
@@ -317,45 +317,45 @@ TEST_F(Reconstruction_Test,traceLine3D){
auto ds = m.read("ds");
for (size_t i = 0; i < result.path.getDataSize(); i++)
{
EXPECT_DOUBLE_AE(result.path.getData()[i],path[i])<<"index:"<<i;
EXPECT_FLOAT_AE(result.path.getData()[i],path[i])<<"index:"<<i;
}
for (size_t i = 0; i < result.ds.getDataSize(); i++)
{
EXPECT_DOUBLE_AE(result.ds.getData()[i],ds[i])<<"index:"<<i;
EXPECT_FLOAT_AE(result.ds.getData()[i],ds[i])<<"index:"<<i;
}
}
TEST_F(Reconstruction_Test,traceStraightRay){
auto p1 = Aurora::Matrix::fromRawData(new double[3]{1, 1, 1}, 1, 3);
auto p2 = Aurora::Matrix::fromRawData(new double[3]{5, 6, 7}, 1, 3);
auto res = Aurora::Matrix::fromRawData(new double[3]{.1, .1, .1}, 1, 3);
auto dmis = Aurora::Matrix::fromRawData(new double[3]{5, 10, 20}, 1, 3);
auto p1 = Aurora::Matrix::fromRawData(new float[3]{1, 1, 1}, 1, 3);
auto p2 = Aurora::Matrix::fromRawData(new float[3]{5, 6, 7}, 1, 3);
auto res = Aurora::Matrix::fromRawData(new float[3]{.1, .1, .1}, 1, 3);
auto dmis = Aurora::Matrix::fromRawData(new float[3]{5, 10, 20}, 1, 3);
auto result = Recon::traceStraightRay(p1, p2, res, dmis);
EXPECT_EQ(13, result.weighting.getDataSize());
EXPECT_DOUBLE_AE(result.weighting[0],0);
EXPECT_DOUBLE_AE(result.weighting[1],0.1462);
EXPECT_DOUBLE_AE(result.weighting[11],0.0292);
EXPECT_DOUBLE_AE(result.weighting[3],0.0439);
EXPECT_FLOAT_AE(result.weighting[0],0);
EXPECT_FLOAT_AE(result.weighting[1],0.1462);
EXPECT_FLOAT_AE(result.weighting[11],0.0292);
EXPECT_FLOAT_AE(result.weighting[3],0.0439);
EXPECT_EQ(13, result.path.getDimSize(0));
EXPECT_EQ(3, result.path.getDimSize(1));
EXPECT_DOUBLE_AE(result.path[0],1);
EXPECT_DOUBLE_AE(result.path[15],2);
EXPECT_DOUBLE_AE(result.path[30],3);
EXPECT_FLOAT_AE(result.path[0],1);
EXPECT_FLOAT_AE(result.path[15],2);
EXPECT_FLOAT_AE(result.path[30],3);
EXPECT_EQ(13, result.pathLen);
}
TEST_F(Reconstruction_Test,traceStraightRayBresenham){
auto p1 = Aurora::Matrix::fromRawData(new double[3]{1, 1, 1}, 1, 3);
auto p2 = Aurora::Matrix::fromRawData(new double[3]{5, 6, 7}, 1, 3);
auto res = Aurora::Matrix::fromRawData(new double[3]{.1, .1, .1}, 1, 3);
auto p1 = Aurora::Matrix::fromRawData(new float[3]{1, 1, 1}, 1, 3);
auto p2 = Aurora::Matrix::fromRawData(new float[3]{5, 6, 7}, 1, 3);
auto res = Aurora::Matrix::fromRawData(new float[3]{.1, .1, .1}, 1, 3);
auto result = Recon::traceStraightRayBresenham(p1, p2, res);
EXPECT_EQ(1, result.weighting.getDataSize());
EXPECT_DOUBLE_AE(result.weighting[0],0.1462);
EXPECT_FLOAT_AE(result.weighting[0],0.1462);
EXPECT_EQ(6, result.path.getDimSize(0));
EXPECT_EQ(3, result.path.getDimSize(1));
EXPECT_DOUBLE_AE(result.path[0],1);
EXPECT_DOUBLE_AE(result.path[15],4);
EXPECT_DOUBLE_AE(result.path[7],2);
EXPECT_FLOAT_AE(result.path[0],1);
EXPECT_FLOAT_AE(result.path[15],4);
EXPECT_FLOAT_AE(result.path[7],2);
EXPECT_EQ(6, result.pathLen);
}
@@ -378,7 +378,7 @@ TEST_F(Reconstruction_Test,callTval3){
Aurora::Sparse M(i1-1,j1-1,s1,734989,1196032);
MatlabReader m2("/home/sun/testData/tval3gpu3d.mat");
auto b = m2.read("b");
auto dims = Aurora::Matrix::fromRawData(new double[3]{128,128,73}, 1, 3);
auto dims = Aurora::Matrix::fromRawData(new float[3]{128,128,73}, 1, 3);
auto result = Recon::callTval3(M, b, dims, 0,opt);
auto outSOS = Recon::slownessToSOS(result, 1.498206569328594e+03) ;
MatlabWriter w2("/home/krad/transmissionSOS111.mat");

20
test/Sensitivity_Test.cpp
View File

@@ -5,15 +5,15 @@
#include "transmissionReconstruction/dataFilter/sensitivityCalculations.h"
#include "MatlabReader.h"
inline double fourDecimalRound(double src){
inline float fourDecimalRound(float src){
return round(src*10000.0)/10000.0;
}
#define EXPECT_DOUBLE_AE(valueA,valueB)\
EXPECT_DOUBLE_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
#define EXPECT_FLOAT_AE(valueA,valueB)\
EXPECT_FLOAT_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
#define ASSERT_DOUBLE_AE(valueA,valueB)\
ASSERT_DOUBLE_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
#define ASSERT_FLOAT_AE(valueA,valueB)\
ASSERT_FLOAT_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
class Sensitivity_Test : public ::testing::Test {
protected:
@@ -50,7 +50,7 @@ TEST_F(Sensitivity_Test, getSensitivity) {
EXPECT_EQ(output.getDataSize(), sens.getDataSize());
for (size_t i = 0; i < output.getDataSize(); i++)
{
EXPECT_DOUBLE_AE(output.getData()[i],sens.getData()[i])<<", index:"<<i;
EXPECT_FLOAT_AE(output.getData()[i],sens.getData()[i])<<", index:"<<i;
}
}
@@ -70,7 +70,7 @@ TEST_F(Sensitivity_Test, precalcSensitivityForTAS){
EXPECT_EQ(output.getDataSize(), sens.getDataSize());
for (size_t i = 0; i < output.getDataSize(); i++)
{
EXPECT_DOUBLE_AE(output.getData()[i],sens.getData()[i])<<", index:"<<i;
EXPECT_FLOAT_AE(output.getData()[i],sens.getData()[i])<<", index:"<<i;
}
}
@@ -96,7 +96,7 @@ TEST_F(Sensitivity_Test, combineSensitivity){
{
for (size_t j = 0; j < output[i].getDataSize(); j++)
{
EXPECT_DOUBLE_AE(output[i].getData()[j],sens[i].getData()[j])<<"Matrix index:"<<i<<", value index:"<<j;
EXPECT_FLOAT_AE(output[i].getData()[j],sens[i].getData()[j])<<"Matrix index:"<<i<<", value index:"<<j;
}
}
@@ -116,7 +116,7 @@ TEST_F(Sensitivity_Test,precalcSensitivity){
TASElements.receiverPositions = m3.read4d("receiverPositions");
TASElements.receiverNormals = m3.read4d("receiverNormals");
TASElements.sensChar = m.read("sensChar");
auto motorPos = Aurora::Matrix::fromRawData(new double[2]{1,2}, 2);
auto motorPos = Aurora::Matrix::fromRawData(new float[2]{1,2}, 2);
auto output = precalcSensitivity(senderTASRange, senderElementRange, receiverTASRange, receiverElementRange, motorPos, TASElements);
MatlabReader m2("/home/krad/TestData/precalcResult.mat");
auto sens = m2.read4d("result");
@@ -127,7 +127,7 @@ TEST_F(Sensitivity_Test,precalcSensitivity){
{
for (size_t j = 0; j < output[i].getDataSize(); j++)
{
EXPECT_DOUBLE_AE(output[i].getData()[j],sens[i].getData()[j])<<"Matrix index:"<<i<<", value index:"<<j;
EXPECT_FLOAT_AE(output[i].getData()[j],sens[i].getData()[j])<<"Matrix index:"<<i<<", value index:"<<j;
}
}

34
test/TransRecon_DataPreperation_Test.cpp
View File

@@ -3,12 +3,12 @@
#include "Function3D.h"
#include "transmissionReconstruction/dataPreperation.h"
inline double fourDecimalRound(double src){
inline float fourDecimalRound(float src){
return round(src*10000.0)/10000.0;
}
#define EXPECT_DOUBLE_AE(valueA,valueB)\
EXPECT_DOUBLE_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
#define EXPECT_FLOAT_AE(valueA,valueB)\
EXPECT_FLOAT_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
class TransRecon_DataPreperation_Test : public ::testing::Test {
protected:
@@ -27,39 +27,39 @@ protected:
};
TEST_F(TransRecon_DataPreperation_Test, distanceBetweenTwoPoints) {
double *dataA = new double[9]{1, 9, 4, 0, .01, 1.9, 300,22, -93};
float *dataA = new float[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};
float *dataB = new float[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]);
EXPECT_FLOAT_AE(6.1644,output.getData()[0]);
EXPECT_FLOAT_AE(2.9614,output.getData()[1]);
EXPECT_FLOAT_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};
float *xD = new float[6]{1, 2, 3, 1, 2, 3};
Aurora::Matrix sl(
std::shared_ptr<double>(xD, std::default_delete<double[]>()),
std::shared_ptr<float>(xD, std::default_delete<float[]>()),
std::vector<int>{6});
xD = new double[6]{1, 1, 1, 1, 1, 1};
xD = new float[6]{1, 1, 1, 1, 1, 1};
Aurora::Matrix rl(
std::shared_ptr<double>(xD, std::default_delete<double[]>()),
std::shared_ptr<float>(xD, std::default_delete<float[]>()),
std::vector<int>{6});
xD = new double[6]{1, 1, 1, 2, 2, 2};
xD = new float[6]{1, 1, 1, 2, 2, 2};
Aurora::Matrix mp(
std::shared_ptr<double>(xD, std::default_delete<double[]>()),
std::shared_ptr<float>(xD, std::default_delete<float[]>()),
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]);
EXPECT_FLOAT_AE(23.5, output.getData()[0]);
EXPECT_FLOAT_AE(23.5, output.getData()[1]);
}
TEST_F(TransRecon_DataPreperation_Test, prepareAScansForTransmissionDetection){
@@ -68,6 +68,6 @@ TEST_F(TransRecon_DataPreperation_Test, prepareAScansForTransmissionDetection){
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]);
EXPECT_FLOAT_AE(0, result.getData()[0]);
}