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

Add getAscanBlock function and unit test.

Browse Source
This commit is contained in:
sunwen
2023-05-23 17:43:42 +08:00
parent 6b7b961dc6
commit db86d973a6
3 changed files with 195 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

102
src/common/daraBlockCreation/getAscanBlock.cpp Normal file
View File

@@ -0,0 +1,102 @@
#include "getAscanBlock.h"
#include "Function.h"
#include "Matrix.h"
#include "Parser.h"
#include "Data/OneTasAScanData.h"
#include "Data/AScanData.h"
#include "Data/TasElementIndex.h"
#include "Data/ElementIndex.h"
#include "Data/GeometryIndex.h"
#include "Data/ElectricIndex.h"
#include "Data/MetaData.h"
#include "ShotList/ShotList.h"
#include <vector>
using namespace Recon;
using namespace Aurora;
namespace
{
std::vector<int> findTasIndex(TasIndicesPointer aTasIndices, int aTasNum)
{
std::vector<int> result;
for(int i=0; i<aTasIndices.getLength(); ++i)
{
if (aTasIndices.get()[i] == aTasNum)
{
result.push_back(i);
}
}
return result;
}
}
AscanBlock Recon::getAscanBlock(Parser* aParser, const Aurora::Matrix& aMp, const Aurora::Matrix& aSl, const Aurora::Matrix& aSn,
const Aurora::Matrix& aRl, const Aurora::Matrix& aRn)
{
AscanBlock result;
int numScans = aMp.getDataSize() * aSl.getDataSize() * aSn.getDataSize() * aRl.getDataSize() * aRn.getDataSize();
int numScansIndex = 0;
int ascanBlockSize = numScans * aParser->getMetaData().getSampleNumber();
double* ascanBlockData = new double[ascanBlockSize];
double* mpBlockData = new double[numScans];
double* slBlockData = new double[numScans];
double* snBlockData = new double[numScans];
double* rlBlockData = new double[numScans];
double* rnBlockData = new double[numScans];
double* gainBlockData = new double[numScans];
result.ascanBlock = Matrix::fromRawData(ascanBlockData, aParser->getMetaData().getSampleNumber(), numScans);
result.mpBlock = Matrix::fromRawData(mpBlockData, 1, numScans);
result.slBlock = Matrix::fromRawData(slBlockData, 1, numScans);
result.snBlock = Matrix::fromRawData(snBlockData, 1, numScans);
result.rlBlock = Matrix::fromRawData(rlBlockData, 1, numScans);
result.rnBlock = Matrix::fromRawData(rnBlockData, 1, numScans);
result.gainBlock = Matrix::fromRawData(gainBlockData, 1, numScans);
OneTasAScanData oenTasData = aParser->getOneTasAscanDataOfMotorPosition(1);
auto tasIndices = aParser->getMetaData().getTasIndices();
auto receiverIndices = aParser->getMetaData().getReceiverIndices();
for(int mpIndex=0; mpIndex<aMp.getDataSize();++mpIndex)
{
for(int slIndex=0; slIndex<aSl.getDataSize();++slIndex)
{
OneTasAScanData oenTasData = aParser->getOneTasAscanDataOfMotorPosition(aSl[slIndex]);
for(int snIndex=0; snIndex<aSn.getDataSize();++snIndex)
{
for(int rlIndex=0; rlIndex<aRl.getDataSize();++rlIndex)
{
auto rElementIndex = findTasIndex(tasIndices, aRl[rlIndex]);
for(int rnIndex=0; rnIndex<rElementIndex.size(); ++rnIndex)
{
MotorPosition mp = aMp[mpIndex] == 1 ? MotorPosition::MotorPosition1 : MotorPosition::MotorPosition2;
AScanData ascan = aParser->searchAscanDataFromOneTasAscanDataOfMP(oenTasData, ElementIndex(GeometryIndex(aSn[snIndex])), TasElementIndex(aRl[rlIndex], ElementIndex(GeometryIndex(receiverIndices.get()[rElementIndex[rnIndex]]))), mp);
std::copy(ascan.get() ,ascan.get() + ascan.getAscanDataLength(), ascanBlockData);
ascanBlockData += ascan.getAscanDataLength();
mpBlockData[numScansIndex] = aMp[mpIndex];
slBlockData[numScansIndex] = aSl[slIndex];
snBlockData[numScansIndex] = aSn[snIndex];
rlBlockData[numScansIndex] = aRl[rlIndex];
rnBlockData[numScansIndex] = receiverIndices.get()[rElementIndex[rnIndex]];
gainBlockData[numScansIndex] = ascan.getAmplification()[0];
++numScansIndex;
}
}
}
}
}
// 改分支不会进，暂不实现 todo
// % initialized and calculated numbers agree?, otherwise reduce block sizes
// if num ~= numScans
// warning([mfilename, ':MissingSenderReceiverInfos'],'Not all defined data available.')
// writeReconstructionLog('Not all defined sender/receiver available', 3);
// usedDataIdxs = 1:num;
// [slBlock, snBlock, rlBlock, rnBlock, mpBlock, gainBlock] = removeDataFromArrays(usedDataIdxs, slBlock, snBlock, rlBlock, rnBlock, mpBlock, gainBlock);
// AscanBlock = AscanBlock(:,usedDataIdxs);
// end
return result;
}

25
src/common/daraBlockCreation/getAscanBlock.h Normal file
View File

@@ -0,0 +1,25 @@
#ifndef GET_ASCAN_BLOCK_H
#define GET_ASCAN_BLOCK_H
#include "Matrix.h"
#include "src/common/getMeasurementMetaData.h"
class Parser;
namespace Recon
{
struct AscanBlock
{
Aurora::Matrix ascanBlock;
Aurora::Matrix mpBlock;
Aurora::Matrix slBlock;
Aurora::Matrix snBlock;
Aurora::Matrix rlBlock;
Aurora::Matrix rnBlock;
Aurora::Matrix gainBlock;
};
AscanBlock getAscanBlock(Parser* aParser, const Aurora::Matrix& mp, const Aurora::Matrix& aSL, const Aurora::Matrix& aSn,
const Aurora::Matrix& aRl, const Aurora::Matrix& aRn);
}
#endif

68
test/Common_Test.cpp
View File

@@ -5,6 +5,9 @@
#include "common/common.h"
#include "common/convertfp16tofloat.h"
#include "common/getGeometryInfo.h"
#include "common/daraBlockCreation/getAscanBlock.h"
#include "Parser.h"
#include "MatlabReader.h"
inline double fourDecimalRound(double src){
@@ -219,3 +222,68 @@ TEST_F(Common_Test, getGeometryInfo) {
Aurora::Matrix maxRN = m.read("maxRN");
EXPECT_DOUBLE_EQ(geom.maxRN, maxRN[0]);
}
TEST_F(Common_Test, getAscanBlock) {
MatlabReader m("/home/sun/testData/getAscanBlock.mat");
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));
for(int i=0; i<ascanBlock.getDataSize(); ++i)
{
EXPECT_DOUBLE_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));
auto gainBlock = m.read("gainBlock");
for(int i=0; i<gainBlock.getDataSize(); ++i)
{
EXPECT_DOUBLE_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));
auto mpBlock = m.read("mpBlock");
for(int i=0; i<mpBlock.getDataSize(); ++i)
{
EXPECT_DOUBLE_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));
auto rlBlock = m.read("rlBlock");
for(int i=0; i<rlBlock.getDataSize(); ++i)
{
EXPECT_DOUBLE_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));
auto rnBlock = m.read("rnBlock");
for(int i=0; i<rnBlock.getDataSize(); ++i)
{
EXPECT_DOUBLE_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));
auto slBlock = m.read("slBlock");
for(int i=0; i<slBlock.getDataSize(); ++i)
{
EXPECT_DOUBLE_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));
auto snBlock = m.read("snBlock");
for(int i=0; i<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));
}