#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 <queue>
#include <thread>
#include <iostream>
#include <condition_variable>

struct CreateMatSturct
{
    std::shared_ptr<Parser> mParser;
    std::string mFileName;
    std::shared_ptr<short> mAScanData;
    std::shared_ptr<double> mAmplificationData;
};

namespace
{
    double progress = 0;

    std::queue<CreateMatSturct> PRODUCER_DATAS;
    std::mutex PRODUCER_MUTEX;
    std::condition_variable PRODUCER_CONDITION;

    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(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(&MatlabCreatorPrivate::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 MatlabCreatorPrivate::createKITMatInThread(std::shared_ptr<Parser> aParser, unsigned short aStartTasNum,unsigned short aTasCount, const std::string& aOutputPath)
{
    std::thread producerThread = std::thread(&MatlabCreatorPrivate::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<short> 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<short> 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 MatlabCreatorPrivate::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<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);
                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<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);
            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 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.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_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];
            std::copy(ascan.get(), ascan.get() + aParser->getDataLength(), aAScanData.get() + (muxIndex*TOTAL_CHANNEL+i)*aParser->getDataLength());
            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];
            std::copy(ascan.get(), ascan.get() + aParser->getDataLength(), aAScanData.get() + (muxIndex*TOTAL_CHANNEL+i)*aParser->getDataLength());
            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.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[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 = 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);
    //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 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.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();
    short* ceMeasuredData;
    size_t cEMeasuredDims[2];
    if(cEMeasured.isNull())
    {
        CEPointer ce = aParser->getCEData().getCE();
        ceMeasuredData = new short[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 = cEMeasured.get();
        cEMeasuredDims[0] = cEMeasured.getAscanDataLength();
        cEMeasuredDims[1] = cEMeasured.getSize();
    }
    matvar_t* cEMeasuredVar =  Mat_VarCreate("CEMeasured",MAT_C_INT16,MAT_T_INT16,2,cEMeasuredDims,ceMeasuredData,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.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 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).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 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).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 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.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 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,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 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);
}