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

Add transmissionReconstruction.

Browse Source
This commit is contained in:
sunwen
2023-06-02 15:34:22 +08:00
parent e39a5ecb57
commit b1727b193b
21 changed files with 991 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
src/transmissionReconstruction/dataFilter/estimateNoiseValueFromAScans.cpp Normal file
View File

@@ -0,0 +1,18 @@
#include "estimateNoiseValueFromAScans.h"
#include "src/common/dataBlockCreation/getAScanBlockPreprocessed.h"
#include "src/config/config.h"
#include "Function2D.h"
using namespace Aurora;
using namespace Recon;
Matrix Recon::estimateNoiseValueFromAScans(Aurora::Matrix aSn, Aurora::Matrix aRn, GeometryInfo& aGeo, const MeasurementInfo& aMesInfo, Parser* aParser)
{
auto ascanBlockPreprocessed = getAscanBlockPreprocessed(aParser, transParams::calibReferenceMotorPosition, transParams::calibReferenceTas, aSn, transParams::calibReferenceTas, aRn, aGeo, aMesInfo, false, false);
Matrix referenceAScansForNoiseEstimation = ascanBlockPreprocessed.ascanBlockPreprocessed / repmat(ascanBlockPreprocessed.gainBlock, ascanBlockPreprocessed.ascanBlockPreprocessed.getDimSize(0), 1);
referenceAScansForNoiseEstimation = referenceAScansForNoiseEstimation - repmat(mean(referenceAScansForNoiseEstimation, FunctionDirection::Column),referenceAScansForNoiseEstimation.getDimSize(0),1);
referenceAScansForNoiseEstimation = mean(referenceAScansForNoiseEstimation, FunctionDirection::Row);
return max(abs(referenceAScansForNoiseEstimation));
}

15
src/transmissionReconstruction/dataFilter/estimateNoiseValueFromAScans.h Normal file
View File

@@ -0,0 +1,15 @@
#ifndef ESTIMATENOISEVALUE_FROM_ASCAN_H
#define ESTIMATENOISEVALUE_FROM_ASCAN_H
#include "Matrix.h"
#include "src/common/getGeometryInfo.h"
#include "src/common/getMeasurementMetaData.h"
class Parser;
namespace Recon
{
Aurora::Matrix estimateNoiseValueFromAScans(Aurora::Matrix aSn, Aurora::Matrix aRn, GeometryInfo& aGeo, const MeasurementInfo& aMesInfo, Parser* aParser);
}
#endif

376
src/transmissionReconstruction/detection/getTransmissionData.cpp
View File

@@ -1,21 +1,189 @@
#include "getTransmissionData.h"
#include "../../config/config.h"
#include "Function.h"
#include "Function1D.h"
#include "Function2D.h"
#include "common/dataBlockCreation/removeDataFromArrays.h"
#include "src//config/config.h"
#include "src/common/getGeometryInfo.h"
#include "src/common/temperatureCalculation/extractTasTemperature.h"
#include "src/common/dataBlockCreation/getAScanBlockPreprocessed.h"
#include "src/common/precalculateChannelList.h"
#include "src/transmissionReconstruction/dataFilter/sensitivityCalculations.h"
#include "src/transmissionReconstruction/dataFilter/estimateNoiseValueFromAScans.h"
#include "Matrix.h"
#include "Function3D.h"
#include "transmissionReconstruction/dataFilter/dataFilter.h"
#include "transmissionReconstruction/dataPreperation.h"
#include "transmissionReconstruction/detection/detection.h"
#include <cstddef>
#include <mkl_cblas.h>
#include "MatlabReader.h"
#include <iostream>
#include <mkl_vml_functions.h>
#include <vector>
using namespace Recon;
using namespace Aurora;
void Recon::getTransmissionData(const Aurora::Matrix& aMotorPos, const Aurora::Matrix& aMotoPosRef, const Aurora::Matrix& aSlList,
namespace
{
struct BlockOfTransmissionData
{
Matrix tofData;
Matrix attData;
Matrix senderBlock;
Matrix receiverBlock;
Matrix waterTempBlock;
MetaInfos metaInfos;
};
Matrix prepareAScansForTransmissionDetection(const Matrix& aAscanBlock, const Matrix& aGainBlock)
{
Matrix result = aAscanBlock / repmat(aGainBlock, aAscanBlock.getDimSize(0), 1);
result = result - repmat(mean(result,FunctionDirection::Column), result.getDimSize(0), 1);
return result;
}
BlockOfTransmissionData getBlockOfTransmissionData(const Matrix& aMp, const Matrix& aMpRef, const Matrix& aSl, const Matrix& aSn, const Matrix& aRlList, const Matrix& aRnList,
const TasTemps& aTasTemps, const Matrix& aExpectedSOSWater, GeometryInfo aGeom, GeometryInfo& aGeomRef,
const Matrix& aSnrRmsNoise, const Matrix& aSnrRmsNoiseRef, const MeasurementInfo& aExpInfo, const MeasurementInfo& aExpInfoRef,
const PreComputes& aPreComputes, Parser* aParser, Parser* aParserRef)
{
BlockOfTransmissionData result;
MetaInfos metaInfos;
auto blockData = getAscanBlockPreprocessed(aParser, aMp, aSl, aSn, aRlList, aRnList, aGeom, aExpInfo, true, true);
auto blockDataRef = getAscanBlockPreprocessed(aParserRef, aMpRef, aSl, aSn, aRlList, aRnList, aGeomRef, aExpInfoRef, true, true);
Matrix ascanBlock = prepareAScansForTransmissionDetection(blockData.ascanBlockPreprocessed, blockData.gainBlock);
Matrix ascanBlockRef = prepareAScansForTransmissionDetection(blockDataRef.ascanBlockPreprocessed, blockDataRef.gainBlock);
if(aExpInfo.Hardware == "USCT3dv3")
{
Matrix channelList = precalculateChannelList(aRlList, aRnList, aExpInfo, aPreComputes);
double* 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 channelListBlockSize = ind.getDataSize();
double* channelListBlockData = Aurora::malloc(channelListBlockSize);
for(size_t i=0; i<channelListBlockSize; ++i)
{
channelListBlockData[i] = channelList[ind[i] - 1];
}
Matrix channelListBlock = Matrix::New(channelListBlockData, 1, channelListBlockSize);
Matrix fx = fft(ascanBlock);
double* fhData = Aurora::malloc(aExpInfo.matchedFilter.getDimSize(0) * channelListBlockSize, true);
Matrix fh = Matrix::New(fhData, aExpInfo.matchedFilter.getDimSize(0), channelListBlockSize, 1, Aurora::Complex);
size_t matchedFilterRowDataSize = aExpInfo.matchedFilter.getDimSize(0)*2;
for(size_t i=0; i<channelListBlockSize; ++i)
{
cblas_dcopy(matchedFilterRowDataSize, aExpInfo.matchedFilter.getData() + (size_t)(channelListBlock[i] - 1) * matchedFilterRowDataSize, 1 , fhData ,1);
fhData += matchedFilterRowDataSize;
}
// Matrix fxReal = Aurora::real(fx);
// Matrix fhReal = Aurora::real(fh);
// Matrix fxImag = Aurora::imag(fx);
// Matrix fhImag = Aurora::imag(fh);
// Matrix real = fxReal * fhReal + fxImag * fhImag;
// Matrix image = fxImag * fhReal - fxReal * fhImag;
double* value1 = Aurora::malloc(fx.getDataSize());
vdMulI(fx.getDataSize(), fx.getData(), 2, fh.getData(), 2, value1, 1);
double* value2 = Aurora::malloc(fx.getDataSize());
vdMulI(fx.getDataSize(), fx.getData() + 1, 2, fh.getData() + 1, 2, value2, 1);
double* realData = Aurora::malloc(fx.getDataSize());
vdAdd(fx.getDataSize(), value1, value2, realData);
Matrix real = Matrix::New(realData, fx.getDimSize(0), fx.getDimSize(1));
vdMulI(fx.getDataSize(), fx.getData() + 1, 2, fh.getData(), 2, value1, 1);
vdMulI(fx.getDataSize(), fx.getData(), 2, fh.getData() + 1, 2, value2, 1);
double* imagData = Aurora::malloc(fx.getDataSize());
vdSub(fx.getDataSize(), value1, value2, imagData);
Matrix image = Matrix::New(imagData, fx.getDimSize(0), fx.getDimSize(1));
double* complexData = Aurora::malloc(real.getDataSize(), true);
cblas_dcopy(real.getDataSize(), real.getData(), 1 , complexData ,2);
cblas_dcopy(image.getDataSize(), image.getData(), 1 , complexData + 1 ,2);
Matrix complex = Matrix::New(complexData, real.getDimSize(0), real.getDimSize(1), 1, Aurora::Complex);
ascanBlock = Aurora::real(ifft(complex));
fx = fft(ascanBlockRef);
fhData = Aurora::malloc(aExpInfoRef.matchedFilter.getDimSize(0) * channelListBlockSize, true);
fh = Matrix::New(fhData, aExpInfoRef.matchedFilter.getDimSize(0), channelListBlockSize, 1, Aurora::Complex);
matchedFilterRowDataSize = aExpInfoRef.matchedFilter.getDimSize(0)*2;
for(size_t i=0; i<channelListBlockSize; ++i)
{
cblas_dcopy(matchedFilterRowDataSize, aExpInfoRef.matchedFilter.getData() + (size_t)(channelListBlock[i] - 1) * matchedFilterRowDataSize, 1 , fhData ,1);
fhData += matchedFilterRowDataSize;
}
// real = Aurora::real(fx) * Aurora::real(fh) + Aurora::imag(fx) * Aurora::imag(fh);
// image = Aurora::imag(fx) * Aurora::real(fh) - Aurora::real(fx) * Aurora::imag(fh);
vdMulI(fx.getDataSize(), fx.getData(), 2, fh.getData(), 2, value1, 1);
vdMulI(fx.getDataSize(), fx.getData() + 1, 2, fh.getData() + 1, 2, value2, 1);
realData = Aurora::malloc(fx.getDataSize());
vdAdd(fx.getDataSize(), value1, value2, realData);
real = Matrix::New(realData, fx.getDimSize(0), fx.getDimSize(1));
vdMulI(fx.getDataSize(), fx.getData() + 1, 2, fh.getData(), 2, value1, 1);
vdMulI(fx.getDataSize(), fx.getData(), 2, fh.getData() + 1, 2, value2, 1);
imagData = Aurora::malloc(fx.getDataSize());
vdSub(fx.getDataSize(), value1, value2, imagData);
image = Matrix::New(imagData, fx.getDimSize(0), fx.getDimSize(1));
Aurora::free(value1);
Aurora::free(value2);
complexData = Aurora::malloc(real.getDataSize(), true);
cblas_dcopy(real.getDataSize(), real.getData(), 1 , complexData ,2);
cblas_dcopy(image.getDataSize(), image.getData(), 1 , complexData + 1 ,2);
complex = Matrix::New(complexData, real.getDimSize(0), real.getDimSize(1), 1, Aurora::Complex);
ascanBlockRef = Aurora::real(ifft(complex));
}
else
{
transParams::detectionWindowSOS = transParams::pulseLengthSamples;
transParams::detectionWindowATT = transParams::pulseLengthSamples;
}
if(transParams::applyCalib)
{
metaInfos.snrValues = calculateSnr(ascanBlock, aSnrRmsNoise[0]);
metaInfos.snrValuesRef = calculateSnr(ascanBlockRef, aSnrRmsNoiseRef[0]);
}
Matrix dists = distanceBetweenTwoPoints(blockData.senderPositionBlock, blockData.receiverPositionBlock);
Matrix distRefBlock = distanceBetweenTwoPoints(blockDataRef.senderPositionBlock, blockDataRef.receiverPositionBlock);
Matrix waterTempBlock = calculateWaterTemperature(aTasTemps.waterTempPreCalc_sl, aTasTemps.waterTempPreCalc_rl, blockData.slBlock, blockData.rlBlock, blockData.mpBlock);
Matrix waterTempRefBlock = calculateWaterTemperature(aTasTemps.waterTempRefPreCalc_sl, aTasTemps.waterTempRefPreCalc_rl, blockData.slBlock, blockData.rlBlock, blockDataRef.mpBlock);
if(transParams::saveDetection || transParams::outlierOnTasDetection || transParams::saveDebugInfomation)
{
metaInfos.mpBlock = blockData.mpBlock;
metaInfos.slBlock = blockData.slBlock;
metaInfos.snBlock = blockData.snBlock;
metaInfos.rlBlock = blockData.rlBlock;
metaInfos.rnBlock = blockData.rnBlock;
}
result.metaInfos = metaInfos;
result.senderBlock = blockData.senderPositionBlock;
result.receiverBlock = blockData.receiverPositionBlock;
result.waterTempBlock = waterTempBlock;
DetectResult detect = transmissionDetection(ascanBlock, ascanBlockRef, dists, distRefBlock, waterTempBlock, waterTempRefBlock, aExpectedSOSWater[0]);
result.attData = detect.att;
result.tofData = detect.tof;
return result;
}
}
TransmissionData Recon::getTransmissionData(const Aurora::Matrix& aMotorPos, const Aurora::Matrix& aMotoPosRef, const Aurora::Matrix& aSlList,
const Aurora::Matrix& aSnList, const Aurora::Matrix& aRlList, const Aurora::Matrix& aRnList,
const TempInfo& aTemp, const TempInfo& aTempRef, GeometryInfo& aGeom,
GeometryInfo& aGeomRef, const MeasurementInfo& aExpInfo, const MeasurementInfo& aExpInfoRef,
const PreComputes& aPreComputes)
const PreComputes& aPreComputes, Parser* aParser, Parser* aParserRef)
{
//推测是已经完成过透射重建并从完成的透射重建读取数据，但下方读取后数据又被覆盖
//推测是已经完成过透射重建并从完成的透射重建读取数据
//暂不考虑此逻辑运行
// if transParams.detection.forceRedetect == 0 && exist(transParams.pathSaveDetection, 'dir') && size(dir(transParams.pathSaveDetection), 1) > 2 % i.e. detection folder exists and is not empty
// % Load transmission detection data
@@ -30,4 +198,204 @@ void Recon::getTransmissionData(const Aurora::Matrix& aMotorPos, const Aurora::M
aGeom.sensData = precalcSensitivity(aSlList, aSnList, aRlList, aRnList, aMotorPos, aGeom);
aGeomRef.sensData = aGeom.sensData;
Matrix rmsNoise, rmsNoiseRef;
if (transParams::applyCalib)
{
rmsNoise = estimateNoiseValueFromAScans(aSnList, aRnList, aGeom, aExpInfo, aParser);
rmsNoiseRef = estimateNoiseValueFromAScans(aSnList, aRnList, aGeom, aExpInfo, aParserRef);
}
size_t numScans = aMotorPos.getDataSize() * aSlList.getDataSize() * aSnList.getDataSize() * aRlList.getDataSize() * aRnList.getDataSize();
Matrix tofDataTotal = Matrix::fromRawData(new double[numScans], 1, numScans) + NAN;
Matrix attDataTotal = Matrix::fromRawData(new double[numScans], 1, numScans) + NAN;
Matrix waterTempList = zeros(1,numScans,1);
Matrix senderList = zeros(3,numScans,1);
Matrix receiverList = zeros(3,numScans,1);
Matrix snrValues = zeros(1,numScans,1);
Matrix snrValuesRef = zeros(1,numScans,1);
Matrix mpBlockTotal;
Matrix slBlockTotal;
Matrix snBlockTotal;
Matrix rlBlockTotal;
Matrix rnBlockTotal;
if(transParams::saveDetection || transParams::outlierOnTasDetection || transParams::saveDebugInfomation)
{
mpBlockTotal = zeros(1,numScans,1);
slBlockTotal = zeros(1,numScans,1);
snBlockTotal = zeros(1,numScans,1);
rlBlockTotal = zeros(1,numScans,1);
rnBlockTotal = zeros(1,numScans,1);
}
int numData = 0;
int numPossibleScans = 0;
for(int i=0; i<aMotorPos.getDataSize(); ++i)
{
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 mpRef = aMotoPosRef(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 transmissionBlock = getBlockOfTransmissionData(mp,mpRef,sl,sn,aRlList,aRnList,tasTemps,aTemp.expectedSOSWater,aGeom,aGeomRef,rmsNoise,rmsNoiseRef,aExpInfo,aExpInfoRef,aPreComputes,aParser, aParserRef);
size_t numUsedData = transmissionBlock.senderBlock.getDimSize(1);
if(transParams::applyCalib)
{
cblas_dcopy(numUsedData, transmissionBlock.metaInfos.snrValues.getData(), 1, snrValues.getData() + numData, 1);
cblas_dcopy(numUsedData, transmissionBlock.metaInfos.snrValuesRef.getData(), 1, snrValuesRef.getData() + numData, 1);
}
int rows = transmissionBlock.senderBlock.getDimSize(0);
cblas_dcopy(numUsedData * rows, transmissionBlock.senderBlock.getData(), 1, senderList.getData() + numData*rows, 1);
cblas_dcopy(numUsedData * rows, transmissionBlock.receiverBlock.getData(), 1, receiverList.getData() + numData*rows, 1);
cblas_dcopy(numUsedData, transmissionBlock.tofData.getData(), 1, tofDataTotal.getData() + numData, 1);
cblas_dcopy(numUsedData, transmissionBlock.attData.getData(), 1, attDataTotal.getData() + numData, 1);
cblas_dcopy(numUsedData, transmissionBlock.waterTempBlock.getData(), 1, waterTempList.getData() + numData, 1);
if(transParams::saveDetection || transParams::outlierOnTasDetection || transParams::saveDebugInfomation)
{
cblas_dcopy(numUsedData, transmissionBlock.metaInfos.mpBlock.getData(), 1, mpBlockTotal.getData() + numData, 1);
cblas_dcopy(numUsedData, transmissionBlock.metaInfos.slBlock.getData(), 1, slBlockTotal.getData() + numData, 1);
cblas_dcopy(numUsedData, transmissionBlock.metaInfos.snBlock.getData(), 1, snBlockTotal.getData() + numData, 1);
cblas_dcopy(numUsedData, transmissionBlock.metaInfos.rlBlock.getData(), 1, rlBlockTotal.getData() + numData, 1);
cblas_dcopy(numUsedData, transmissionBlock.metaInfos.rnBlock.getData(), 1, rnBlockTotal.getData() + numData, 1);
}
numData += numUsedData;
std::cout<<j<<std::endl;
}
}
}
double* filterData = Aurora::malloc(tofDataTotal.getDataSize());
for(int i=0;i<tofDataTotal.getDataSize();++i)
{
if(tofDataTotal[i] != tofDataTotal[i])
{
filterData[i] = 0;
}
else
{
filterData[i] = 1;
}
}
Matrix filter = Matrix::New(filterData, 1, tofDataTotal.getDataSize());
if(transParams::applyCalib)
{
snrValues = removeDataFromArrays(snrValues, filter);
snrValuesRef = removeDataFromArrays(snrValuesRef, filter);
}
senderList = removeDataFromArrays(senderList, filter);
receiverList = removeDataFromArrays(receiverList, filter);
tofDataTotal = removeDataFromArrays(tofDataTotal, filter);
attDataTotal = removeDataFromArrays(attDataTotal, filter);
waterTempList = removeDataFromArrays(waterTempList, filter);
if(transParams::saveDebugInfomation || transParams::outlierOnTasDetection || transParams::saveDetection)
{
mpBlockTotal = removeDataFromArrays(mpBlockTotal, filter);
slBlockTotal = removeDataFromArrays(slBlockTotal, filter);
snBlockTotal = removeDataFromArrays(snBlockTotal, filter);
rlBlockTotal = removeDataFromArrays(rlBlockTotal, filter);
rnBlockTotal = removeDataFromArrays(rnBlockTotal, filter);
}
Matrix valid;
if(transParams::applyCalib)
{
double* snr = Aurora::malloc(numData);
valid = findDefectTransmissionData(Matrix::copyFromRawData(snrValues.getData(), 1, numData), transParams::snrThreshold) *
findDefectTransmissionData(Matrix::copyFromRawData(snrValuesRef.getData(), 1, numData), transParams::snrThreshold);
}
else
{
valid = zeros(1,numData) + 1;
}
DataInfo dataInfno;
double* findDefectData = Aurora::malloc(valid.getDataSize());
int findDefectDataIndex = 0;
for(int i=0; i<valid.getDataSize(); ++i)
{
if(valid[i] == 0)
{
findDefectData[findDefectDataIndex] = i + 1;
++findDefectDataIndex;
}
}
dataInfno.findDefect = Matrix::New(findDefectData, 1, findDefectDataIndex);
if(transParams::saveDebugInfomation)
{
dataInfno.sn = snBlockTotal;
dataInfno.sl = slBlockTotal;
dataInfno.rn = rnBlockTotal;
dataInfno.rl = rlBlockTotal;
dataInfno.mp = mpBlockTotal;
}
tofDataTotal = removeDataFromArrays(tofDataTotal, valid);
attDataTotal = removeDataFromArrays(attDataTotal, valid);
senderList = removeDataFromArrays(senderList, valid);
receiverList = removeDataFromArrays(receiverList, valid);
waterTempList = removeDataFromArrays(waterTempList, valid);
dataInfno.numPossibleScans = numData;
dataInfno.numValidScans = sum(valid);
//以下逻辑config默认值不走。后续再实现
// if(transParams.detection.outlierOnTasDetection)
// snBlockTotal = snBlockTotal(valid);
// slBlockTotal = slBlockTotal(valid);
// rnBlockTotal = rnBlockTotal(valid);
// rlBlockTotal = rlBlockTotal(valid);
// outliers = analyzeDetections(slBlockTotal, snBlockTotal, rlBlockTotal, rnBlockTotal, tofDataTotal);
// tofDataTotal = tofDataTotal(~outliers);
// attDataTotal = attDataTotal(:,~outliers);
// senderList = senderList(:,~outliers);
// receiverList = receiverList(:,~outliers);
// waterTempList = waterTempList(~outliers);
// writeReconstructionLog(sprintf('Removed additionally %i outliers. \n',sum(outliers)),1);
// writeReconstructionLog(sprintf('Total data after 3 filter steps: Taken %d/%d AScans for reconstruction (%.2f percent).', numel(tofDataTotal), numScans, (numel(tofDataTotal) / numScans)*100), 1)
// end
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// if transParams.detection.saveDetection % writing the detected values to file
// writeReconstructionLog('Save transmission detections.', 1);
// if(~transParams.detection.outlierOnTasDetection)
// snBlockTotal = snBlockTotal(valid);
// slBlockTotal = slBlockTotal(valid);
// rnBlockTotal = rnBlockTotal(valid);
// rlBlockTotal = rlBlockTotal(valid);
// end
// mpBlockTotal = mpBlockTotal(valid);
// if(transParams.detection.outlierOnTasDetection)
// snBlockTotal = snBlockTotal(~outliers);
// slBlockTotal = slBlockTotal(~outliers);
// rnBlockTotal = rnBlockTotal(~outliers);
// rlBlockTotal = rlBlockTotal(~outliers);
// mpBlockTotal = mpBlockTotal(~outliers);
// end
// saveTransmisssionDetectionData(transParams.pathSaveDetection, tofDataTotal, attDataTotal, senderList, receiverList, mpBlockTotal, slBlockTotal, snBlockTotal, rlBlockTotal, rnBlockTotal, waterTempList, expInfo.rootMeasUniqueID, dataInfo);
// end
TransmissionData result;
result.attDataTotal = attDataTotal;
result.tofDataTotal = tofDataTotal;
result.receiverList = receiverList;
result.senderList = senderList;
result.dataInfo = dataInfno;
result.waterTempList = waterTempList;
return result;
}

38
src/transmissionReconstruction/detection/getTransmissionData.h
View File

@@ -5,13 +5,47 @@
#include "../../common/getMeasurementMetaData.h"
#include "src/common/getGeometryInfo.h"
class Parser;
namespace Recon
{
void getTransmissionData(const Aurora::Matrix& aMotorPos, const Aurora::Matrix& aMotoPosRef, const Aurora::Matrix& aSlList,
struct MetaInfos
{
Aurora::Matrix snrValues;
Aurora::Matrix snrValuesRef;
Aurora::Matrix mpBlock;
Aurora::Matrix slBlock;
Aurora::Matrix snBlock;
Aurora::Matrix rlBlock;
Aurora::Matrix rnBlock;
};
struct DataInfo
{
Aurora::Matrix findDefect;
Aurora::Matrix sn;
Aurora::Matrix sl;
Aurora::Matrix rn;
Aurora::Matrix rl;
Aurora::Matrix mp;
unsigned long long numPossibleScans;
Aurora::Matrix numValidScans;
};
struct TransmissionData
{
Aurora::Matrix tofDataTotal;
Aurora::Matrix attDataTotal;
Aurora::Matrix senderList;
Aurora::Matrix receiverList;
Aurora::Matrix waterTempList;
DataInfo dataInfo;
};
TransmissionData getTransmissionData(const Aurora::Matrix& aMotorPos, const Aurora::Matrix& aMotoPosRef, const Aurora::Matrix& aSlList,
const Aurora::Matrix& aSnList, const Aurora::Matrix& aRlList, const Aurora::Matrix& aRnList,
const TempInfo& aTemp, const TempInfo& aTempRef, GeometryInfo& aGeom,
GeometryInfo& aGeomRef, const MeasurementInfo& aExpInfo, const MeasurementInfo& aExpInfoRef,
const PreComputes& aPreComputes);
const PreComputes& aPreComputes, Parser* aParser, Parser* aParserRef);
}
#endif

13
src/transmissionReconstruction/reconstruction/reconstruction.cpp
View File

@@ -78,9 +78,9 @@ namespace Recon {
return dims;
}
void slownessToSOS(Aurora::Matrix & aVF1, double aSOS_IN_WATER)
Matrix slownessToSOS(Aurora::Matrix & aVF1, double aSOS_IN_WATER)
{
aVF1 = 1 / ((aVF1 + 1) / aSOS_IN_WATER);
return 1 / ((aVF1 + 1) / aSOS_IN_WATER);
}
DiscretizePositionValues discretizePositions(Aurora::Matrix &aVSenderCoordList, Aurora::Matrix &aVReceiverCoordList, double aNumPixelXY)
@@ -224,7 +224,14 @@ namespace Recon {
if(!data.isNull())
{
result.outSOS = solveParameterIterator(buildMatrixR.M, b, dims, false, transParams::nonNeg)[0][0];
Matrix sosValue = solveParameterIterator(buildMatrixR.M, b, dims, false, transParams::nonNeg)[0][0];
result.outSOS = slownessToSOS(sosValue, SOS_IN_WATER) ;
}
if(!dataAtt.isNull())
{
Matrix attValue = solveParameterIterator(buildMatrixR.M, bAtt, dims, false, transParams::nonNeg)[0][0];
result.outATT = attValue/100 ;
}
}

2
src/transmissionReconstruction/reconstruction/reconstruction.h
View File

@@ -23,7 +23,7 @@ Aurora::Matrix calculateResolution(const Aurora::Matrix &aVDdims, const Aurora::
Aurora::Matrix getDimensions(double aNumPixelXY, const Aurora::Matrix& ddims);
void slownessToSOS(Aurora::Matrix & aVF1, double aSOS_IN_WATER);
Aurora::Matrix slownessToSOS(Aurora::Matrix & aVF1, double aSOS_IN_WATER);
DiscretizePositionValues discretizePositions(Aurora::Matrix &aVSenderCoordList, Aurora::Matrix &aVReceiverCoordList, double aNumPixelXY);

47
src/transmissionReconstruction/startTransmissionReconstruction.cpp Normal file
View File

@@ -0,0 +1,47 @@
#include "startTransmissionReconstruction.h"
#include "./detection/getTransmissionData.h"
#include "Matrix.h"
#include "common/dataBlockCreation/removeDataFromArrays.h"
#include "src/transmissionReconstruction/dataFilter/dataFilter.h"
#include "src/transmissionReconstruction/dataPreperation.h"
#include "src/common/getMeasurementMetaData.h"
#include "src/common/qualityReview.h"
#include "src/transmissionReconstruction/reconstruction/reconstruction.h"
#include "src/config/config.h"
#include "Function2D.h"
#include "MatlabWriter.h"
using namespace Aurora;
using namespace Recon;
void Recon::startTransmissionReconstruction(const Aurora::Matrix& aMotorPos, const Aurora::Matrix& aMotoPosRef, const Aurora::Matrix& aSlList,
const Aurora::Matrix& aSnList, const Aurora::Matrix& aRlList, const Aurora::Matrix& aRnList,
const TempInfo& aTemp, const TempInfo& aTempRef, Recon::GeometryInfo& aGeom,
GeometryInfo& aGeomRef, const MeasurementInfo& aExpInfo, const MeasurementInfo& aExpInfoRef,
const PreComputes& aPreComputes, Parser* aParser, Parser* aParserRef)
{
auto transmissionData = getTransmissionData(aMotorPos, aMotoPosRef, aSlList, aSnList, aRlList, aRnList, aTemp, aTempRef,
aGeom, aGeomRef, aExpInfo, aExpInfoRef, aPreComputes, aParser, aParserRef);
Matrix dists = Recon::distanceBetweenTwoPoints(transmissionData.senderList, transmissionData.receiverList);
Matrix sosRef = Recon::temperatureToSoundSpeed(transmissionData.waterTempList, "marczak");
Matrix valid = Recon::checkTofDetections(transmissionData.tofDataTotal, dists, sosRef,
Recon::transParams::minSpeedOfSound,Recon::transParams::maxSpeedOfSound).valid;
if(transParams::qualityCheck)
{
qualityReview(sum(valid,Aurora::All)[0], transmissionData.dataInfo.numPossibleScans);
}
DiscretizePositionValues positionValues = Recon::discretizePositions(transmissionData.senderList, transmissionData.receiverList, Recon::transParams::numPixelXY);
Matrix tofData = removeDataFromArrays(transmissionData.tofDataTotal, valid);
Matrix attData = removeDataFromArrays(transmissionData.attDataTotal, valid);
Matrix senderList = removeDataFromArrays(positionValues.senderCoordList, valid);
Matrix reveiverList = removeDataFromArrays(positionValues.receiverCoordList, valid);
auto transmissionReon = reconstructArt(tofData, attData, positionValues.dims, senderList, reveiverList, positionValues.res, aTemp.expectedSOSWater[0]);
MatlabWriter w1("/home/sun/transmissionATT.mat");
MatlabWriter w2("/home/sun/transmissionSOS.mat");
w1.write(transmissionReon.outATT, "ATT");
w2.write(transmissionReon.outSOS, "SOS");
}

19
src/transmissionReconstruction/startTransmissionReconstruction.h Normal file
View File

@@ -0,0 +1,19 @@
#ifndef START_TRANSMISSION_RECONSTRUCTION_H
#define START_TRANSMISSION_RECONSTRUCTION_H
#include "Matrix.h"
#include "../common/getMeasurementMetaData.h"
#include "../common/getGeometryInfo.h"
class Parser;
namespace Recon
{
void startTransmissionReconstruction(const Aurora::Matrix& aMotorPos, const Aurora::Matrix& aMotoPosRef, const Aurora::Matrix& aSlList,
const Aurora::Matrix& aSnList, const Aurora::Matrix& aRlList, const Aurora::Matrix& aRnList,
const TempInfo& aTemp, const TempInfo& aTempRef, Recon::GeometryInfo& aGeom,
GeometryInfo& aGeomRef, const MeasurementInfo& aExpInfo, const MeasurementInfo& aExpInfoRef,
const PreComputes& aPreComputes, Parser* aParser, Parser* aParserRef);
}
#endif