Parser/src/DataReader/PatientDataReader.cpp

#include "PatientDataReader.h"
#include "Helper/MatlabHelper.h"
#include "Data/ConfigHeader.h"
#include "Json/json.hpp"

#include <regex>
#include <matio.h>
#include <fstream>

namespace
{
    static std::string getPatientStringData(mat_t* aPatMat, const char* aFieldName)
    {
        matvar_t* matVar = Mat_VarRead(aPatMat,aFieldName);
        std::string result;
        if(matVar!=nullptr)
        {
            result = MatlabHelper::getMatlabString(matVar);
        }
        Mat_VarFree(matVar);
        return result;
    }
}

PatientDataReader::PatientDataReader()
{

}

PatientData PatientDataReader::getPatientDataFromKIT(const std::string& aFilePath)
{
    mat_t* patMat = Mat_Open(aFilePath.c_str(), MAT_ACC_RDONLY);
    PatientData result;
    if(patMat == nullptr)
    {
        return result;
    }
    //InstitutionAddress
    result.setInstituationAddress(getPatientStringData(patMat,"InstitutionAddress"));

    //InstitutionName
    result.setInstituationName(getPatientStringData(patMat,"InstitutionName"));

    //IsEmptyData
    matvar_t* isEmptyDataVar = Mat_VarRead(patMat,"IsEmptyData");
    if(isEmptyDataVar!=nullptr)
    {
        bool isEmptyData = static_cast<bool>(*reinterpret_cast<double*>(isEmptyDataVar->data));
        result.setIsEmptyData(isEmptyData);
    }
    Mat_VarFree(isEmptyDataVar);

    //Laterality
    result.setLaterality(getPatientStringData(patMat,"Laterality"));

    //OperatorName
    result.setOperatorName(getPatientStringData(patMat,"OperatorName"));

    //PatientBirthDate
    result.setPatientBirthDate(getPatientStringData(patMat,"PatientBirthDate"));

    //PatientID
    result.setPatientID(getPatientStringData(patMat,"PatientID"));

    //PatientName
    result.setPatientName(getPatientStringData(patMat,"PatientName"));

    //PatientSex
    result.setPatientSex(getPatientStringData(patMat,"PatientSex"));

    //ReferringPhysicianName
    result.setReferringPhysicianName(getPatientStringData(patMat,"ReferringPhysicianName"));

    Mat_Close(patMat);
    return result;
}

PatientData PatientDataReader::getPatientDataFromHJ(const std::string& aFilePath, ConfigHeader* aConfigHeader)
{
    PatientData result;
    std::ifstream stream;
    stream.open(aFilePath, std::ios_base::binary | std::ios::in);
    stream.seekg(aConfigHeader->getPatientPosition(),std::ios::beg);
    char* patientCString = new char[aConfigHeader->getPatientLength()];
    stream.read(patientCString,aConfigHeader->getPatientLength());
    std::string patientJsonString = patientCString;
    nlohmann::json jsonObj = nlohmann::json::parse(patientJsonString);
    if(!jsonObj.contains("Patient Info"))
    {
       return result;
    }
    nlohmann::json patientObj = jsonObj.at("Patient Info");
    if(patientObj.contains("PatientID"))
    {
        result.setPatientID(patientObj.at("PatientID").get<std::string>());
    }

    if(patientObj.contains("PatientName"))
    {
        result.setPatientName(patientObj.at("PatientName").get<std::string>());
    }

    if(patientObj.contains("PatientBirthDate"))
    {
        result.setPatientBirthDate(patientObj.at("PatientBirthDate").get<std::string>());
    }

    if(patientObj.contains("ReferringPhysicianName"))
    {
        result.setReferringPhysicianName(patientObj.at("ReferringPhysicianName").get<std::string>());
    }

    if(patientObj.contains("InstituationName"))
    {
        result.setInstituationName(patientObj.at("InstituationName").get<std::string>());
    }

    if(patientObj.contains("InstituationAddress"))
    {
        result.setInstituationAddress(patientObj.at("InstituationAddress").get<std::string>());
    }

    if(patientObj.contains("OpeatorName"))
    {
        result.setOperatorName(patientObj.at("OpeatorName").get<std::string>());
    }

    if(patientObj.contains("IsEmptyData"))
    {
        result.setIsEmptyData(patientObj.at("IsEmptyData").get<int>());
    }

    if(patientObj.contains("PatientSex"))
    {
        result.setPatientSex(patientObj.at("PatientSex").get<std::string>());
    }

    if(patientObj.contains("Laterality"))
    {
        result.setLaterality(patientObj.at("Laterality").get<std::string>());
    }
    delete[] patientCString;
    stream.close();
    return  result;
}