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

Add convertFp16 mode.

Browse Source
This commit is contained in:
sunwen
2024-04-03 16:36:51 +08:00
parent 2d2d1a993b
commit aab3b1c87c
4 changed files with 1019 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/MatLab/MatlabCreator.cpp
View File

@@ -2,10 +2,12 @@
#include "MatlabCreatorPrivate.h" #include "MatlabCreatorPrivate.h"
#include "MatlabCreatorVariableWindowPrivate.h" #include "MatlabCreatorVariableWindowPrivate.h"
#include "MatlabCreatorConvertFp16Private.h"
MatlabCreator::MatlabCreator(const std::string& aDirectoryPath) MatlabCreator::MatlabCreator(const std::string& aDirectoryPath)
: mPrivate(new MatlabCreatorPrivate(aDirectoryPath)) : mPrivate(new MatlabCreatorPrivate(aDirectoryPath))
, mVariableWindowPrivate(new MatlabCreatorVariableWindowPrivate(aDirectoryPath)) , mVariableWindowPrivate(new MatlabCreatorVariableWindowPrivate(aDirectoryPath))
, mConvertFp16Private(new MatlabCreatorConvertFp16Private(aDirectoryPath))
{ {
} }
@@ -24,5 +26,10 @@ bool MatlabCreator::createKITVariableWindowMat(const std::string& aOutputPath)
return mVariableWindowPrivate->createKITMat(aOutputPath); return mVariableWindowPrivate->createKITMat(aOutputPath);
} }
bool MatlabCreator::createKITConvertFp16Mat(const std::string& aOutputPath)
{
return mConvertFp16Private->createKITMat(aOutputPath);
}

3
src/MatLab/MatlabCreator.h
View File

@@ -7,6 +7,7 @@
class MatlabCreatorPrivate; class MatlabCreatorPrivate;
class MatlabCreatorVariableWindowPrivate; class MatlabCreatorVariableWindowPrivate;
class MatlabCreatorConvertFp16Private;
class PARSERSHARED_EXPORT MatlabCreator class PARSERSHARED_EXPORT MatlabCreator
{ {
@@ -15,6 +16,7 @@ public:
void setDirectoryPath(const std::string& aDirectoryPath); void setDirectoryPath(const std::string& aDirectoryPath);
bool createKITMat(const std::string& aOutputPath); bool createKITMat(const std::string& aOutputPath);
bool createKITVariableWindowMat(const std::string& aOutputPath); bool createKITVariableWindowMat(const std::string& aOutputPath);
bool createKITConvertFp16Mat(const std::string& aOutputPath);
MatlabCreator(const MatlabCreator& aMatlabCreator) = delete; MatlabCreator(const MatlabCreator& aMatlabCreator) = delete;
MatlabCreator& operator=(const MatlabCreator& aMatlabCreator) = delete; MatlabCreator& operator=(const MatlabCreator& aMatlabCreator) = delete;
@@ -22,6 +24,7 @@ public:
private: private:
MatlabCreatorPrivate* mPrivate; MatlabCreatorPrivate* mPrivate;
MatlabCreatorVariableWindowPrivate* mVariableWindowPrivate; MatlabCreatorVariableWindowPrivate* mVariableWindowPrivate;
MatlabCreatorConvertFp16Private* mConvertFp16Private;
}; };

967
src/MatLab/MatlabCreatorConvertFp16Private.cpp Normal file
View File

@@ -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 <vector>
#include <queue>
#include <thread>
#include <iostream>
#include <condition_variable>
#include <fstream>
#include <algorithm>
#include <string.h>
#include <cmath>
namespace
{
struct CreateMatSturct
{
std::shared_ptr<Parser> mParser;
std::string mFileName;
std::shared_ptr<double> mAScanData;
std::shared_ptr<double> mAmplificationData;
};
double progress = 0;
std::queue<CreateMatSturct> 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> parser(new Parser(mDirectoryPath));
std::shared_ptr<ShotList> shotList = parser->getShotList();
if(!shotList->isValid())
{
return false;
}
unsigned int fileCount = static_cast<unsigned int>(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<std::shared_ptr<std::thread>> threads(static_cast<size_t>(threadCount));
std::string dirPath = aOutputPath;
DirHelper dir;
if(!dir.exists(dirPath))
{
dir.mkdir(dirPath);
}
for(unsigned int i=0;i<threadCount;++i)
{
if(i == threadRemainder && threadRemainder!=0)
{
--tasOffSet;
}
threads[i] = std::shared_ptr<std::thread>(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<<std::endl;
return true;
}
void MatlabCreatorConvertFp16Private::createKITMatInThread(std::shared_ptr<Parser> 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;t<aStartTasNum+aTasCount;++t)
{
//Motorposition
for(unsigned short m=0;m<shotList->getMotorPositionSize();++m)
{
for(unsigned short e=0;e<shotList->getElementSize();++e)
{
std::unique_lock<std::mutex> lock(PRODUCER_MUTEX);
PRODUCER_CONDITION.wait(lock, []{return !PRODUCER_DATAS.empty();});
std::shared_ptr<Parser> parser = PRODUCER_DATAS.front().mParser;
std::string fileName = PRODUCER_DATAS.front().mFileName;
std::shared_ptr<double> ascanData = PRODUCER_DATAS.front().mAScanData;
std::shared_ptr<double> amplificationData = PRODUCER_DATAS.front().mAmplificationData;
PRODUCER_DATAS.pop();
lock.unlock();
createEmitterMat(parser,fileName,ascanData,amplificationData);
}
}
//CEMeasure
if(shotList->hasCEMeasured())
{
std::unique_lock<std::mutex> lock(PRODUCER_MUTEX);
PRODUCER_CONDITION.wait(lock, []{return !PRODUCER_DATAS.empty();});
std::shared_ptr<Parser> parser = PRODUCER_DATAS.front().mParser;
std::string fileName = PRODUCER_DATAS.front().mFileName;
std::shared_ptr<double> ascanData = PRODUCER_DATAS.front().mAScanData;
std::shared_ptr<double> amplificationData = PRODUCER_DATAS.front().mAmplificationData;
PRODUCER_DATAS.pop();
lock.unlock();
createEmitterMat(parser,fileName,ascanData,amplificationData);
}
++progress;
std::cout<<"\r\033[K"<<std::flush;
std::cout<< "progress: \033[41m\033[1m " + std::to_string(progress/1.28) + "%\033[0m" <<std::flush;
}
producerThread.join();
}
void MatlabCreatorConvertFp16Private::producerThreadFunction(std::shared_ptr<Parser> 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;t<aStartTasNum+aTasCount;++t)
{
std::string tasFloder = dirPath + SLASH_CHAR + getTasFolderName(shotList->getTasValue(t));
if(!dir.exists(tasFloder))
{
dir.mkdir(tasFloder);
}
OneTasAScanData oneTasAscan = aParser->getOneTasAscanDataOfMotorPosition(shotList->getTasValue(t));
//Motorposition
for(unsigned short m=0;m<shotList->getMotorPositionSize();++m)
{
std::string motorpositionFolder = tasFloder + SLASH_CHAR + getMotorPositionFolderName(shotList->getMotorPositionValue(m));
if(!dir.exists(motorpositionFolder))
{
dir.mkdir(motorpositionFolder);
}
for(unsigned short e=0;e<shotList->getElementSize();++e)
{
unsigned short element = shotList->getElementValue(e);
std::shared_ptr<double> ascanData = std::shared_ptr<double>(new double[aParser->getDataLength() * RECEIVE_ELEMENT_COUNT],std::default_delete<double[]>());
memset(ascanData.get(), 0, sizeof(double) * aParser->getDataLength() * RECEIVE_ELEMENT_COUNT);
std::shared_ptr<double> amplificationData = std::shared_ptr<double>(new double[RECEIVE_ELEMENT_COUNT],std::default_delete<double[]>());
getAScanOfMPAndAmplification(aParser,shotList,oneTasAscan,ascanData,amplificationData,element,MotorPosition(shotList->getMotorPositionValue(m)));
std::string fileName = motorpositionFolder + SLASH_CHAR + getMatFileName(element);
std::unique_lock<std::mutex> 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<double> ascanData = std::shared_ptr<double>(new double[aParser->getDataLength() * RECEIVE_ELEMENT_COUNT],std::default_delete<double[]>());
memset(ascanData.get(), 0, sizeof(double) * aParser->getDataLength() * RECEIVE_ELEMENT_COUNT);
std::shared_ptr<double> amplificationData = std::shared_ptr<double>(new double[RECEIVE_ELEMENT_COUNT],std::default_delete<double[]>());
getAScanOfCEAndAmplification(aParser,shotList,oneTasAscan,ascanData,amplificationData);
std::string fileName = cemeasureFolder + SLASH_CHAR + getMatFileName(0);
std::unique_lock<std::mutex> 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<Parser> aParser,const std::string& aFileName,std::shared_ptr<double> aAScanData,std::shared_ptr<double> aAmplificationData)
{
std::shared_ptr<unsigned short> 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<char*>(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<Parser> aParser,ShotList* aShotList,OneTasAScanData aOneTasAScanData,std::shared_ptr<double> aAScanData,std::shared_ptr<double> aAmplificationData)
{
std::shared_ptr<unsigned short> mapperArrayPointer = MapperDataBase::getMapperArray();
for(unsigned int muxIndex = 0;muxIndex < aShotList->getMuxSize();++muxIndex)
{
unsigned int index = 0;
for(unsigned int i=0;i<TOTAL_CHANNEL;++i)
{
unsigned short receiveTas = mapperArrayPointer.get()[index + 2];
unsigned short receiveElement = mapperArrayPointer.get()[index + 2 + aShotList->getMuxValue(muxIndex)];
AScanData ascan = aParser->searchAscanDataFromOneTasAscanDataOfCE(aOneTasAScanData,TasElementIndex(TasIndex(receiveTas),ElementIndex(GeometryIndex(receiveElement))));
double* float16Ascan = new double[aParser->getDataLength()];
for(unsigned int j=0; j<aParser->getDataLength(); ++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<Parser> aParser,ShotList* aShotList,OneTasAScanData aOneTasAScanData,std::shared_ptr<double> aAScanData,std::shared_ptr<double> aAmplificationData,unsigned short aGeometryElement,MotorPosition aMotorPosition)
{
std::shared_ptr<unsigned short> mapperArrayPointer = MapperDataBase::getMapperArray();
for(unsigned int muxIndex = 0;muxIndex < aShotList->getMuxSize();++muxIndex)
{
unsigned int index = 0;
for(unsigned int i=0;i<TOTAL_CHANNEL;++i)
{
unsigned short receiveTas = mapperArrayPointer.get()[index + 2];
unsigned short receiveElement = mapperArrayPointer.get()[index + 2 + aShotList->getMuxValue(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; j<aParser->getDataLength(); ++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<Parser> 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<Parser> 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> 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<char*>(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<char*>(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<char*>(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<char*>(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<char*>(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<Parser> 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<char*>(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; i<RECEIVE_ELEMENT_COUNT; ++i)
{
std::copy(ce.get(), ce.get()+ce.getLength(), ceMeasuredData);
ceMeasuredData += RECEIVE_ELEMENT_COUNT;
}
cEMeasuredDims[0] = ce.getLength();
cEMeasuredDims[1] = RECEIVE_ELEMENT_COUNT;
}
else
{
ceMeasuredData = new double[cEMeasured.getAscanDataLength() * RECEIVE_ELEMENT_COUNT];
for(unsigned int i=0; i<cEMeasured.getAscanDataLength() * RECEIVE_ELEMENT_COUNT; ++i)
{
ceMeasuredData[i] = convertfp16tofloat(cEMeasured.get()[i]);
}
cEMeasuredDims[0] = cEMeasured.getAscanDataLength();
cEMeasuredDims[1] = RECEIVE_ELEMENT_COUNT;
}
matvar_t* cEMeasuredVar = Mat_VarCreate("CEMeasured",MAT_C_DOUBLE,MAT_T_DOUBLE,2,cEMeasuredDims,ceMeasuredData,0);
delete [] ceMeasuredData;
//CEOffset
CEData ceData = aParser->getCEData();
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<Parser> 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<char*>(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<Parser> 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<TasTemperaturePointer> 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<temperature.size();++i)
{
std::copy(temperature.at(i).get(), temperature.at(i).get() + temperature.at(i).getLength(), tempData);
tempData+=temperature.at(i).getLength();
}
matvar_t* tasTemperatureVar = Mat_VarCreate("TASTemperature",MAT_C_DOUBLE,MAT_T_DOUBLE,3,tasTemperatureDims,writeData,0);
Mat_VarWrite(matfp,tasTemperatureVar,MAT_COMPRESSION_NONE);
Mat_VarFree(tasTemperatureVar);
delete[] writeData;
//TASTemperatureRawdata
std::vector<std::vector<TasTemperaturePointer>> 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<temperatureRawData.size();++i)
{
for(unsigned int j=0;j<temperatureRawData.at(i).size();++j)
{
std::copy(temperatureRawData.at(i).at(j).get(), temperatureRawData.at(i).at(j).get() + temperatureRawData.at(i).at(j).getLength(), tempData);
tempData+=temperatureRawData.at(i).at(j).getLength();
}
}
matvar_t* tempRawDataVar = Mat_VarCreate("TASTemperatureRawdata",MAT_C_DOUBLE,MAT_T_DOUBLE,4,tasTemperatureRawDataDims,writeData,0);
Mat_VarWrite(matfp,tempRawDataVar,MAT_COMPRESSION_NONE);
Mat_VarFree(tempRawDataVar);
delete[] writeData;
Mat_Close(matfp);
}
void MatlabCreatorConvertFp16Private::createTasTemCompMat(std::shared_ptr<Parser> 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<TasTemperatureCompPointer> 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<temperatureComp.size();++i)
{
std::copy(temperatureComp.at(i).get(), temperatureComp.at(i).get() + temperatureComp.at(i).getLength(), tempData);
tempData+=temperatureComp.at(i).getLength();
}
matvar_t* tasTemperatureVar = Mat_VarCreate("TASTemperature",MAT_C_DOUBLE,MAT_T_DOUBLE,3,tasTemperatureCompDims,writeData,0);
delete[] writeData;
delete[] tasTemperatureCompDims;
Mat_VarWrite(matfp,tasTemperatureVar,MAT_COMPRESSION_NONE);
Mat_VarFree(tasTemperatureVar);
//TASTemperatureRawdata
Mat_Close(matfp);
}
void MatlabCreatorConvertFp16Private::createMeasurementRotationMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath)
{
DirHelper dir;
if(!dir.exists(aDirectoryPath))
{
return;
}
std::vector<RotationMatrixPointer> rotationMatrixs = aParser->getMovementData().getRotationMatrix();
for(unsigned int i=0;i<rotationMatrixs.size();++i)
{
mat_t* matfp = nullptr;
std::string measurementRotationFileName = std::string("measurementRotation0") + std::to_string(i+1) + std::string(".mat");
std::string ceMatFileName = aDirectoryPath + SLASH_CHAR + measurementRotationFileName;
matfp = Mat_CreateVer(ceMatFileName.c_str(),nullptr,MAT_FT_DEFAULT);
if (matfp == nullptr)
{
return;
}
//rotationMatrix
RotationMatrixPointer rotationMatrix = rotationMatrixs.at(i);
unsigned long long rotationMatrixLength = rotationMatrix.getLength();
size_t rotationMatrixDims[2] ={4,4};
double* writeData = new double[rotationMatrixLength];
std::copy(rotationMatrix.get(),rotationMatrix.get() + rotationMatrixLength,writeData);
matvar_t* rotationMatrixVar = Mat_VarCreate("rotationMatrix",MAT_C_DOUBLE,MAT_T_DOUBLE,2,rotationMatrixDims,writeData,0);
delete[] writeData;
//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<char*>(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<Parser> 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<char*>(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<Parser> 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<char*>(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<char*>(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<char*>(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<char*>(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<char*>(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<char*>(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<char*>(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<char*>(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<char*>(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<char*>(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);
}

42
src/MatLab/MatlabCreatorConvertFp16Private.h Normal file
View File

@@ -0,0 +1,42 @@
#ifndef MATLABCREATORCONVERTFP16PRIVATE_H
#define MATLABCREATORCONVERTFP16PRIVATE_H
#include <string>
#include <memory>
#include <vector>
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<Parser> aParser,ShotList* aShotList,OneTasAScanData aOneTasAScanData,std::shared_ptr<double> aAScanData,std::shared_ptr<double> aAmplificationData,unsigned short aGeometryElement,MotorPosition aMotorPosition);
void getAScanOfCEAndAmplification(std::shared_ptr<Parser> aParser,ShotList* aShotList,OneTasAScanData aOneTasAScanData,std::shared_ptr<double> aAScanData,std::shared_ptr<double> aAmplificationData);
void createEmitterMat(std::shared_ptr<Parser> aParser, const std::string& aFileName,std::shared_ptr<double> aAScanData,std::shared_ptr<double> aAmplificationData);
void createKITMatInThread(std::shared_ptr<Parser> aParser,unsigned short aStartTasNum,unsigned short aTasCount, const std::string& aOutputPath);
void createCEMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath);
void createInfoMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath);
void createCEMeasuredMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath);
void createJumoTempMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath);
void createTasTempMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath);
void createTasTemCompMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath);
void createMeasurementRotationMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath);
void createMovementsMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath);
void createPatDataMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath);
void producerThreadFunction(std::shared_ptr<Parser> aParser, unsigned short aStartTasNum,unsigned short aTasCount, const std::string& aOutputPath);
private:
std::string mDirectoryPath;
std::vector<std::string> mFileList;
};
#endif // MATLABCREATORCONVERTFP16PRIVATE_H