From aab3b1c87ca5ae360b2511215995519cd55571e2 Mon Sep 17 00:00:00 2001 From: sunwen Date: Wed, 3 Apr 2024 16:36:51 +0800 Subject: [PATCH] Add convertFp16 mode. --- src/MatLab/MatlabCreator.cpp | 7 + src/MatLab/MatlabCreator.h | 3 + .../MatlabCreatorConvertFp16Private.cpp | 967 ++++++++++++++++++ src/MatLab/MatlabCreatorConvertFp16Private.h | 42 + 4 files changed, 1019 insertions(+) create mode 100644 src/MatLab/MatlabCreatorConvertFp16Private.cpp create mode 100644 src/MatLab/MatlabCreatorConvertFp16Private.h diff --git a/src/MatLab/MatlabCreator.cpp b/src/MatLab/MatlabCreator.cpp index 155cd23..9e5a670 100644 --- a/src/MatLab/MatlabCreator.cpp +++ b/src/MatLab/MatlabCreator.cpp @@ -2,10 +2,12 @@ #include "MatlabCreatorPrivate.h" #include "MatlabCreatorVariableWindowPrivate.h" +#include "MatlabCreatorConvertFp16Private.h" MatlabCreator::MatlabCreator(const std::string& aDirectoryPath) : mPrivate(new MatlabCreatorPrivate(aDirectoryPath)) , mVariableWindowPrivate(new MatlabCreatorVariableWindowPrivate(aDirectoryPath)) + , mConvertFp16Private(new MatlabCreatorConvertFp16Private(aDirectoryPath)) { } @@ -24,5 +26,10 @@ bool MatlabCreator::createKITVariableWindowMat(const std::string& aOutputPath) return mVariableWindowPrivate->createKITMat(aOutputPath); } +bool MatlabCreator::createKITConvertFp16Mat(const std::string& aOutputPath) +{ + return mConvertFp16Private->createKITMat(aOutputPath); +} + diff --git a/src/MatLab/MatlabCreator.h b/src/MatLab/MatlabCreator.h index 78b1cb9..42b4fee 100644 --- a/src/MatLab/MatlabCreator.h +++ b/src/MatLab/MatlabCreator.h @@ -7,6 +7,7 @@ class MatlabCreatorPrivate; class MatlabCreatorVariableWindowPrivate; +class MatlabCreatorConvertFp16Private; class PARSERSHARED_EXPORT MatlabCreator { @@ -15,6 +16,7 @@ public: void setDirectoryPath(const std::string& aDirectoryPath); bool createKITMat(const std::string& aOutputPath); bool createKITVariableWindowMat(const std::string& aOutputPath); + bool createKITConvertFp16Mat(const std::string& aOutputPath); MatlabCreator(const MatlabCreator& aMatlabCreator) = delete; MatlabCreator& operator=(const MatlabCreator& aMatlabCreator) = delete; @@ -22,6 +24,7 @@ public: private: MatlabCreatorPrivate* mPrivate; MatlabCreatorVariableWindowPrivate* mVariableWindowPrivate; + MatlabCreatorConvertFp16Private* mConvertFp16Private; }; diff --git a/src/MatLab/MatlabCreatorConvertFp16Private.cpp b/src/MatLab/MatlabCreatorConvertFp16Private.cpp new file mode 100644 index 0000000..71b5790 --- /dev/null +++ b/src/MatLab/MatlabCreatorConvertFp16Private.cpp @@ -0,0 +1,967 @@ +#include "MatlabCreatorConvertFp16Private.h" + +#include "Helper/FileListHelper.h" +#include "Helper/ThreadHelper.h" +#include "Helper/DirHelper.h" +#include "Helper/MatlabHelper.h" +#include "Data/Hardwareinfomation.h" +#include "Data/OneTasAScanData.h" +#include "Data/AScanData.h" +#include "Data/CEMeasuredData.h" +#include "Data/GeometryIndex.h" +#include "Data/ElementIndex.h" +#include "Data/CEData.h" +#include "Data/MetaData.h" +#include "Data/MovementData.h" +#include "Data/TemperatureData.h" +#include "Data/PatientData.h" +#include "Mapper/MapperDataBase.h" +#include "MatlabOpener.h" +#include "Data/TasElementIndex.h" +#include "ShotList/ShotList.h" +#include "Parser.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace +{ + struct CreateMatSturct + { + std::shared_ptr mParser; + std::string mFileName; + std::shared_ptr mAScanData; + std::shared_ptr mAmplificationData; + }; + + double progress = 0; + + std::queue PRODUCER_DATAS; + std::mutex PRODUCER_MUTEX; + std::condition_variable PRODUCER_CONDITION; + + double convertfp16tofloat(uint16_t f16) + { + unsigned int sign, exp, fraction,hiden_bit=0; + double val; + + sign = (f16 & 0x8000) >> 15; + exp = (f16 & 0x7800) >> 11; + fraction = f16 & 0x7ff; + + if((sign==1 && exp==0) || (sign==0 && exp!=0)) + { + hiden_bit = 0x800; + } + if(exp>0)exp--; + val = (int32_t)((fraction+hiden_bit+(0xFFFFF000*sign))<<(exp)); + return val; + } + + std::string getTasFolderName(unsigned short aNum) + { + if (aNum < 10) + { + return "TAS00" + std::to_string(aNum); + } + else if(aNum >= 10 && aNum < 100) + { + return "TAS0" + std::to_string(aNum); + } + else + { + return "TAS" + std::to_string(aNum); + } + } + + std::string getMotorPositionFolderName(unsigned short aNum) + { + return "TASRotation0" + std::to_string(aNum); + } + + std::string getCEMeasureFolderName() + { + return "TASRotation00"; + } + + std::string getMatFileName(unsigned short aNum) + { + if (aNum < 10) + { + return "Emitter0" + std::to_string(aNum) + ".mat"; + } + else + { + return "Emitter" + std::to_string(aNum) + ".mat"; + } + } +} + +MatlabCreatorConvertFp16Private::MatlabCreatorConvertFp16Private(const std::string& aDirectoryPath) + : mDirectoryPath(FileListHelper::fixPathSlash(aDirectoryPath)) + , mFileList(FileListHelper::getFileList(mDirectoryPath)) +{ + DirHelper::checkPathSlash(mDirectoryPath); +} + +void MatlabCreatorConvertFp16Private::setDirectoryPath(const std::string& aDirectoryPath) +{ + mDirectoryPath = FileListHelper::fixPathSlash(aDirectoryPath); + DirHelper::checkPathSlash(mDirectoryPath); + mFileList = FileListHelper::getFileList(mDirectoryPath); +} + +bool MatlabCreatorConvertFp16Private::createKITMat(const std::string& aOutputPath) +{ + progress = 0; + if(mFileList.size() == 0) + { + return false; + } + std::shared_ptr parser(new Parser(mDirectoryPath)); + std::shared_ptr shotList = parser->getShotList(); + if(!shotList->isValid()) + { + return false; + } + unsigned int fileCount = static_cast(mFileList.size()); + unsigned int tasCount = shotList->getTasSize(); + unsigned int threadCount = ThreadHelper::getCreateMatFileThread(tasCount,fileCount); + unsigned int threadRemainder = tasCount % threadCount; + unsigned int tasOffSet = (tasCount - threadRemainder) / threadCount; + if(threadRemainder != 0) + { + ++tasOffSet; + } + unsigned int tasNum = 0; + std::vector> threads(static_cast(threadCount)); + + std::string dirPath = aOutputPath; + DirHelper dir; + if(!dir.exists(dirPath)) + { + dir.mkdir(dirPath); + } + + for(unsigned int i=0;i(new std::thread(&MatlabCreatorConvertFp16Private::createKITMatInThread, this, parser->clone(), tasNum, tasOffSet, dirPath)); + tasNum += tasOffSet; + } + for(unsigned int i=0; i< threadCount; ++i) + { + threads[i]->join(); + } + createCEMat(parser,dirPath); + createInfoMat(parser,dirPath); + createPatDataMat(parser,dirPath); + createTasTempMat(parser,dirPath); + createJumoTempMat(parser,dirPath); + createMovementsMat(parser,dirPath); + createCEMeasuredMat(parser,dirPath); + createTasTemCompMat(parser,dirPath); + createMeasurementRotationMat(parser,dirPath); + + std::cout< aParser, unsigned short aStartTasNum,unsigned short aTasCount, const std::string& aOutputPath) +{ + std::thread producerThread = std::thread(&MatlabCreatorConvertFp16Private::producerThreadFunction, this, aParser, aStartTasNum, aTasCount, aOutputPath); + ShotList* shotList = aParser->getShotList().get(); + for(unsigned short t=aStartTasNum;tgetMotorPositionSize();++m) + { + for(unsigned short e=0;egetElementSize();++e) + { + std::unique_lock lock(PRODUCER_MUTEX); + PRODUCER_CONDITION.wait(lock, []{return !PRODUCER_DATAS.empty();}); + std::shared_ptr parser = PRODUCER_DATAS.front().mParser; + std::string fileName = PRODUCER_DATAS.front().mFileName; + std::shared_ptr ascanData = PRODUCER_DATAS.front().mAScanData; + std::shared_ptr amplificationData = PRODUCER_DATAS.front().mAmplificationData; + PRODUCER_DATAS.pop(); + lock.unlock(); + createEmitterMat(parser,fileName,ascanData,amplificationData); + } + } + //CEMeasure + if(shotList->hasCEMeasured()) + { + std::unique_lock lock(PRODUCER_MUTEX); + PRODUCER_CONDITION.wait(lock, []{return !PRODUCER_DATAS.empty();}); + std::shared_ptr parser = PRODUCER_DATAS.front().mParser; + std::string fileName = PRODUCER_DATAS.front().mFileName; + std::shared_ptr ascanData = PRODUCER_DATAS.front().mAScanData; + std::shared_ptr amplificationData = PRODUCER_DATAS.front().mAmplificationData; + PRODUCER_DATAS.pop(); + lock.unlock(); + createEmitterMat(parser,fileName,ascanData,amplificationData); + } + ++progress; + std::cout<<"\r\033[K"< aParser, unsigned short aStartTasNum,unsigned short aTasCount, const std::string& aOutputPath) +{ + std::string dirPath = aOutputPath; + DirHelper dir; + ShotList* shotList = aParser->getShotList().get(); + for(unsigned short t=aStartTasNum;tgetTasValue(t)); + if(!dir.exists(tasFloder)) + { + dir.mkdir(tasFloder); + } + OneTasAScanData oneTasAscan = aParser->getOneTasAscanDataOfMotorPosition(shotList->getTasValue(t)); + //Motorposition + for(unsigned short m=0;mgetMotorPositionSize();++m) + { + std::string motorpositionFolder = tasFloder + SLASH_CHAR + getMotorPositionFolderName(shotList->getMotorPositionValue(m)); + if(!dir.exists(motorpositionFolder)) + { + dir.mkdir(motorpositionFolder); + } + for(unsigned short e=0;egetElementSize();++e) + { + unsigned short element = shotList->getElementValue(e); + std::shared_ptr ascanData = std::shared_ptr(new double[aParser->getDataLength() * RECEIVE_ELEMENT_COUNT],std::default_delete()); + memset(ascanData.get(), 0, sizeof(double) * aParser->getDataLength() * RECEIVE_ELEMENT_COUNT); + std::shared_ptr amplificationData = std::shared_ptr(new double[RECEIVE_ELEMENT_COUNT],std::default_delete()); + getAScanOfMPAndAmplification(aParser,shotList,oneTasAscan,ascanData,amplificationData,element,MotorPosition(shotList->getMotorPositionValue(m))); + std::string fileName = motorpositionFolder + SLASH_CHAR + getMatFileName(element); + std::unique_lock lock(PRODUCER_MUTEX); + PRODUCER_DATAS.push({aParser,fileName,ascanData,amplificationData}); + lock.unlock(); + PRODUCER_CONDITION.notify_one(); + //createEmitterMat(aParser,fileName,ascanData,amplificationData); + } + } + //CEMeasure + if(shotList->hasCEMeasured()) + { + std::string cemeasureFolder = tasFloder + SLASH_CHAR + getCEMeasureFolderName(); + if(!dir.exists(cemeasureFolder)) + { + dir.mkdir(cemeasureFolder); + } + oneTasAscan = aParser->getOneTasAscanDataOfCEMeasured(shotList->getTasValue(t)); + std::shared_ptr ascanData = std::shared_ptr(new double[aParser->getDataLength() * RECEIVE_ELEMENT_COUNT],std::default_delete()); + memset(ascanData.get(), 0, sizeof(double) * aParser->getDataLength() * RECEIVE_ELEMENT_COUNT); + std::shared_ptr amplificationData = std::shared_ptr(new double[RECEIVE_ELEMENT_COUNT],std::default_delete()); + getAScanOfCEAndAmplification(aParser,shotList,oneTasAscan,ascanData,amplificationData); + std::string fileName = cemeasureFolder + SLASH_CHAR + getMatFileName(0); + std::unique_lock lock(PRODUCER_MUTEX); + PRODUCER_DATAS.push({aParser,fileName,ascanData,amplificationData}); + lock.unlock(); + PRODUCER_CONDITION.notify_one(); + //createEmitterMat(aParser,fileName,ascanData,amplificationData); + } + } +} + +void MatlabCreatorConvertFp16Private::createEmitterMat(std::shared_ptr aParser,const std::string& aFileName,std::shared_ptr aAScanData,std::shared_ptr aAmplificationData) +{ + std::shared_ptr mapperArrayPointer = MapperDataBase::getMapperArray(); + std::string measurementID = aParser->getMetaData().getMeasurementID(); + size_t measurementDims[2] = {1,measurementID.size()}; + size_t ascanDims[2] = {aParser->getDataLength(),RECEIVE_ELEMENT_COUNT}; + size_t amplificationDims[2] = {1,RECEIVE_ELEMENT_COUNT}; + ReceiverIndicesPointer receiverIndicesPointer = aParser->getMetaData().getReceiverIndices(); + size_t receiverIndicesDims[2] = {receiverIndicesPointer.getLength(),1}; + double* receiverIndicesData = new double[receiverIndicesPointer.getLength()]; + std::copy(receiverIndicesPointer.get(),receiverIndicesPointer.get() + receiverIndicesPointer.getLength(), receiverIndicesData); + TasIndicesPointer tasIndicesPointer = aParser->getMetaData().getTasIndices(); + size_t tasIndicesDims[2] = {tasIndicesPointer.getLength(),1}; + double* tasIndicesData = new double[tasIndicesPointer.getLength()]; + std::copy(tasIndicesPointer.get(),tasIndicesPointer.get() + tasIndicesPointer.getLength(), tasIndicesData); + mat_t* matfp = nullptr; + matfp = Mat_CreateVer(aFileName.c_str(),nullptr,MAT_FT_DEFAULT); + if ( nullptr == matfp ) + { + return; + } + matvar_t* measurementIdVar = Mat_VarCreate("MeasurementID", MAT_C_CHAR,MAT_T_INT8,2,measurementDims,const_cast(measurementID.c_str()),0); + matvar_t* ascanVar = Mat_VarCreate("AScans", MAT_C_DOUBLE,MAT_T_DOUBLE,2,ascanDims,aAScanData.get(),0); + matvar_t* amplificationVar = Mat_VarCreate("Amplification", MAT_C_DOUBLE,MAT_T_DOUBLE,2,amplificationDims,aAmplificationData.get(),0); + matvar_t* receiverIndicesVar = Mat_VarCreate("receiverIndices",MAT_C_DOUBLE,MAT_T_DOUBLE,2,receiverIndicesDims,receiverIndicesData,0); + delete[] receiverIndicesData; + matvar_t* tasIndicesVar = Mat_VarCreate("TASIndices",MAT_C_DOUBLE,MAT_T_DOUBLE,2,tasIndicesDims,tasIndicesData,0); + delete[] tasIndicesData; + Mat_VarWrite(matfp,measurementIdVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,ascanVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,amplificationVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,receiverIndicesVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,tasIndicesVar,MAT_COMPRESSION_NONE); + Mat_VarFree(measurementIdVar); + Mat_VarFree(ascanVar); + Mat_VarFree(amplificationVar); + Mat_VarFree(receiverIndicesVar); + Mat_VarFree(tasIndicesVar); + Mat_Close(matfp); + return; +} + +void MatlabCreatorConvertFp16Private::getAScanOfCEAndAmplification(std::shared_ptr aParser,ShotList* aShotList,OneTasAScanData aOneTasAScanData,std::shared_ptr aAScanData,std::shared_ptr aAmplificationData) +{ + std::shared_ptr mapperArrayPointer = MapperDataBase::getMapperArray(); + for(unsigned int muxIndex = 0;muxIndex < aShotList->getMuxSize();++muxIndex) + { + unsigned int index = 0; + for(unsigned int i=0;igetMuxValue(muxIndex)]; + AScanData ascan = aParser->searchAscanDataFromOneTasAscanDataOfCE(aOneTasAScanData,TasElementIndex(TasIndex(receiveTas),ElementIndex(GeometryIndex(receiveElement)))); + double* float16Ascan = new double[aParser->getDataLength()]; + for(unsigned int j=0; jgetDataLength(); ++j) + { + float16Ascan[j] = convertfp16tofloat(ascan.get()[j]); + } + aAmplificationData.get()[muxIndex*TOTAL_CHANNEL+i] = ascan.getAmplification()[0]; + std::copy(float16Ascan, float16Ascan + aParser->getDataLength(), aAScanData.get() + (muxIndex*TOTAL_CHANNEL+i)*aParser->getDataLength()); + index+=9; + delete[] float16Ascan; + } + } +} + +void MatlabCreatorConvertFp16Private::getAScanOfMPAndAmplification(std::shared_ptr aParser,ShotList* aShotList,OneTasAScanData aOneTasAScanData,std::shared_ptr aAScanData,std::shared_ptr aAmplificationData,unsigned short aGeometryElement,MotorPosition aMotorPosition) +{ + std::shared_ptr mapperArrayPointer = MapperDataBase::getMapperArray(); + for(unsigned int muxIndex = 0;muxIndex < aShotList->getMuxSize();++muxIndex) + { + unsigned int index = 0; + for(unsigned int i=0;igetMuxValue(muxIndex)]; + AScanData ascan = aParser->searchAscanDataFromOneTasAscanDataOfMP(aOneTasAScanData,ElementIndex(GeometryIndex(aGeometryElement)),TasElementIndex(TasIndex(receiveTas),ElementIndex(GeometryIndex(receiveElement))),aMotorPosition); + double* float16Ascan = new double[aParser->getDataLength()]; + for(unsigned int j=0; jgetDataLength(); ++j) + { + float16Ascan[j] = convertfp16tofloat(ascan.get()[j]); + } + aAmplificationData.get()[muxIndex*TOTAL_CHANNEL+i] = ascan.getAmplification()[0]; + std::copy(float16Ascan, float16Ascan + aParser->getDataLength(), aAScanData.get() + (muxIndex*TOTAL_CHANNEL+i)*aParser->getDataLength()); + index+=9; + delete[] float16Ascan; + } + } +} + +void MatlabCreatorConvertFp16Private::createCEMat(std::shared_ptr aParser, const std::string& aDirectoryPath) +{ + DirHelper dir; + if(!dir.exists(aDirectoryPath)) + { + return; + } + mat_t* matfp = nullptr; + std::string ceMatFileName = aDirectoryPath + SLASH_CHAR + "CE.mat"; + matfp = Mat_CreateVer(ceMatFileName.c_str(),nullptr,MAT_FT_DEFAULT); + if (matfp == nullptr) + { + return; + } + matvar_t* ceVar = nullptr; + matvar_t* ceSfVar = nullptr; + matvar_t* ceOffSetVar = nullptr; + CEData ceData = aParser->getCEData(); + CEPointer ce = ceData.getCE(); + size_t ceDims[2] = {ce.getLength(),1}; + size_t ceSfDims[2] = {1,1}; + size_t ceOffSetDims[2] = {1,1}; + double ceSf = ceData.getCE_SF(); + double ceOffSet = ceData.getCEOffset(); + ceVar = Mat_VarCreate("CE",MAT_C_DOUBLE,MAT_T_UINT16,2,ceDims,ce.get(),0); + ceSfVar = Mat_VarCreate("CE_SF",MAT_C_DOUBLE,MAT_T_DOUBLE,2,ceSfDims,&ceSf,0); + ceOffSetVar = Mat_VarCreate("CEOffset",MAT_C_DOUBLE,MAT_T_DOUBLE,2,ceOffSetDims,&ceOffSet,0); + Mat_VarWrite(matfp,ceVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,ceSfVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,ceOffSetVar,MAT_COMPRESSION_NONE); + Mat_VarFree(ceVar); + Mat_VarFree(ceSfVar); + Mat_VarFree(ceOffSetVar); + Mat_Close(matfp); +} + +void MatlabCreatorConvertFp16Private::createInfoMat(std::shared_ptr aParser, const std::string& aDirectoryPath) +{ + DirHelper dir; + if(!dir.exists(aDirectoryPath)) + { + return; + } + mat_t* matfp = nullptr; + std::string infoMatFileName = aDirectoryPath + SLASH_CHAR + "info.mat"; + matfp = Mat_CreateVer(infoMatFileName.c_str(),nullptr,MAT_FT_DEFAULT); + if (matfp == nullptr) + { + return; + } + size_t structDims[1] ={1}; + const char* field[7] = {"shotlist","samplenumber","SampleRate","Datatype","MeasurementID","DACDelay","FilterBypass"}; + matvar_t* structVar = Mat_VarCreateStruct("MetaData",1,structDims,field,7); + //shotList + std::shared_ptr shotList = aParser->getShotList(); + ShotListArray shotListArray = shotList->getShotListArray(); + size_t shotListDims[2] ={shotListArray.getLength()/4,4}; + matvar_t* shotListVar = Mat_VarCreate("shotlist",MAT_C_DOUBLE,MAT_T_DOUBLE,2,shotListDims,shotListArray.get(),0); + Mat_VarSetStructFieldByName(structVar, "shotlist", 0, shotListVar); + //SampleNumber + MetaData metaData = aParser->getMetaData(); + double smpleNumber = aParser->getDataLength(); + size_t sampleNumberDims[2] ={1,1}; + matvar_t* sampleNumberVar = Mat_VarCreate("samplenumber",MAT_C_DOUBLE,MAT_T_DOUBLE,2,sampleNumberDims,&smpleNumber,0); + Mat_VarSetStructFieldByName(structVar, "samplenumber", 0, sampleNumberVar); + //SampleRate + double sampleRate = metaData.getSamplerate(); + size_t sampleRateDims[2] ={1,1}; + matvar_t* sampleRateVar = Mat_VarCreate("SampleRate",MAT_C_DOUBLE,MAT_T_DOUBLE,2,sampleRateDims,&sampleRate,0); + Mat_VarSetStructFieldByName(structVar, "SampleRate", 0, sampleRateVar); + //Datatype + std::string dataType = metaData.getDataType(); + size_t dataTypeDims[2] ={1,dataType.size()}; + matvar_t* dataTypeVar = Mat_VarCreate("Datatype",MAT_C_CHAR,MAT_T_INT8,2,dataTypeDims,const_cast(dataType.c_str()),0); + Mat_VarSetStructFieldByName(structVar, "Datatype", 0, dataTypeVar); + //MeasurementID + std::string measurementID = metaData.getMeasurementID(); + size_t measurementIDDims[2] ={1,measurementID.size()}; + matvar_t* measurementIDVar = Mat_VarCreate("MeasurementID",MAT_C_CHAR,MAT_T_INT8,2,measurementIDDims,const_cast(measurementID.c_str()),0); + Mat_VarSetStructFieldByName(structVar, "MeasurementID", 0, measurementIDVar); + //DACDelay + double dacDelay = metaData.getDacDelay(); + size_t dacDelayDims[2] ={1,1}; + matvar_t* dacDelayVar = Mat_VarCreate("DACDelay",MAT_C_DOUBLE,MAT_T_DOUBLE,2,dacDelayDims,&dacDelay,0); + Mat_VarSetStructFieldByName(structVar, "DACDelay", 0, dacDelayVar); + //FilterBypass + double filterByPass = metaData.getFilterByPass(); + size_t filterByPassDims[2] ={1,1}; + matvar_t* filterByPassVar = Mat_VarCreate("FilterBypass",MAT_C_DOUBLE,MAT_T_DOUBLE,2,filterByPassDims,&filterByPass,0); + Mat_VarSetStructFieldByName(structVar, "FilterBypass", 0, filterByPassVar); + Mat_VarWrite(matfp,structVar,MAT_COMPRESSION_NONE); + Mat_VarFree(structVar); + + //AScanDataType + dataTypeVar = Mat_VarCreate("AScanDatatype",MAT_C_CHAR,MAT_T_INT8,2,dataTypeDims,const_cast(dataType.c_str()),0); + Mat_VarWrite(matfp,dataTypeVar,MAT_COMPRESSION_NONE); + Mat_VarFree(dataTypeVar); + + //NumberSamples + sampleNumberVar = Mat_VarCreate("NumberSamples",MAT_C_DOUBLE,MAT_T_DOUBLE,2,sampleNumberDims,&smpleNumber,0); + Mat_VarWrite(matfp,sampleNumberVar,MAT_COMPRESSION_NONE); + Mat_VarFree(sampleNumberVar); + + //SampleRate + sampleRateVar = Mat_VarCreate("SampleRate",MAT_C_DOUBLE,MAT_T_DOUBLE,2,sampleRateDims,&sampleRate,0); + Mat_VarWrite(matfp,sampleRateVar,MAT_COMPRESSION_NONE); + Mat_VarFree(sampleRateVar); + + //Hardware + std::string hardware = "USCT3dv3"; + size_t hardwareDims[2] ={1,hardware.size()}; + matvar_t* hardwareVar = Mat_VarCreate("Hardware",MAT_C_CHAR,MAT_T_INT8,2,hardwareDims,const_cast(hardware.c_str()),0); + Mat_VarWrite(matfp,hardwareVar,MAT_COMPRESSION_NONE); + Mat_VarFree(hardwareVar); + + //HardwareVersion + std::string hardwareVersion = "3.0"; + size_t hardwareVersionDims[2] ={1,hardwareVersion.size()}; + matvar_t* hardwareVersionVar = Mat_VarCreate("HardwareVersion",MAT_C_CHAR,MAT_T_INT8,2,hardwareVersionDims,const_cast(hardwareVersion.c_str()),0); + Mat_VarWrite(matfp,hardwareVersionVar,MAT_COMPRESSION_NONE); + Mat_VarFree(hardwareVersionVar); + + //Bandpassundersampling + double bandpassundersampling = 0; + size_t bandpassDims[2] ={1,1}; + matvar_t* bandpassVar = Mat_VarCreate("Bandpassundersampling",MAT_C_DOUBLE,MAT_T_DOUBLE,2,bandpassDims,&bandpassundersampling,0); + Mat_VarWrite(matfp,bandpassVar,MAT_COMPRESSION_NONE); + Mat_VarFree(bandpassVar); + + Mat_Close(matfp); +} + +void MatlabCreatorConvertFp16Private::createCEMeasuredMat(std::shared_ptr aParser, const std::string& aDirectoryPath) +{ + DirHelper dir; + if(!dir.exists(aDirectoryPath)) + { + return; + } + mat_t* matfp = nullptr; + std::string ceMeasuredMatFileName = aDirectoryPath + SLASH_CHAR + "CEMeasured.mat"; + matfp = Mat_CreateVer(ceMeasuredMatFileName.c_str(),nullptr,MAT_FT_DEFAULT); + if (matfp == nullptr) + { + return; + } + MetaData metaData = aParser->getMetaData(); + + //MeasurementID + std::string measurementID = metaData.getMeasurementID(); + size_t measurementIDDims[2] ={1,measurementID.size()}; + matvar_t* measurementIDVar = Mat_VarCreate("MeasurementID",MAT_C_CHAR,MAT_T_INT8,2,measurementIDDims,const_cast(measurementID.c_str()),0); + + //receiverIndices + ReceiverIndicesPointer receiverIndices = metaData.getReceiverIndices(); + double* writeDataOfReceiverIndices = new double[receiverIndices.getLength()]; + std::copy(receiverIndices.get(), receiverIndices.get() + receiverIndices.getLength(), writeDataOfReceiverIndices); + size_t receiverIndicesDims[2] ={receiverIndices.getLength(),1}; + matvar_t* receiverIndicesVar = Mat_VarCreate("receiverIndices",MAT_C_DOUBLE,MAT_T_DOUBLE,2,receiverIndicesDims,writeDataOfReceiverIndices,0); + delete[] writeDataOfReceiverIndices; + + //TASIndices + TasIndicesPointer tasIndices = metaData.getTasIndices(); + double* writeDataOfTasIndices = new double[tasIndices.getLength()]; + std::copy(tasIndices.get(), tasIndices.get() + tasIndices.getLength(), writeDataOfTasIndices); + size_t tasIndicesDims[2] ={tasIndices.getLength(),1}; + matvar_t* tasIndicesVar = Mat_VarCreate("TASIndices",MAT_C_DOUBLE,MAT_T_DOUBLE,2,tasIndicesDims,writeDataOfTasIndices,0); + delete[] writeDataOfTasIndices; + + //CEMeasured + CEMeasuredData cEMeasured = aParser->getAllCEMeasuredData(); + double* ceMeasuredData; + size_t cEMeasuredDims[2]; + if(cEMeasured.isNull()) + { + CEPointer ce = aParser->getCEData().getCE(); + ceMeasuredData = new double[ce.getLength() * RECEIVE_ELEMENT_COUNT]; + for(size_t i=0; igetCEData(); + double ceOffSet = ceData.getCEOffset(); + size_t ceOffSetDims[2] ={1,1}; + matvar_t* ceOffSetVar = Mat_VarCreate("CEOffset",MAT_C_DOUBLE,MAT_T_DOUBLE,2,ceOffSetDims,&ceOffSet,0); + + //CE_SF + double ceSF = ceData.getCE_SF(); + size_t ceSFDims[2] ={1,1}; + matvar_t* ceSFVar = Mat_VarCreate("CE_SF",MAT_C_DOUBLE,MAT_T_DOUBLE,2,ceSFDims,&ceSF,0); + + Mat_VarWrite(matfp,measurementIDVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,receiverIndicesVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,tasIndicesVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,cEMeasuredVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,ceOffSetVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,ceSFVar,MAT_COMPRESSION_NONE); + + Mat_VarFree(measurementIDVar); + Mat_VarFree(receiverIndicesVar); + Mat_VarFree(tasIndicesVar); + Mat_VarFree(cEMeasuredVar); + Mat_VarFree(ceOffSetVar); + Mat_VarFree(ceSFVar); + Mat_Close(matfp); +} + +void MatlabCreatorConvertFp16Private::createJumoTempMat(std::shared_ptr aParser, const std::string& aDirectoryPath) +{ + DirHelper dir; + if(!dir.exists(aDirectoryPath)) + { + return; + } + mat_t* matfp = nullptr; + std::string jumoTempMatFileName = aDirectoryPath + SLASH_CHAR + "JumoTemp.mat"; + matfp = Mat_CreateVer(jumoTempMatFileName.c_str(),nullptr,MAT_FT_DEFAULT); + if (matfp == nullptr) + { + return; + } + + //JumoTemperature1 + TemperatureData temperatureData = aParser->getTemperatureData(); + JumoTemperaturePointer jumoTemperature1 = temperatureData.getJumoTemperature1(); + unsigned long long jumoLength = jumoTemperature1.getLength(); + double* writeData = new double[jumoLength]; + std::copy(jumoTemperature1.get(), jumoTemperature1.get() + jumoLength, writeData); + size_t jumoTemperature1Dims[2] ={1,jumoTemperature1.getLength()}; + matvar_t* jumoTemperature1Var = Mat_VarCreate("JumoTemperature1",MAT_C_DOUBLE,MAT_T_DOUBLE,2,jumoTemperature1Dims,writeData,0); + delete[] writeData; + + //JumoTemperature2 + JumoTemperaturePointer jumoTemperature2 = temperatureData.getJumoTemperature2(); + jumoLength = jumoTemperature2.getLength(); + writeData = new double[jumoLength]; + std::copy(jumoTemperature2.get(), jumoTemperature2.get() + jumoLength, writeData); + size_t jumoTemperature2Dims[2] ={1,jumoTemperature2.getLength()}; + matvar_t* jumoTemperature2Var = Mat_VarCreate("JumoTemperature2",MAT_C_DOUBLE,MAT_T_DOUBLE,2,jumoTemperature2Dims,writeData,0); + delete[] writeData; + + //JumoTemperature3 + JumoTemperaturePointer jumoTemperature3 = temperatureData.getJumoTemperature3(); + jumoLength = jumoTemperature3.getLength(); + writeData = new double[jumoLength]; + std::copy(jumoTemperature3.get(), jumoTemperature3.get() + jumoLength, writeData); + size_t jumoTemperature3Dims[2] ={1,jumoTemperature3.getLength()}; + matvar_t* jumoTemperature3Var = Mat_VarCreate("JumoTemperature3",MAT_C_DOUBLE,MAT_T_DOUBLE,2,jumoTemperature3Dims,writeData,0); + delete[] writeData; + + //JumoTemperature4 + JumoTemperaturePointer jumoTemperature4 = temperatureData.getJumoTemperature4(); + jumoLength = jumoTemperature4.getLength(); + writeData = new double[jumoLength]; + std::copy(jumoTemperature4.get(), jumoTemperature4.get() + jumoLength, writeData); + size_t jumoTemperature4Dims[2] ={1,jumoTemperature4.getLength()}; + matvar_t* jumoTemperature4Var = Mat_VarCreate("JumoTemperature4",MAT_C_DOUBLE,MAT_T_DOUBLE,2,jumoTemperature4Dims,writeData,0); + delete[] writeData; + + //TimeStamps +// MetaData metaData = aParser->getMetaData(); +// TimeStampsPointer timeStamps = metaData.getTimeStamps(); +// size_t timeStampsDims[2] ={1,timeStamps.getLength()}; +// matvar_t* timeStampsVar = Mat_VarCreate("TimeStamps",MAT_C_DOUBLE,MAT_T_DOUBLE,2,timeStampsDims,timeStamps.getArray().get(),0); + + //MeasurementID + MetaData metaData = aParser->getMetaData(); + std::string measurementID = metaData.getMeasurementID(); + size_t measurementIDDims[2] ={1,measurementID.size()}; + matvar_t* measurementIDVar = Mat_VarCreate("MeasurementID",MAT_C_CHAR,MAT_T_INT8,2,measurementIDDims,const_cast(measurementID.c_str()),0); + + Mat_VarWrite(matfp,jumoTemperature1Var,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,jumoTemperature2Var,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,jumoTemperature3Var,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,jumoTemperature4Var,MAT_COMPRESSION_NONE); +// Mat_VarWrite(matfp,timeStampsVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,measurementIDVar,MAT_COMPRESSION_NONE); + + Mat_VarFree(jumoTemperature1Var); + Mat_VarFree(jumoTemperature2Var); + Mat_VarFree(jumoTemperature3Var); + Mat_VarFree(jumoTemperature4Var); +// Mat_VarFree(timeStampsVar); + Mat_VarFree(measurementIDVar); + Mat_Close(matfp); +} + +void MatlabCreatorConvertFp16Private::createTasTempMat(std::shared_ptr aParser, const std::string& aDirectoryPath) +{ + DirHelper dir; + if(!dir.exists(aDirectoryPath)) + { + return; + } + mat_t* matfp = nullptr; + std::string tasTempMatFileName = aDirectoryPath + SLASH_CHAR + "TASTemp.mat"; + matfp = Mat_CreateVer(tasTempMatFileName.c_str(),nullptr,MAT_FT_DEFAULT); + if (matfp == nullptr) + { + return; + } + //TASTemperature + TemperatureData temperatureData = aParser->getTemperatureData(); + std::vector temperature = temperatureData.getTasTemperature(); + if(temperature.size() == 0) + { + Mat_Close(matfp); + return; + } + size_t tasTemperatureDims[3]{2,temperatureData.getUsedTasNum(),temperatureData.getAperaturePosition()}; + unsigned long long temperatureLength = temperature.size() * temperature.at(0).getLength(); + double* writeData = new double[temperatureLength]; + double* tempData = writeData; + for(unsigned int i=0;i> temperatureRawData = temperatureData.getTasTemperatureRawdata(); + if(temperature.size() == 0) + { + Mat_Close(matfp); + return; + } + size_t tasTemperatureRawDataDims[4]{2,temperatureRawData.at(0).at(0).getLength()/2,temperatureRawData.at(0).size(),temperatureRawData.size()}; + unsigned long long tempRawDataLength = temperatureRawData.size() * temperatureRawData.at(0).size() * temperatureRawData.at(0).at(0).getLength(); + writeData = new double[tempRawDataLength]; + tempData = writeData; + for(unsigned int i=0;i aParser, const std::string& aDirectoryPath) +{ + DirHelper dir; + if(!dir.exists(aDirectoryPath)) + { + return; + } + mat_t* matfp = nullptr; + std::string tasTempMatFileName = aDirectoryPath + SLASH_CHAR + "TASTempComp.mat"; + matfp = Mat_CreateVer(tasTempMatFileName.c_str(),nullptr,MAT_FT_DEFAULT); + if (matfp == nullptr) + { + return; + } + //TASTemperatureComp + TemperatureData temperatureData = aParser->getTemperatureData(); + std::vector temperatureComp = temperatureData.getTasTemperatureComp(); + if(temperatureComp.size() == 0) + { + Mat_Close(matfp); + return; + } + size_t* tasTemperatureCompDims = new size_t[3]{2,temperatureData.getUsedTasNum(),temperatureData.getAperaturePosition()}; + unsigned long long temperatureCompLength = temperatureComp.size() * temperatureComp.at(0).getLength(); + double* writeData = new double[temperatureCompLength]; + double* tempData = writeData; + for(unsigned int i=0;i aParser, const std::string& aDirectoryPath) +{ + DirHelper dir; + if(!dir.exists(aDirectoryPath)) + { + return; + } + + std::vector rotationMatrixs = aParser->getMovementData().getRotationMatrix(); + for(unsigned int i=0;igetMetaData().getMeasurementID(); + size_t measurementIDDims[2] ={1,measurementID.size()}; + matvar_t* measurementIDVar = Mat_VarCreate("MeasurementID",MAT_C_CHAR,MAT_T_INT8,2,measurementIDDims,const_cast(measurementID.c_str()),0); + + Mat_VarWrite(matfp,rotationMatrixVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,measurementIDVar,MAT_COMPRESSION_NONE); + Mat_VarFree(rotationMatrixVar); + Mat_VarFree(measurementIDVar); + Mat_Close(matfp); + } +} + +void MatlabCreatorConvertFp16Private::createMovementsMat(std::shared_ptr aParser, const std::string& aDirectoryPath) +{ + DirHelper dir; + if(!dir.exists(aDirectoryPath)) + { + return; + } + + mat_t* matfp = nullptr; + std::string movementsMatFileName = aDirectoryPath + SLASH_CHAR + "Movements.mat"; + matfp = Mat_CreateVer(movementsMatFileName.c_str(),nullptr,MAT_FT_DEFAULT); + if (matfp == nullptr) + { + return; + } + + MetaData metaData = aParser->getMetaData(); + //MovementsListreal + MovementsListRealPointer movementsListReal = aParser->getMovementData().getMovementsListReal(); + unsigned long long movementsListRealLength = movementsListReal.getLength(); + unsigned short aperturePositionNum = metaData.getAperturePositionNumber(); + size_t movementsListRealDims[2] ={aperturePositionNum,2}; //2 means heigh and rotation; + double* writeData = new double[movementsListRealLength]; + std::copy(movementsListReal.get(),movementsListReal.get()+movementsListRealLength,writeData); + matvar_t* movementsListRealVar = Mat_VarCreate("MovementsListreal",MAT_C_DOUBLE,MAT_T_DOUBLE,2,movementsListRealDims,writeData,0); + delete[] writeData; + + //TimeStamps + TimeStampsPointer timeStamps = metaData.getTimeStamps(); + size_t timeStampsDims[2] ={1,timeStamps.getLength()}; + matvar_t* timeStampsVar = Mat_VarCreate("TimeStamps",MAT_C_DOUBLE,MAT_T_DOUBLE,2,timeStampsDims,timeStamps.get(),0); + + //MeasurementID + std::string measurementID = metaData.getMeasurementID(); + size_t measurementIDDims[2] ={1,measurementID.size()}; + matvar_t* measurementIDVar = Mat_VarCreate("MeasurementID",MAT_C_CHAR,MAT_T_INT8,2,measurementIDDims,const_cast(measurementID.c_str()),0); + + Mat_VarWrite(matfp,movementsListRealVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,timeStampsVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,measurementIDVar,MAT_COMPRESSION_NONE); + Mat_VarFree(movementsListRealVar); + Mat_VarFree(timeStampsVar); + Mat_VarFree(measurementIDVar); + Mat_Close(matfp); +} + +void MatlabCreatorConvertFp16Private::createPatDataMat(std::shared_ptr aParser, const std::string& aDirectoryPath) +{ + DirHelper dir; + if(!dir.exists(aDirectoryPath)) + { + return; + } + + mat_t* matfp = nullptr; + std::string movementsMatFileName = aDirectoryPath + SLASH_CHAR + "patData.mat"; + matfp = Mat_CreateVer(movementsMatFileName.c_str(),nullptr,MAT_FT_DEFAULT); + if (matfp == nullptr) + { + return; + } + + PatientData patientData = aParser->getPatientData(); + //InstitutionAddress + std::string institutionAddress = patientData.getInstituationAddress(); + size_t institutionAddressDims[2] ={1,institutionAddress.size()}; + matvar_t* institutionAddressVar = Mat_VarCreate("InstitutionAddress",MAT_C_CHAR,MAT_T_INT8,2,institutionAddressDims,const_cast(institutionAddress.c_str()),0); + + //InstitutionName + std::string institutionName = patientData.getInstituationName(); + size_t institutionNameDims[2] ={1,institutionName.size()}; + matvar_t* institutionNameVar = Mat_VarCreate("InstitutionName",MAT_C_CHAR,MAT_T_INT8,2,institutionNameDims,const_cast(institutionName.c_str()),0); + + //IsEmptyData + double isEmptyData = patientData.getIsEmptyData(); + size_t isEmptyDataDims[2] ={1,1}; + matvar_t* isEmptyDataVar = Mat_VarCreate("IsEmptyData",MAT_C_DOUBLE,MAT_T_DOUBLE,2,isEmptyDataDims,&isEmptyData,0); + + //Laterality + std::string laterality = patientData.getLaterality(); + size_t lateralityDims[2] ={1,laterality.size()}; + matvar_t* lateralityVar = Mat_VarCreate("Laterality",MAT_C_CHAR,MAT_T_INT8,2,lateralityDims,const_cast(laterality.c_str()),0); + + //MeasurementID + std::string measurementID = aParser->getMetaData().getMeasurementID(); + size_t measurementIDDims[2] ={1,measurementID.size()}; + matvar_t* measurementIDVar = Mat_VarCreate("MeasurementID",MAT_C_CHAR,MAT_T_INT8,2,measurementIDDims,const_cast(measurementID.c_str()),0); + + //OperatorName + std::string operatorName = patientData.getOperatorName(); + size_t operatorNameDims[2] ={1,operatorName.size()}; + matvar_t* operatorNameVar = Mat_VarCreate("OperatorName",MAT_C_CHAR,MAT_T_INT8,2,operatorNameDims,const_cast(operatorName.c_str()),0); + + //PatientBirthDate + std::string patientBirthDate = patientData.getPatientBirthDate(); + size_t patientBirthDateDims[2] ={1,patientBirthDate.size()}; + matvar_t* patientBirthDateVar = Mat_VarCreate("PatientBirthDate",MAT_C_CHAR,MAT_T_INT8,2,patientBirthDateDims,const_cast(patientBirthDate.c_str()),0); + + //PatientID + std::string patientID = patientData.getPatientID(); + size_t patientIDDims[2] ={1,patientID.size()}; + matvar_t* patientIDVar = Mat_VarCreate("PatientID",MAT_C_CHAR,MAT_T_INT8,2,patientIDDims,const_cast(patientID.c_str()),0); + + //PatientName + std::string patientName = patientData.getPatientName(); + size_t patientNameDims[2] ={1,patientName.size()}; + matvar_t* patientNameVar = Mat_VarCreate("PatientName",MAT_C_CHAR,MAT_T_INT8,2,patientNameDims,const_cast(patientName.c_str()),0); + + //PatientSex + std::string patientSex = patientData.getPatientName(); + size_t patientSexDims[2] ={1,patientSex.size()}; + matvar_t* patientSexVar = Mat_VarCreate("PatientSex",MAT_C_CHAR,MAT_T_INT8,2,patientSexDims,const_cast(patientSex.c_str()),0); + + //ReferringPhysicianName + std::string referringPhysicianName = patientData.getReferringPhysicianName(); + size_t referringPhysicianNameDims[2] ={1,referringPhysicianName.size()}; + matvar_t* referringPhysicianNameVar = Mat_VarCreate("ReferringPhysicianName",MAT_C_CHAR,MAT_T_INT8,2,referringPhysicianNameDims,const_cast(referringPhysicianName.c_str()),0); + + Mat_VarWrite(matfp,institutionAddressVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,institutionNameVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,isEmptyDataVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,lateralityVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,measurementIDVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,operatorNameVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,patientBirthDateVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,patientIDVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,patientNameVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,patientSexVar,MAT_COMPRESSION_NONE); + Mat_VarWrite(matfp,referringPhysicianNameVar,MAT_COMPRESSION_NONE); + + Mat_VarFree(institutionAddressVar); + Mat_VarFree(institutionNameVar); + Mat_VarFree(isEmptyDataVar); + Mat_VarFree(lateralityVar); + Mat_VarFree(measurementIDVar); + Mat_VarFree(operatorNameVar); + Mat_VarFree(patientBirthDateVar); + Mat_VarFree(patientIDVar); + Mat_VarFree(patientNameVar); + Mat_VarFree(patientSexVar); + Mat_VarFree(referringPhysicianNameVar); + Mat_Close(matfp); +} diff --git a/src/MatLab/MatlabCreatorConvertFp16Private.h b/src/MatLab/MatlabCreatorConvertFp16Private.h new file mode 100644 index 0000000..d1e5663 --- /dev/null +++ b/src/MatLab/MatlabCreatorConvertFp16Private.h @@ -0,0 +1,42 @@ +#ifndef MATLABCREATORCONVERTFP16PRIVATE_H +#define MATLABCREATORCONVERTFP16PRIVATE_H + + +#include +#include +#include + +class OneTasAScanData; +class Parser; +class ShotList; +enum class MotorPosition:unsigned short; + +class MatlabCreatorConvertFp16Private +{ +public: + MatlabCreatorConvertFp16Private(const std::string& aDirectoryPath); + void setDirectoryPath(const std::string& aDirectoryPath); + bool createKITMat(const std::string& aOutputPath); + +private: + void getAScanOfMPAndAmplification(std::shared_ptr aParser,ShotList* aShotList,OneTasAScanData aOneTasAScanData,std::shared_ptr aAScanData,std::shared_ptr aAmplificationData,unsigned short aGeometryElement,MotorPosition aMotorPosition); + void getAScanOfCEAndAmplification(std::shared_ptr aParser,ShotList* aShotList,OneTasAScanData aOneTasAScanData,std::shared_ptr aAScanData,std::shared_ptr aAmplificationData); + void createEmitterMat(std::shared_ptr aParser, const std::string& aFileName,std::shared_ptr aAScanData,std::shared_ptr aAmplificationData); + void createKITMatInThread(std::shared_ptr aParser,unsigned short aStartTasNum,unsigned short aTasCount, const std::string& aOutputPath); + void createCEMat(std::shared_ptr aParser, const std::string& aDirectoryPath); + void createInfoMat(std::shared_ptr aParser, const std::string& aDirectoryPath); + void createCEMeasuredMat(std::shared_ptr aParser, const std::string& aDirectoryPath); + void createJumoTempMat(std::shared_ptr aParser, const std::string& aDirectoryPath); + void createTasTempMat(std::shared_ptr aParser, const std::string& aDirectoryPath); + void createTasTemCompMat(std::shared_ptr aParser, const std::string& aDirectoryPath); + void createMeasurementRotationMat(std::shared_ptr aParser, const std::string& aDirectoryPath); + void createMovementsMat(std::shared_ptr aParser, const std::string& aDirectoryPath); + void createPatDataMat(std::shared_ptr aParser, const std::string& aDirectoryPath); + void producerThreadFunction(std::shared_ptr aParser, unsigned short aStartTasNum,unsigned short aTasCount, const std::string& aOutputPath); + +private: + std::string mDirectoryPath; + std::vector mFileList; +}; + +#endif // MATLABCREATORCONVERTFP16PRIVATE_H