Add matio and MatLab Reader.

CMakeLists.txt

@@ -24,6 +24,7 @@ target_compile_options(Aurora PUBLIC $<TARGET_PROPERTY:MKL::MKL,INTERFACE_COMPIL
 target_include_directories(Aurora PUBLIC $<TARGET_PROPERTY:MKL::MKL,INTERFACE_INCLUDE_DIRECTORIES>)
 target_link_libraries(Aurora PUBLIC $<LINK_ONLY:MKL::MKL>)
 target_link_libraries(Aurora PUBLIC OpenMP::OpenMP_CXX)
+target_link_libraries(Aurora PUBLIC matio)
 find_package(GTest  REQUIRED)
 INCLUDE_DIRECTORIES(${GTEST_INCLUDE_DIRS})
 include_directories(./src/util)
@@ -38,6 +39,7 @@ target_compile_options(Aurora_Test PUBLIC $<TARGET_PROPERTY:MKL::MKL,INTERFACE_C
 target_include_directories(Aurora_Test PUBLIC $<TARGET_PROPERTY:MKL::MKL,INTERFACE_INCLUDE_DIRECTORIES>)
 target_link_libraries(Aurora_Test PUBLIC $<LINK_ONLY:MKL::MKL>)
 target_link_libraries(Aurora_Test PUBLIC OpenMP::OpenMP_CXX)
+target_link_libraries(Aurora_Test PUBLIC matio)
 target_link_libraries(Aurora_Test PUBLIC ${GTEST_BOTH_LIBRARIES}  )
 gtest_discover_tests(Aurora_Test )
 #target_link_libraries(CreateMatchedFilter PRIVATE TBB::tbb)

src/MatlabReader.cpp

@@ -0,0 +1,100 @@
+#include "MatlabReader.h"
+
+#include <matio.h>
+
+double* calculateArray(matvar_t* aMatVar, const char* aFieldName)
+{
+    matvar_t* matVar = Mat_VarGetStructFieldByName(aMatVar,aFieldName,0);
+    double* data = reinterpret_cast<double*>(matVar->data);
+    unsigned long long dataLength = matVar->nbytes / static_cast<unsigned long long>(matVar->data_size);
+    double* result = new double[dataLength];
+    std::copy(data,data+dataLength,result);
+    Mat_VarFree(matVar);
+    return result;
+}
+
+MatlabReader::MatlabReader()
+{
+
+}
+
+bool MatlabReader::read(Input* aInput,MatchedFilter* aOutput,const std::string& aFilePath)
+{
+    mat_t* mat = Mat_Open(aFilePath.c_str(), MAT_ACC_RDONLY);
+    if(mat == nullptr)
+    {
+        return false;
+    }
+
+    matvar_t* matvar = Mat_VarRead(mat,"input");
+    if (matvar == nullptr)
+    {
+        return false;
+    }
+
+    aInput->mCe = calculateArray(matvar,"ce");
+
+    matvar_t* measuredCEusedVar = Mat_VarGetStructFieldByName(matvar,"measuredCEused",0);
+    double* measuredCEused = reinterpret_cast<double*>(measuredCEusedVar->data);
+    aInput->mMeasuredCEused = *measuredCEused;
+    Mat_VarFree(measuredCEusedVar);
+
+    matvar_t* removeOutliersFromCEMeasuredVar = Mat_VarGetStructFieldByName(matvar,"removeOutliersFromCEMeasured",0);
+    double* removeOutliersFromCEMeasured = reinterpret_cast<double*>(removeOutliersFromCEMeasuredVar->data);
+    aInput->mRemoveOutliersFromCEMeasured = *removeOutliersFromCEMeasured;
+    Mat_VarFree(removeOutliersFromCEMeasuredVar);
+
+    matvar_t* hardwareVersionVar = Mat_VarGetStructFieldByName(matvar,"hardwareVersion",0);
+    char* hardwareVersion = reinterpret_cast<char*>(hardwareVersionVar->data);
+    aInput->mHardwareVersion = hardwareVersion;
+    Mat_VarFree(hardwareVersionVar);
+
+    matvar_t* paramsVar = Mat_VarGetStructFieldByName(matvar,"params",0);
+
+    aInput->mParams->mSenderTasList = calculateArray(paramsVar,"senderTasList");
+
+    aInput->mParams->mSenderElementList = calculateArray(paramsVar,"senderElementList");
+
+    aInput->mParams->mReceiverTasList = calculateArray(paramsVar,"receiverTasList");;
+
+    aInput->mParams->mSenderElementList = calculateArray(paramsVar,"receiverElementList");
+
+    aInput->mParams->mMotorPos = calculateArray(paramsVar,"motorPos");
+
+    matvar_t* constrictReflectionAnglesVar = Mat_VarGetStructFieldByName(paramsVar,"constrictReflectionAngles",0);
+    aInput->mParams->mConstrictReflectionAngles = *reinterpret_cast<double*>(constrictReflectionAnglesVar->data);
+    Mat_VarFree(constrictReflectionAnglesVar);
+
+    matvar_t* angleLowerLimitVar = Mat_VarGetStructFieldByName(paramsVar,"angleLowerLimit",0);
+    aInput->mParams->mAngleLowerLimit = *reinterpret_cast<double*>(angleLowerLimitVar->data);
+    Mat_VarFree(angleLowerLimitVar);
+
+    matvar_t* angleUpperLimitVar = Mat_VarGetStructFieldByName(paramsVar,"angleUpperLimit",0);
+    aInput->mParams->mAngleUpperLimit = *reinterpret_cast<double*>(angleUpperLimitVar->data);
+    Mat_VarFree(angleUpperLimitVar);
+
+    matvar_t* findDefectsVar = Mat_VarGetStructFieldByName(paramsVar,"findDefects",0);
+    aInput->mParams->mFindDefects = *reinterpret_cast<double*>(findDefectsVar->data);
+    Mat_VarFree(findDefectsVar);
+
+    matvar_t* epsilonVar = Mat_VarGetStructFieldByName(paramsVar,"epsilon",0);
+    aInput->mParams->mEpsilon = *reinterpret_cast<double*>(epsilonVar->data);
+    Mat_VarFree(epsilonVar);
+
+    matvar = Mat_VarRead(mat,"output");
+    mat_complex_split_t* complexDouble = reinterpret_cast<mat_complex_split_t*>(matvar->data);
+    unsigned long long dataLength =  matvar->nbytes / static_cast<unsigned long long>(matvar->data_size);;
+    double* real = reinterpret_cast<double*>(complexDouble->Re);
+    double* imag = reinterpret_cast<double*>(complexDouble->Im);
+    double* realData = new double[dataLength];
+    double* imagData = new double[dataLength];
+    std::copy(real,real+dataLength,realData);
+    std::copy(imag,imag+dataLength,imagData);
+    aOutput->mImag = imagData;
+    aOutput->mReal = realData;
+
+    Mat_VarFree(matvar);
+    Mat_Close(mat);
+
+    return true;
+}

src/MatlabReader.h

@@ -0,0 +1,76 @@
+#ifndef MATLABREADER_H
+#define MATLABREADER_H
+
+#include <string>
+#include <matio.h>
+
+class Params
+{
+public:
+    Params(){}
+
+    double* mSenderTasList;
+    double* mSenderElementList;
+    double* mReceiverTasList;
+    double* mReceiverElementList;
+    double* mMotorPos;
+    double mConstrictReflectionAngles;
+    double mAngleLowerLimit;
+    double mAngleUpperLimit;
+    double mFindDefects;
+    double mEpsilon;
+};
+
+class Input
+{
+public:
+    Input():mParams(new Params()){}
+    ~Input(){delete mParams;}
+    Params* mParams;
+    double* mCe;
+    double mMeasuredCEused;
+    double mRemoveOutliersFromCEMeasured;
+    std::string mHardwareVersion;
+};
+
+class MatchedFilter
+{
+public:
+    MatchedFilter(){};
+
+    double* mReal;
+    double* mImag;
+};
+
+
+class MatlabReader
+{
+public:
+    MatlabReader();
+    bool read(Input* aInput,MatchedFilter* aOutput,const std::string& aFilePath);
+};
+
+class MatlabCreator
+{
+public:
+    MatlabCreator(){};
+    void createMat(const std::string& aFileName,size_t* aSize,int aRank,double* aRealData,double* aImageData)
+    {
+        mat_t* matfp = nullptr;
+        matfp = Mat_CreateVer(aFileName.c_str(),nullptr,MAT_FT_DEFAULT);
+        if ( nullptr == matfp )
+        {
+            return;
+        }
+        mat_complex_split_t complexDouble;
+        complexDouble.Im = aImageData;
+        complexDouble.Re = aRealData;
+        matvar_t* measurementIdVar = Mat_VarCreate("output", MAT_C_DOUBLE,MAT_T_DOUBLE,aRank,aSize,&complexDouble,MAT_F_COMPLEX);
+        Mat_VarWrite(matfp,measurementIdVar,MAT_COMPRESSION_NONE);
+        Mat_VarFree(measurementIdVar);
+        Mat_Close(matfp);
+        return;
+    }
+};
+
+#endif // MATLABREADER_H