#include "Function2D.h" #include "Matrix.h" #include #define GLOBLE_CONFIG #include "config.h" #include "src/log/log.h" #include "json.hpp" #include namespace Recon { const std::string ReconParamsFileName = "configReconstruction_USCT3Dv3.json"; const std::string ReflectParamsFileName = "configReflectionReconstruction_USCT3Dv3.json"; const std::string TransParramsFileName = "configTransmissionReconstruction_USCT3Dv3.json"; const std::string ConfigPath= "./"; Aurora::Matrix readToMatrix(const nlohmann::json& aJsonObj, bool aIsHorizontal = true) { if(aJsonObj.is_array()) { std::vector vec = aJsonObj.get>(); double* data = vec.data(); int size = vec.size(); if(aIsHorizontal) { return Aurora::Matrix::copyFromRawData(data, 1, size); } return Aurora::Matrix::copyFromRawData(data, size); } if(aJsonObj.is_number()) { double value = aJsonObj.get(); return Aurora::Matrix::fromRawData(new double[1]{value}, 1); } return Aurora::Matrix(); } void initalizeConfigFromFiles() { nlohmann::json reconParamsJson; nlohmann::json reflectParamsJson; nlohmann::json transParamsJson; std::ifstream reconParamsFile(ReconParamsFileName); std::ifstream reflectParamsFile(ReflectParamsFileName); std::ifstream transParamsFile(TransParramsFileName); if(reconParamsFile.good()) { reconParamsFile >> reconParamsJson; if(reconParamsJson.contains("files")) { nlohmann::json files = reconParamsJson.at("files"); if(files.contains("measurementInfo")) { nlohmann::json measurementInfo = files.at("measurementInfo"); if(measurementInfo.contains("ce")) { nlohmann::json ce = measurementInfo.at("ce"); if(ce.contains("useCEMeasured")) { reconParams::useCEMeasured = ce.at("useCEMeasured").get(); } if(ce.contains("removeOutliersFromCEMeasured")) { reconParams::removeOutliersFromCEMeasured = ce.at("removeOutliersFromCEMeasured").get(); } if(ce.contains("offsetFilterEnabled")) { reconParams::offsetFilterEnabled = ce.at("offsetFilterEnabled").get(); } if(ce.contains("offsetFilterDisabled")) { reconParams::offsetFilterDisabled = ce.at("offsetFilterDisabled").get(); } } if(measurementInfo.contains("temp")) { nlohmann::json temp = measurementInfo.at("temp"); if(temp.contains("useTASTempComp")) { reconParams::useTASTempComp = temp.at("useTASTempComp").get(); } if(temp.contains("correctTASTemp")) { reconParams::correctTASTemp = temp.at("correctTASTemp").get(); } } } if(files.contains("hardwareSelection")) { nlohmann::json hardwareSelection = files.at("hardwareSelection"); if(hardwareSelection.contains("gpuSelectionList")) { nlohmann::json gpuSelectionList = hardwareSelection.at("gpuSelectionList"); reconParams::gpuSelectionList = readToMatrix(gpuSelectionList, false); } } if(files.contains("dataInfo")) { nlohmann::json dataInfo = files.at("dataInfo"); if(dataInfo.contains("expectedAScanLength")) { reconParams::expectedAScanDataLength = dataInfo.at("expectedAScanLength").get(); } } } } else { RECON_INFO(ReconParamsFileName + " not found."); } if(reflectParamsFile.good()) { reflectParamsFile >> reflectParamsJson; if(reflectParamsJson.contains("params")) { nlohmann::json params = reflectParamsJson.at("params"); if(params.contains("runReflectionReco")) { reflectParams::runReflectionReco = params.at("runReflectionReco").get(); } if(params.contains("dataSelection")) { nlohmann::json dataSelection = params.at("dataSelection"); if(dataSelection.contains("senderTasList")) { reflectParams::senderTasList = readToMatrix(dataSelection.at("senderTasList"), false); } if(dataSelection.contains("senderElementList")) { reflectParams::senderElementList = readToMatrix(dataSelection.at("senderElementList"), false); } if(dataSelection.contains("receiverTasList")) { reflectParams::receiverTasList = readToMatrix(dataSelection.at("receiverTasList"), false); } if(dataSelection.contains("receiverElementList")) { reflectParams::receiverElementList = readToMatrix(dataSelection.at("receiverElementList"), false); } if(dataSelection.contains("motorPos")) { reflectParams::motorPos = readToMatrix(dataSelection.at("motorPos"), false); } if(dataSelection.contains("constrictReflectionAngles")) { reflectParams::constrictReflectionAngles = dataSelection.at("constrictReflectionAngles").get(); } if(dataSelection.contains("angleLowerLimit")) { reflectParams::angleLowerLimit = dataSelection.at("angleLowerLimit").get(); } if(dataSelection.contains("angleUpperLimit")) { reflectParams::angleUpperLimit = dataSelection.at("angleUpperLimit").get(); } if(dataSelection.contains("findDefects")) { reflectParams::findDefects = dataSelection.at("findDefects").get(); } if(dataSelection.contains("epsilon")) { reflectParams::epsilon = dataSelection.at("epsilon").get(); } } if(params.contains("dataBlocking")) { nlohmann::json dataBlocking = params.at("dataBlocking"); if(dataBlocking.contains("mpSize")) { reflectParams::mpSize = dataBlocking.at("mpSize").get(); } if(dataBlocking.contains("senderTASSize")) { reflectParams::senderTASSize = dataBlocking.at("senderTASSize").get(); } if(dataBlocking.contains("senderElementSize")) { reflectParams::senderElementSize = dataBlocking.at("senderElementSize").get(); } } if(params.contains("qualityCheck")) { nlohmann::json qualityCheck = params.at("qualityCheck"); if(qualityCheck.contains("qualityCheck")) { reflectParams::qualityCheck = qualityCheck.at("qualityCheck").get(); } if(qualityCheck.contains("warningThreshold")) { reflectParams::warningThreshold = qualityCheck.at("warningThreshold").get(); } if(qualityCheck.contains("errorThreshold")) { reflectParams::errorThreshold = qualityCheck.at("errorThreshold").get(); } } if(params.contains("dataPreparation")) { nlohmann::json dataPreparation = params.at("dataPreparation"); if(dataPreparation.contains("version")) { reflectParams::version = dataPreparation.at("version").get(); } if(dataPreparation.contains("aScanReconstructionFrequency")) { reflectParams::aScanReconstructionFrequency = dataPreparation.at("aScanReconstructionFrequency").get(); } if(dataPreparation.contains("offsetElectronic")) { reflectParams::offsetElectronic = dataPreparation.at("offsetElectronic").get(); } if(dataPreparation.contains("removeDCOffset")) { reflectParams::removeDCOffset = dataPreparation.at("removeDCOffset").get(); } } if(params.contains("imageInfos")) { nlohmann::json imageInfos = params.at("imageInfos"); if(imageInfos.contains("pixelResolutionX")) { reflectParams::pixelResolutionX = imageInfos.at("pixelResolutionX").get(); } if(imageInfos.contains("pixelResolutionY")) { reflectParams::pixelResolutionY = imageInfos.at("pixelResolutionY").get(); } if(imageInfos.contains("imageStartpoint")) { reflectParams::imageStartpoint = readToMatrix(imageInfos.at("imageStartpoint")); } if(imageInfos.contains("imageEndpoint")) { reflectParams::imageEndpoint = readToMatrix(imageInfos.at("imageEndpoint")); } } if(params.contains("signalProcessing")) { nlohmann::json signalProcessing = params.at("signalProcessing"); if(signalProcessing.contains("useOptPulse")) { reflectParams::useOptPulse = signalProcessing.at("useOptPulse").get(); } if(signalProcessing.contains("optPulseFactor")) { reflectParams::optPulseFactor = signalProcessing.at("optPulseFactor").get(); } if(signalProcessing.contains("expectedPulseLength")) { reflectParams::expectedPulseLength = signalProcessing.at("expectedPulseLength").get(); } if(signalProcessing.contains("limitNumPulsesTo")) { reflectParams::limitNumPulsesTo = signalProcessing.at("limitNumPulsesTo").get(); } if(signalProcessing.contains("normalizePeaks")) { reflectParams::normalizePeaks = signalProcessing.at("normalizePeaks").get(); } if(signalProcessing.contains("removeTransmissionSignal")) { reflectParams::removeTransmissionSignal = signalProcessing.at("removeTransmissionSignal").get(); } if(signalProcessing.contains("suppressSameHead")) { reflectParams::suppressSameHead = signalProcessing.at("suppressSameHead").get(); } if(signalProcessing.contains("suppressSameHeadLength")) { reflectParams::suppressSameHeadLength = signalProcessing.at("suppressSameHeadLength").get(); } if(signalProcessing.contains("useCorrelation")) { reflectParams::useCorrelation = signalProcessing.at("useCorrelation").get(); } if(signalProcessing.contains("matchedFilterCeAScan")) { reflectParams::matchedFilterCeAScan = signalProcessing.at("matchedFilterCeAScan").get(); } if(signalProcessing.contains("windowLength")) { reflectParams::windowLength = signalProcessing.at("windowLength").get(); } if(signalProcessing.contains("numThreads")) { reflectParams::numThreads = signalProcessing.at("numThreads").get(); } if(signalProcessing.contains("expectedUSSpeedRange")) { reflectParams::expectedUSSpeedRange = readToMatrix(signalProcessing.at("expectedUSSpeedRange")); } } if(params.contains("transmissionCorrection")) { nlohmann::json transmissionCorrection = params.at("transmissionCorrection"); if(transmissionCorrection.contains("soundSpeedCorrection")) { reflectParams::soundSpeedCorrection = transmissionCorrection.at("soundSpeedCorrection").get(); } if(transmissionCorrection.contains("attenuationCorrection")) { reflectParams::attenuationCorrection = transmissionCorrection.at("attenuationCorrection").get(); } if(transmissionCorrection.contains("saveTransmInReflCoords")) { reflectParams::saveTransmInReflCoords = transmissionCorrection.at("saveTransmInReflCoords").get(); } if(transmissionCorrection.contains("resolutionTransmMap")) { reflectParams::resolutionTransmMap = transmissionCorrection.at("resolutionTransmMap").get(); } } if(params.contains("saft")) { nlohmann::json saft = params.at("saft"); if(saft.contains("debugMode")) { reflectParams::debugMode = saft.at("debugMode").get(); } if(saft.contains("blockSizeReco")) { reflectParams::blockSizeReco = saft.at("blockSizeReco").get(); } if(saft.contains("medianWindowSize")) { reflectParams::medianWindowSize = saft.at("medianWindowSize").get(); } if(saft.contains("saftVariant")) { reflectParams::saftVariant = readToMatrix(saft.at("saftVariant")); } if(saft.contains("useAscanIndex")) { reflectParams::useAscanIndex = saft.at("useAscanIndex").get(); } if(saft.contains("attenuationCorrectionLimit")) { reflectParams::attenuationCorrectionLimit = saft.at("attenuationCorrectionLimit").get(); } if(saft.contains("blockDimXYZ")) { reflectParams::blockDimXYZ = readToMatrix(saft.at("blockDimXYZ")); } } } } else { RECON_INFO(ReflectParamsFileName + " not found."); } if(transParamsFile.good()) { transParamsFile >> transParamsJson; if(transParamsJson.contains("params")) { nlohmann::json params = transParamsJson.at("params"); if(params.contains("runTransmissionReco")) { transParams::runTransmissionReco = params.at("runTransmissionReco").get(); } if(params.contains("verbose")) { transParams::verbose = params.at("verbose").get(); } if(params.contains("saveReco")) { transParams::saveRecon = params.at("saveReco").get(); } if(params.contains("saveDebugInformation")) { transParams::saveDebugInfomation = params.at("saveDebugInformation").get(); } if(params.contains("dataSelection")) { nlohmann::json dataSelection = params.at("dataSelection"); if(dataSelection.contains("senderTasList")) { reflectParams::senderTasList = readToMatrix(dataSelection.at("senderTasList"), false); } if(dataSelection.contains("receiverTasList")) { reflectParams::receiverTasList = readToMatrix(dataSelection.at("receiverTasList"), false); } if(dataSelection.contains("senderElementList")) { reflectParams::senderElementList = readToMatrix(dataSelection.at("senderElementList"), false); } if(dataSelection.contains("receiverElementList")) { reflectParams::receiverElementList = readToMatrix(dataSelection.at("receiverElementList"), false); } if(dataSelection.contains("motorPos")) { reflectParams::motorPos = readToMatrix(dataSelection.at("motorPos"), false); } if(dataSelection.contains("filterSensitivity")) { transParams::filterSensitivity = dataSelection.at("filterSensitivity").get(); } if(dataSelection.contains("sensFilter")) { transParams::sensFilter = dataSelection.at("sensFilter").get(); } if(dataSelection.contains("angleLowerLimit")) { transParams::angleLowerLimit = dataSelection.at("angleLowerLimit").get(); } if(dataSelection.contains("angleUpperLimit")) { transParams::angleUpperLimit = dataSelection.at("angleUpperLimit").get(); } if(dataSelection.contains("applyCalib")) { transParams::applyCalib = dataSelection.at("applyCalib").get(); } if(dataSelection.contains("snrThreshold")) { transParams::snrThreshold = dataSelection.at("snrThreshold").get(); } if(dataSelection.contains("calibReferenceTas")) { nlohmann::json calibReferenceTas = dataSelection.at("calibReferenceTas"); transParams::calibReferenceTas = readToMatrix(calibReferenceTas, false); } if(dataSelection.contains("calibReferenceMotorPosition")) { nlohmann::json calibReferenceMotorPosition = dataSelection.at("calibReferenceMotorPosition"); transParams::calibReferenceMotorPosition = readToMatrix(calibReferenceMotorPosition, false); } } if(params.contains("qualityCheck")) { nlohmann::json qualityCheck = params.at("qualityCheck"); if(qualityCheck.contains("qualityCheck")) { transParams::qualityCheck = qualityCheck.at("qualityCheck").get(); } if(qualityCheck.contains("warningThreshold")) { transParams::warningThreshold = qualityCheck.at("warningThreshold").get(); } if(qualityCheck.contains("errorThreshold")) { transParams::errorThreshold = qualityCheck.at("errorThreshold").get(); } } if(params.contains("dataBlocking")) { nlohmann::json dataBlocking = params.at("dataBlocking"); if(dataBlocking.contains("mpSize")) { transParams::mpSize = dataBlocking.at("mpSize").get(); } if(dataBlocking.contains("senderTASSize")) { transParams::senderTASSize = dataBlocking.at("senderTASSize").get(); } if(dataBlocking.contains("senderElementSize")) { transParams::senderElementSize = dataBlocking.at("senderElementSize").get(); } } if(params.contains("dataPreparation")) { nlohmann::json dataPreparation = params.at("dataPreparation"); if(dataPreparation.contains("numPixelXY")) { transParams::numPixelXY = dataPreparation.at("numPixelXY").get(); } if(dataPreparation.contains("offsetElectronic")) { transParams::offsetElectronic = dataPreparation.at("offsetElectronic").get(); } if(dataPreparation.contains("aScanReconstructionFrequency")) { transParams::aScanReconstructionFrequency = dataPreparation.at("aScanReconstructionFrequency").get(); } if(dataPreparation.contains("minTemperature")) { transParams::minTemperature = dataPreparation.at("minTemperature").get(); } if(dataPreparation.contains("maxTemperature")) { transParams::maxTemperature = dataPreparation.at("maxTemperature").get(); } } if(params.contains("detection")) { nlohmann::json detection = params.at("detection"); if(detection.contains("forceRedetect")) { transParams::forceRedetect = detection.at("forceRedetect").get(); } if(detection.contains("saveDetection")) { transParams::saveDetection = detection.at("saveDetection").get(); } if(detection.contains("version")) { transParams::version = detection.at("version").get(); } if(detection.contains("useTimeWindowing")) { transParams::useTimeWindowing = detection.at("useTimeWindowing").get(); } if(detection.contains("gaussWindow")) { transParams::gaussWindow = detection.at("gaussWindow").get(); } if(detection.contains("outlierOnTasDetection")) { transParams::outlierOnTasDetection = detection.at("outlierOnTasDetection").get(); } if(detection.contains("resampleFactor")) { transParams::resampleFactor = detection.at("resampleFactor").get(); } if(detection.contains("nThreads")) { transParams::nThreads = detection.at("nThreads").get(); } if(detection.contains("minSpeedOfSound")) { transParams::minSpeedOfSound = detection.at("minSpeedOfSound").get(); } if(detection.contains("maxSpeedOfSound")) { transParams::maxSpeedOfSound = detection.at("maxSpeedOfSound").get(); } if(detection.contains("detectionWindowSOS")) { transParams::detectionWindowSOS = detection.at("detectionWindowSOS").get(); } if(detection.contains("detectionWindowATT")) { transParams::detectionWindowATT = detection.at("detectionWindowATT").get(); } } if(params.contains("rayTracing")) { nlohmann::json rayTracing = params.at("rayTracing"); if(rayTracing.contains("bentReconstruction")) { transParams::bentReconstruction = rayTracing.at("bentReconstruction").get(); } if(rayTracing.contains("bresenham")) { transParams::bresenham = rayTracing.at("bresenham").get(); } if(rayTracing.contains("bentMethod")) { transParams::bentMethod = rayTracing.at("bentMethod").get(); } if(rayTracing.contains("bentTol")) { transParams::bentTol = rayTracing.at("bentTol").get(); } if(rayTracing.contains("bentIter")) { transParams::bentIter = rayTracing.at("bentIter").get(); } } if(params.contains("solver")) { nlohmann::json solver = params.at("solver"); if(solver.contains("name")) { transParams::name = solver.at("name").get(); } if(solver.contains("maxIter")) { transParams::maxIter = solver.at("maxIter").get(); } if(solver.contains("muValues")) { nlohmann::json muValues = solver.at("muValues"); transParams::muValues = readToMatrix(solver.at("muValues"), false); } if(solver.contains("betaValues")) { nlohmann::json betaValues = solver.at("betaValues"); transParams::betaValues = readToMatrix(solver.at("betaValues"), false); } } } } else { RECON_INFO(TransParramsFileName + " not found."); } reflectParams::expectedAScanDataLength = reconParams::expectedAScanDataLength; reflectParams::gpuSelectionList = reconParams::gpuSelectionList; transParams::gpuSelectionList = reconParams::gpuSelectionList; } void initalizeConfig() { //reconParams.measurementInfo.ce reconParams::useCEMeasured = true; reconParams::removeOutliersFromCEMeasured = true; reconParams::offsetFilterEnabled = 6.9e-6; reconParams::offsetFilterDisabled = 1.2e-6; //reconParams.measurementInfo.temp reconParams::useTASTempComp = true; reconParams::correctTASTemp = 1; //reconParams.hardwareSelection reconParams::gpuSelectionList = Aurora::Matrix::fromRawData(new double[8] {0,1,2,3,4,5,6,7},8); //reconParams.dataInfo reconParams::expectedAScanDataLength = 4000; //reflectParams.dataSelection reflectParams::senderTasList = Aurora::Matrix::fromRawData(new double[128] {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128},128); //1~128 reflectParams::senderElementList = 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); //1~18 reflectParams::receiverTasList = Aurora::Matrix::fromRawData(new double[128] {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128},128); //1~128 reflectParams::receiverElementList = 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); //1~18 reflectParams::motorPos = Aurora::Matrix::fromRawData(new double[2] {1,2}, 2); reflectParams::constrictReflectionAngles = 1; reflectParams::angleLowerLimit = 45; reflectParams::angleUpperLimit = 360; reflectParams::findDefects = 1; reflectParams::epsilon = 4; //reflectParams.dataBlocking reflectParams::mpSize = 1; reflectParams::senderTASSize = 2; reflectParams::senderElementSize = 18; //reflectParams.qualityCheck reflectParams::qualityCheck = true; reflectParams::warningThreshold = 0.5; reflectParams::errorThreshold = 0.1; //reflectParams.dataPreparation reflectParams::version = 2; reflectParams::aScanReconstructionFrequency = 10000000; reflectParams::offsetElectronic = 5.2e-7; reflectParams::removeDCOffset = true; reflectParams::expectedAScanDataLength = 4000; //reflectParams.imageInfos reflectParams::pixelResolutionX = 400; reflectParams::pixelResolutionY = 400; reflectParams::pixelResolutionZ = NAN; reflectParams::imageStartpoint = Aurora::Matrix::fromRawData(new double[3] {-0.18,-0.18,-0.22}, 1, 3); reflectParams::imageEndpoint = Aurora::Matrix::fromRawData(new double[3] {0.18,0.18,0.02}, 1, 3); reflectParams::imageResolution = NAN; reflectParams::imageXYZ = Aurora::Matrix(); //reflectParams.signalProcessing reflectParams::useOptPulse = 1; reflectParams::optPulseFactor = 48; reflectParams::expectedPulseLength = 90; reflectParams::limitNumPulsesTo = 100; reflectParams::normalizePeaks = 1; reflectParams::removeTransmissionSignal = 1; reflectParams::suppressSameHead = 1; reflectParams::suppressSameHeadLength = 1500; reflectParams::useCorrelation = 1; reflectParams::matchedFilterCeAScan = true; reflectParams::windowLength = 10; reflectParams::numThreads = 30; reflectParams::expectedUSSpeedRange = Aurora::Matrix::fromRawData(new double[2] {1420,1600}, 1, 2); //reflectParams.transmissionCorrection reflectParams::soundSpeedCorrection = 0; reflectParams::attenuationCorrection = 0; reflectParams::saveTransmInReflCoords = 1; reflectParams::resolutionTransmMap = 0.005; //reflectParams.saft reflectParams::debugMode = 0; reflectParams::blockSizeReco = 60000; reflectParams::medianWindowSize = 1; reflectParams::saftVariant = Aurora::Matrix::fromRawData(new double[6]{1,1,1,1,0,0} , 1, 6); reflectParams::useAscanIndex = 1; reflectParams::attenuationCorrectionLimit = 20; reflectParams::blockDimXYZ = Aurora::Matrix::fromRawData(new double[3]{16,16,1} , 1, 3); reflectParams::gpuSelectionList = reconParams::gpuSelectionList;; //reflectParams reflectParams::VERSION_MATLAB_MAJOR = 9; reflectParams::OS_UNIX = 0; reflectParams::runReflectionReco = false; transParams::gpuSelectionList = reconParams::gpuSelectionList; //transParams.dataSelection transParams::verbose = 1; transParams::saveRecon = 1; transParams::saveDebugInfomation = 1; //transParams.dataSelection transParams::senderTasList = Aurora::Matrix::fromRawData(new double[128] {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128},128); //1~128 transParams::senderElementList = 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); //1~18 transParams::receiverTasList = Aurora::Matrix::fromRawData(new double[128] {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128},128); //1~128 transParams::receiverElementList = 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); //1~18 transParams::motorPos = Aurora::Matrix::fromRawData(new double[2] {1,2}, 2); transParams::filterSensitivity = 1; transParams::sensFilter = 0.3; transParams::angleLowerLimit = 120; transParams::angleUpperLimit = 180; transParams::applyCalib = true; transParams::snrThreshold = 10; transParams::calibReferenceTas = Aurora::Matrix::fromRawData(new double[1] {1},1); transParams::calibReferenceMotorPosition = Aurora::Matrix::fromRawData(new double[1] {1},1); //transParams.qualityCheck transParams::qualityCheck = 1; transParams::warningThreshold = 0.5; transParams::errorThreshold = 0.1; //transParams.dataBlocking transParams::mpSize = 1; transParams::senderTASSize = 2; transParams::senderElementSize = 18; //transParams.dataPreparation transParams::numPixelXY = 128; transParams::offsetElectronic = 5.2e-7; transParams::aScanReconstructionFrequency = 10000000; transParams::minTemperature = 15; transParams::maxTemperature = 40; //transParams.detection transParams::forceRedetect = 0; transParams::saveDetection = 0; transParams::version = 1; transParams::useTimeWindowing = 1; transParams::gaussWindow = 0; transParams::outlierOnTasDetection = 0; transParams::resampleFactor = 1; transParams::nThreads = 8; transParams::minSpeedOfSound = 1450; transParams::maxSpeedOfSound = 1550; transParams::detectionWindowSOS = 1; transParams::detectionWindowATT = 50; transParams::pulseLengthSamples = 0; transParams::pulseLengthRefSamples = 0; //transParams.rayTracing transParams::bentReconstruction = false; transParams::bresenham = 1; transParams::bentMethod = 1; transParams::bentTol = 1; transParams::bentIter = 1; //transParams.solver transParams::name = "TVAL3"; transParams::maxIter = 50; transParams::muValues = Aurora::Matrix::fromRawData(new double[1] {100}, 1); transParams::betaValues = Aurora::Matrix::fromRawData(new double[1] {1}, 1); transParams::runTransmissionReco = true; transParams::nonNeg = false; initalizeConfigFromFiles(); } }