Parser Upload.

2023-03-27 17:35:44 +08:00
commit bd3bd664e7
93 changed files with 42141 additions and 0 deletions
--- a/src/MatLab/MatlabCreatorPrivate.cpp
+++ b/src/MatLab/MatlabCreatorPrivate.cpp
@@ -0,0 +1,840 @@
+#include "MatlabCreatorPrivate.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 <thread>
+#include <iostream>
+
+
+namespace
+{
+    double progress = 0;
+
+    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";
+        }
+    }
+}
+
+MatlabCreatorPrivate::MatlabCreatorPrivate(const std::string& aDirectoryPath)
+    : mDirectoryPath(FileListHelper::fixPathSlash(aDirectoryPath))
+    , mFileList(FileListHelper::getFileList(mDirectoryPath))
+{
+    DirHelper::checkPathSlash(mDirectoryPath);
+}
+
+void MatlabCreatorPrivate::setDirectoryPath(const std::string& aDirectoryPath)
+{
+    mDirectoryPath = FileListHelper::fixPathSlash(aDirectoryPath);
+    DirHelper::checkPathSlash(mDirectoryPath);
+    mFileList = FileListHelper::getFileList(mDirectoryPath);
+}
+
+bool MatlabCreatorPrivate::createKITMat()
+{
+    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 = mDirectoryPath + "_mat";
+    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(&MatlabCreatorPrivate::createKITMatInThread, this, parser->clone(), tasNum, tasOffSet));
+//        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 MatlabCreatorPrivate::createKITMatInThread(std::shared_ptr<Parser> aParser, unsigned short aStartTasNum,unsigned short aTasCount)
+{
+    std::string dirPath = mDirectoryPath + "_mat";
+    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<short> ascanData = std::shared_ptr<short>(new short[aParser->getDataLength()*RECEIVE_ELEMENT_COUNT],std::default_delete<short[]>());
+                std::shared_ptr<double> amplificationData = std::shared_ptr<double>(new double[aParser->getDataLength()*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);
+                createEmitterMat(aParser,fileName,ascanData,amplificationData);
+            }
+        }
+        //CEMeasure
+        std::string cemeasureFolder = tasFloder + SLASH_CHAR + getCEMeasureFolderName();
+        if(!dir.exists(cemeasureFolder))
+        {
+            dir.mkdir(cemeasureFolder);
+        }
+        oneTasAscan = aParser->getOneTasAscanDataOfCEMeasured(shotList->getTasValue(t));
+        std::shared_ptr<short> ascanData = std::shared_ptr<short>(new short[aParser->getDataLength()*RECEIVE_ELEMENT_COUNT],std::default_delete<short[]>());
+        std::shared_ptr<double> amplificationData = std::shared_ptr<double>(new double[aParser->getDataLength()*RECEIVE_ELEMENT_COUNT],std::default_delete<double[]>());
+        getAScanOfCEAndAmplification(aParser,shotList,oneTasAscan,ascanData,amplificationData);
+        std::string fileName = cemeasureFolder + SLASH_CHAR + getMatFileName(0);
+        createEmitterMat(aParser,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;
+    }
+}
+
+void MatlabCreatorPrivate::createEmitterMat(std::shared_ptr<Parser> aParser,const std::string& aFileName,std::shared_ptr<short> 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.getArray().get(),receiverIndicesPointer.getArray().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.getArray().get(),tasIndicesPointer.getArray().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_INT16,MAT_T_INT16,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 MatlabCreatorPrivate::getAScanOfCEAndAmplification(std::shared_ptr<Parser> aParser,ShotList* aShotList,OneTasAScanData aOneTasAScanData,std::shared_ptr<short> 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))));
+            aAmplificationData.get()[muxIndex*TOTAL_CHANNEL+i] = ascan.getAmplification()[0];
+            for(unsigned short j=0;j<aParser->getDataLength();++j)
+            {
+                aAScanData.get()[(muxIndex*TOTAL_CHANNEL+i)*aParser->getDataLength()+j] = ascan.get()[j];
+            }
+            index+=9;
+        }
+    }
+}
+
+void MatlabCreatorPrivate::getAScanOfMPAndAmplification(std::shared_ptr<Parser> aParser,ShotList* aShotList,OneTasAScanData aOneTasAScanData,std::shared_ptr<short> 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);
+            aAmplificationData.get()[muxIndex*TOTAL_CHANNEL+i] = ascan.getAmplification()[0];
+            for(unsigned short j=0;j<aParser->getDataLength();++j)
+            {
+                aAScanData.get()[(muxIndex*TOTAL_CHANNEL+i)*aParser->getDataLength()+j] = ascan.get()[j];
+            }
+            index+=9;
+        }
+    }
+}
+
+void MatlabCreatorPrivate::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.getArray().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 MatlabCreatorPrivate::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[5] = {"shotlist","samplenumber","SampleRate","Datatype","MeasurementID"};
+    matvar_t* structVar = Mat_VarCreateStruct("MetaData",1,structDims,field,5);
+    //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.getArray().get(),0);
+    Mat_VarSetStructFieldByName(structVar, "shotlist", 0, shotListVar);
+    //SampleNumber
+    MetaData metaData = aParser->getMetaData();
+    double smpleNumber = metaData.getSampleNumber();
+    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);
+    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 MatlabCreatorPrivate::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.getArray().get(), receiverIndices.getArray().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.getArray().get(), tasIndices.getArray().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();
+    size_t cEMeasuredDims[2] ={cEMeasured.getAscanDataLength(),cEMeasured.getSize()};
+    matvar_t* cEMeasuredVar =  Mat_VarCreate("CEMeasured",MAT_C_INT16,MAT_T_INT16,2,cEMeasuredDims,cEMeasured.get(),0);
+
+    //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 MatlabCreatorPrivate::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.getArray().get(), jumoTemperature1.getArray().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.getArray().get(), jumoTemperature2.getArray().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.getArray().get(), jumoTemperature3.getArray().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.getArray().get(), jumoTemperature4.getArray().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 MatlabCreatorPrivate::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).getArray().get(), temperature.at(i).getArray().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).getArray().get(), temperatureRawData.at(i).at(j).getArray().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 MatlabCreatorPrivate::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).getArray().get(), temperatureComp.at(i).getArray().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 MatlabCreatorPrivate::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.getArray().get(),rotationMatrix.getArray().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 MatlabCreatorPrivate::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,aperturePositionNum};
+    double* writeData = new double[movementsListRealLength];
+    std::copy(movementsListReal.getArray().get(),movementsListReal.getArray().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.getArray().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 MatlabCreatorPrivate::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);
+}