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

Parser新采集脚本对应。

Browse Source
This commit is contained in:
sunwen
2023-04-18 10:37:23 +08:00
parent bd3bd664e7
commit 5afffd143c
14 changed files with 156 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
src/Data/Arraypointer.h
View File

@@ -7,21 +7,20 @@ template <typename T>
class ArrayPointer
{
public:
ArrayPointer()
: mArray()
, mLength(0)
ArrayPointer(std::shared_ptr<T> aArray = std::shared_ptr<T>(), unsigned long long aLength = 0)
: mArray(aArray)
, mLength(aLength)
{
}
void setArray(std::shared_ptr<T> aArray, unsigned long long aLength)
T* get()
{
mArray = aArray;
mLength = aLength;
return mArray.get();
}
std::shared_ptr<T> getArray()
bool isNull()
{
return mArray;
return !mArray || (mLength == 0);
}
unsigned long long getLength()

6
src/DataReader/CEDataReader.cpp
View File

@@ -25,8 +25,7 @@ CEData CEDataReader::getCEDataFromKIT(const std::string& aFilePath)
{
unsigned long long ceDataLength = ceVar->nbytes / static_cast<unsigned long long>(ceVar->data_size);
std::shared_ptr<unsigned short> ceData = std::shared_ptr<unsigned short>(new unsigned short[ceDataLength], std::default_delete<unsigned short[]>());
CEPointer cePointer;
cePointer.setArray(ceData,ceDataLength);
CEPointer cePointer(ceData,ceDataLength);
std::copy(reinterpret_cast<double*>(ceVar->data),reinterpret_cast<double*>(ceVar->data) + ceDataLength,ceData.get());
result.setCE(cePointer);
}
@@ -60,8 +59,7 @@ CEData CEDataReader::getCEDataFromHJ(const std::string& aConfigBinPath, const st
unsigned long long arrayLength = aConfigHeader->getChirpLength()/2;
std::shared_ptr<unsigned short> ceArrayPointer(new unsigned short[arrayLength],std::default_delete<unsigned short[]>());
stream.read(reinterpret_cast<char*>(ceArrayPointer.get()),aConfigHeader->getChirpLength());
CEPointer ce;
ce.setArray(ceArrayPointer,arrayLength);
CEPointer ce(ceArrayPointer,arrayLength);
result.setCE(ce);
nlohmann::json jsonObj;

19
src/DataReader/MetaDataReader.cpp
View File

@@ -50,12 +50,7 @@ MetaData MetaDataReader::getMetaDataFromKIT(const std::string& aFilePath,std::sh
result.setMeasurementID(MatlabHelper::getMatlabString(measurementIDVar));
}
//AperturePosition
matvar_t* aperturePositionVar = Mat_VarGetStructFieldByName(metaDataVar,"PositionRotation",0);
if(aperturePositionVar != nullptr)
{
unsigned short aperturePositionNum = static_cast<unsigned short>(aperturePositionVar->nbytes / static_cast<unsigned long long>(aperturePositionVar->data_size));
result.setAperturePositionNumber(aperturePositionNum);
}
result.setAperturePositionNumber(aShotList->getMotorPositionSize());
}
//TASIndices
std::shared_ptr<unsigned short> mapperArrayPointer = MapperDataBase::getMapperArray();
@@ -70,8 +65,7 @@ MetaData MetaDataReader::getMetaDataFromKIT(const std::string& aFilePath,std::sh
index+=9;
}
}
TasIndicesPointer tasIndicesPointer;
tasIndicesPointer.setArray(tasIndices,tasIndicesLength);
TasIndicesPointer tasIndicesPointer(tasIndices,tasIndicesLength);
result.setTasIndices(tasIndicesPointer);
//receiverIndices
unsigned long long receiverIndicesLength = aShotList->getMuxSize() * TOTAL_CHANNEL;
@@ -86,8 +80,7 @@ MetaData MetaDataReader::getMetaDataFromKIT(const std::string& aFilePath,std::sh
index+=9;
}
}
ReceiverIndicesPointer receiverIndicesPointer;
receiverIndicesPointer.setArray(receiverIndices,receiverIndicesLength);
ReceiverIndicesPointer receiverIndicesPointer(receiverIndices,receiverIndicesLength);
result.setReceiverIndices(receiverIndicesPointer);
@@ -142,8 +135,7 @@ MetaData MetaDataReader::getMetaDataFromHJ(const std::string& aConfigBinPath, co
unsigned int arrayLength = aConfigHeader->getTasIndicesLength();
std::shared_ptr<uint8_t> tasIndicesArray(new uint8_t[arrayLength],std::default_delete<uint8_t[]>());
stream.read(reinterpret_cast<char*>(tasIndicesArray.get()),arrayLength);
TasIndicesPointer tasIndices;
tasIndices.setArray(tasIndicesArray,arrayLength);
TasIndicesPointer tasIndices(tasIndicesArray,arrayLength);
result.setTasIndices(tasIndices);
@@ -151,8 +143,7 @@ MetaData MetaDataReader::getMetaDataFromHJ(const std::string& aConfigBinPath, co
arrayLength = aConfigHeader->getReceiverIndicesLength();
std::shared_ptr<uint8_t> receiverIndicesArray(new uint8_t[arrayLength],std::default_delete<uint8_t[]>());
stream.read(reinterpret_cast<char*>(receiverIndicesArray.get()),arrayLength);
TasIndicesPointer receiverIndices;
receiverIndices.setArray(receiverIndicesArray,arrayLength);
TasIndicesPointer receiverIndices(receiverIndicesArray,arrayLength);
result.setReceiverIndices(receiverIndices);
stream.close();

10
src/DataReader/MovementDataReader.cpp
View File

@@ -28,7 +28,7 @@ MovementData MovementDataReader::getMovementDataFromKIT(const std::string& aMove
{
unsigned long long movementsListrealLength = movementsListrealVar->nbytes / static_cast<unsigned long long>(movementsListrealVar->data_size);
std::shared_ptr<float> movementsListreal = std::shared_ptr<float>(new float[movementsListrealLength], std::default_delete<float[]>());
movementsListrealPointer.setArray(movementsListreal,movementsListrealLength);
movementsListrealPointer = MovementsListRealPointer(movementsListreal,movementsListrealLength);
std::copy(reinterpret_cast<double*>(movementsListrealVar->data),reinterpret_cast<double*>(movementsListrealVar->data) + movementsListrealLength,movementsListreal.get());
}
Mat_VarFree(movementsListrealVar);
@@ -50,7 +50,7 @@ MovementData MovementDataReader::getMovementDataFromKIT(const std::string& aMove
{
unsigned long long rotaionMatrixLength = rotationMatrixVar->nbytes / static_cast<unsigned long long>(rotationMatrixVar->data_size);
std::shared_ptr<float> rotationMatrix = std::shared_ptr<float>(new float[rotaionMatrixLength], std::default_delete<float[]>());
rotationMatrixPointer.setArray(rotationMatrix,rotaionMatrixLength);
rotationMatrixPointer = RotationMatrixPointer(rotationMatrix,rotaionMatrixLength);
std::copy(reinterpret_cast<double*>(rotationMatrixVar->data),reinterpret_cast<double*>(rotationMatrixVar->data) + rotaionMatrixLength,rotationMatrix.get());
}
rotationMatrixs.push_back(rotationMatrixPointer);
@@ -86,22 +86,20 @@ MovementData MovementDataReader::getMovementDataFromHJ(const std::string& aConfi
rotationMatrixArray.get()[10] = 1;
rotationMatrixArray.get()[14] = rotationMatrixInfo.at(i+1);
rotationMatrixArray.get()[15] = 1;
RotationMatrixPointer rotationMatrixPointer;
rotationMatrixPointer.setArray(rotationMatrixArray,16);
RotationMatrixPointer rotationMatrixPointer(rotationMatrixArray,16);
rotationMatrixs.push_back(rotationMatrixPointer);
}
result.setRotationMatrix(rotationMatrixs);
}
if(generalInfo.contains("Real Holder Position"))
{
MovementsListRealPointer movementsLisReal;
std::vector<float> movementsListRealInfo = generalInfo.at("Real Holder Position").get<std::vector<float>>();
std::shared_ptr<float> movementsListArray(new float[movementsListRealInfo.size()],std::default_delete<float[]>());
for(unsigned int i=0;i<movementsListRealInfo.size();++i)
{
movementsListArray.get()[i] = movementsListRealInfo.at(i);
}
movementsLisReal.setArray(movementsListArray,movementsListRealInfo.size());
MovementsListRealPointer movementsLisReal(movementsListArray,movementsListRealInfo.size());
result.setMovementsListReal(movementsLisReal);
}
}

118
src/DataReader/TemperatureDataReader.cpp
View File

@@ -17,10 +17,21 @@ namespace
JumoTemperaturePointer jumoTemperaturePointer;
if(jumoTemperatureVar!=nullptr)
{
unsigned long long jumoTemperatureLength = jumoTemperatureVar->nbytes / static_cast<unsigned long long>(jumoTemperatureVar->data_size);
std::shared_ptr<float> jumoTemperature = std::shared_ptr<float>(new float[jumoTemperatureLength], std::default_delete<float[]>());
jumoTemperaturePointer.setArray(jumoTemperature,jumoTemperatureLength);
std::copy(reinterpret_cast<double*>(jumoTemperatureVar->data),reinterpret_cast<double*>(jumoTemperatureVar->data) + jumoTemperatureLength,jumoTemperature.get());
size_t dims = jumoTemperatureVar->dims[0];
std::shared_ptr<float> jumoTemperature = std::shared_ptr<float>(new float[dims], std::default_delete<float[]>());
jumoTemperaturePointer = JumoTemperaturePointer(jumoTemperature,dims);
for(size_t i=0;i<dims;++i)
{
matvar_t* jumo = Mat_VarGetStructFieldByName(jumoTemperatureVar, "Temperature",i);
if(jumo != nullptr && jumo->nbytes != 0)
{
jumoTemperature.get()[i] = static_cast<float>(reinterpret_cast<double*>(jumo->data)[0]);
}
else
{
jumoTemperature.get()[i] = NAN;
}
}
}
Mat_VarFree(jumoTemperatureVar);
return jumoTemperaturePointer;
@@ -37,21 +48,19 @@ namespace
{
tasTempLength = tasTempLength / 2;
std::shared_ptr<float> tasTampAp1 = std::shared_ptr<float>(new float[tasTempLength], std::default_delete<float[]>());
TasTemperaturePointer tasTempPointer;
tasTempPointer.setArray(tasTampAp1,tasTempLength);
TasTemperaturePointer tasTempPointer1(tasTampAp1,tasTempLength);
std::copy(reinterpret_cast<double*>(tasTemperatureVar->data),reinterpret_cast<double*>(tasTemperatureVar->data) + tasTempLength,tasTampAp1.get());
tasTempDatas.push_back(tasTempPointer);
tasTempDatas.push_back(tasTempPointer1);
std::shared_ptr<float> tasTampAp2 = std::shared_ptr<float>(new float[tasTempLength], std::default_delete<float[]>());
tasTempPointer.setArray(tasTampAp2,tasTempLength);
TasTemperaturePointer tasTempPointer2(tasTampAp2,tasTempLength);
std::copy(reinterpret_cast<double*>(tasTemperatureVar->data)+tasTempLength,reinterpret_cast<double*>(tasTemperatureVar->data) + tasTempLength*2,tasTampAp2.get());
tasTempDatas.push_back(tasTempPointer);
tasTempDatas.push_back(tasTempPointer2);
}
else
{
std::shared_ptr<float> tasTamp = std::shared_ptr<float>(new float[tasTempLength], std::default_delete<float[]>());
TasTemperaturePointer tasTempPointer;
tasTempPointer.setArray(tasTamp,tasTempLength);
TasTemperaturePointer tasTempPointer(tasTamp,tasTempLength);
std::copy(reinterpret_cast<double*>(tasTemperatureVar->data),reinterpret_cast<double*>(tasTemperatureVar->data) + tasTempLength,tasTamp.get());
tasTempDatas.push_back(tasTempPointer);
}
@@ -76,8 +85,7 @@ namespace
for(unsigned int j=0 ; j < tasTemperatureRawDataVar->dims[2];++j)
{
std::shared_ptr<float> tasTampRawData = std::shared_ptr<float>(new float[tasTempLength], std::default_delete<float[]>());
TasTemperatureRawdataPointer rawDataPointer;
rawDataPointer.setArray(tasTampRawData,tasTempLength);
TasTemperatureRawdataPointer rawDataPointer(tasTampRawData,tasTempLength);
subTasTempRawDatas.push_back(rawDataPointer);
float* startIndex = reinterpret_cast<float*>(tasTemperatureRawDataVar->data) + (i*tasTemperatureRawDataVar->dims[2]+j)*tasTempLength;
std::copy(startIndex,startIndex+TAS_COUNT * 2,tasTampRawData.get());
@@ -119,10 +127,10 @@ namespace
{
for(unsigned int j=0;j<TAS_COUNT;++j)
{
aTasTemperatureDatas.at(i).getArray().get()[2*j] /= aAperaturePositionRound.at(i);
if(aTasTemperatureDatas.at(i).getArray().get()[2*j] < -200)
aTasTemperatureDatas.at(i).get()[2*j] /= aAperaturePositionRound.at(i);
if(aTasTemperatureDatas.at(i).get()[2*j] < -200)
{
aTasTemperatureDatas.at(i).getArray().get()[2*j] = NAN;
aTasTemperatureDatas.at(i).get()[2*j] = NAN;
}
}
}
@@ -194,8 +202,7 @@ TemperatureData TemperatureDataReader::getTemperatureDataFromHJ(const std::strin
for(unsigned short i=0;i<aAperaturePosition;++i)
{
std::shared_ptr<float> tasTempCompArray(new float[tasTempCompArrayLength]{0},std::default_delete<float[]>());
TasTemperaturePointer tasTempCompPointer;
tasTempCompPointer.setArray(tasTempCompArray,tasTempCompArrayLength);
TasTemperaturePointer tasTempCompPointer(tasTempCompArray,tasTempCompArrayLength);
tasTempCompDatas.push_back(tasTempCompPointer);
tasTempCompAperatureRound.push_back(0);
jumoTempAperatureRound.push_back(0);
@@ -213,8 +220,8 @@ TemperatureData TemperatureDataReader::getTemperatureDataFromHJ(const std::strin
{
float data;
stream.read(reinterpret_cast<char*>(&data),sizeof(float));
tasTempCompDatas[0].getArray().get()[2*j] += data;
tasTempCompDatas[0].getArray().get()[2*j+1] = j+1;
tasTempCompDatas[0].get()[2*j] += data;
tasTempCompDatas[0].get()[2*j+1] = j+1;
}
++tasTempCompAperatureRound[0];
}
@@ -224,8 +231,8 @@ TemperatureData TemperatureDataReader::getTemperatureDataFromHJ(const std::strin
{
float data;
stream.read(reinterpret_cast<char*>(&data),sizeof(float));
tasTempCompDatas[1].getArray().get()[2*j] += data;
tasTempCompDatas[1].getArray().get()[2*j+1] = j+1;
tasTempCompDatas[1].get()[2*j] += data;
tasTempCompDatas[1].get()[2*j+1] = j+1;
}
++tasTempCompAperatureRound[1];
}
@@ -235,10 +242,10 @@ TemperatureData TemperatureDataReader::getTemperatureDataFromHJ(const std::strin
{
float data;
stream.read(reinterpret_cast<char*>(&data),sizeof(float));
tasTempCompDatas[0].getArray().get()[2*j] += data;
tasTempCompDatas[0].getArray().get()[2*j+1] = j+1;
tasTempCompDatas[1].getArray().get()[2*j] += data;
tasTempCompDatas[1].getArray().get()[2*j+1] = j+1;
tasTempCompDatas[0].get()[2*j] += data;
tasTempCompDatas[0].get()[2*j+1] = j+1;
tasTempCompDatas[1].get()[2*j] += data;
tasTempCompDatas[1].get()[2*j+1] = j+1;
}
++tasTempCompAperatureRound[0];
++tasTempCompAperatureRound[1];
@@ -262,8 +269,7 @@ TemperatureData TemperatureDataReader::getTemperatureDataFromHJ(const std::strin
for(unsigned short i=0;i<aAperaturePosition;++i)
{
std::shared_ptr<float> tasTempArray(new float[tasTempArrayLength]{0},std::default_delete<float[]>());
TasTemperaturePointer tasTempPointer;
tasTempPointer.setArray(tasTempArray,tasTempArrayLength);
TasTemperaturePointer tasTempPointer(tasTempArray,tasTempArrayLength);
tasTempDatas.push_back(tasTempPointer);
tasTempRawDatas.push_back(std::vector<TasTemperatureRawdataPointer>());
tasTempAperatureRound.push_back(0);
@@ -278,61 +284,57 @@ TemperatureData TemperatureDataReader::getTemperatureDataFromHJ(const std::strin
if(aperaturePosition == 1)
{
std::shared_ptr<float> tasTempRawDataArray(new float[tasTempArrayLength]{0},std::default_delete<float[]>());
TasTemperatureRawdataPointer tasTempRawDataPointer;
tasTempRawDataPointer.setArray(tasTempRawDataArray,tasTempCompArrayLength);
TasTemperatureRawdataPointer tasTempRawDataPointer(tasTempRawDataArray,tasTempCompArrayLength);
tasTempRawDatas[0].push_back(tasTempRawDataPointer);
for(unsigned int j=0;j<TAS_COUNT;++j)
{
float data;
stream.read(reinterpret_cast<char*>(&data),sizeof(float));
tasTempRawDataPointer.getArray().get()[2*j] = data;
tasTempRawDataPointer.getArray().get()[2*j+1] = j+1;
tasTempDatas[0].getArray().get()[2*j] += data;
tasTempDatas[0].getArray().get()[2*j+1] = j+1;
tasTempRawDataPointer.get()[2*j] = data;
tasTempRawDataPointer.get()[2*j+1] = j+1;
tasTempDatas[0].get()[2*j] += data;
tasTempDatas[0].get()[2*j+1] = j+1;
}
++tasTempAperatureRound[0];
}
else if(aperaturePosition == 2 && aAperaturePosition > 1)
{
std::shared_ptr<float> tasTempRawDataArray(new float[tasTempArrayLength]{0},std::default_delete<float[]>());
TasTemperatureRawdataPointer tasTempRawDataPointer;
tasTempRawDataPointer.setArray(tasTempRawDataArray,tasTempArrayLength);
TasTemperatureRawdataPointer tasTempRawDataPointer(tasTempRawDataArray,tasTempArrayLength);
tasTempRawDatas[1].push_back(tasTempRawDataPointer);
for(unsigned int j=0;j<TAS_COUNT;++j)
{
float data;
stream.read(reinterpret_cast<char*>(&data),sizeof(float));
tasTempRawDataPointer.getArray().get()[2*j] = data;
tasTempRawDataPointer.getArray().get()[2*j+1] = j+1;
tasTempDatas[1].getArray().get()[2*j] += data;
tasTempDatas[1].getArray().get()[2*j+1] = j+1;
tasTempRawDataPointer.get()[2*j] = data;
tasTempRawDataPointer.get()[2*j+1] = j+1;
tasTempDatas[1].get()[2*j] += data;
tasTempDatas[1].get()[2*j+1] = j+1;
}
++tasTempAperatureRound[1];
}
else if(aperaturePosition == 3 && aAperaturePosition > 1)
{
std::shared_ptr<float> tasTempRawDataArray1(new float[tasTempArrayLength]{0},std::default_delete<float[]>());
TasTemperatureRawdataPointer tasTempRawDataPointer1;
tasTempRawDataPointer1.setArray(tasTempRawDataArray1,tasTempArrayLength);
TasTemperatureRawdataPointer tasTempRawDataPointer1(tasTempRawDataArray1,tasTempArrayLength);
tasTempRawDatas[0].push_back(tasTempRawDataPointer1);
std::shared_ptr<float> tasTempRawDataArray2(new float[tasTempArrayLength]{0},std::default_delete<float[]>());
TasTemperatureRawdataPointer tasTempRawDataPointer2;
tasTempRawDataPointer2.setArray(tasTempRawDataArray2,tasTempArrayLength);
TasTemperatureRawdataPointer tasTempRawDataPointer2(tasTempRawDataArray2,tasTempArrayLength);
tasTempRawDatas[1].push_back(tasTempRawDataPointer2);
for(unsigned int j=0;j<TAS_COUNT;++j)
{
float data;
stream.read(reinterpret_cast<char*>(&data),sizeof(float));
//tasTempRawData
tasTempRawDataPointer1.getArray().get()[2*j] = data;
tasTempRawDataPointer1.getArray().get()[2*j+1] = j+1;
tasTempRawDataPointer2.getArray().get()[2*j] = data;
tasTempRawDataPointer2.getArray().get()[2*j+1] = j+1;
tasTempRawDataPointer1.get()[2*j] = data;
tasTempRawDataPointer1.get()[2*j+1] = j+1;
tasTempRawDataPointer2.get()[2*j] = data;
tasTempRawDataPointer2.get()[2*j+1] = j+1;
//tasTemp
tasTempDatas[0].getArray().get()[2*j] += data;
tasTempDatas[0].getArray().get()[2*j+1] = j+1;
tasTempDatas[1].getArray().get()[2*j] += data;
tasTempDatas[1].getArray().get()[2*j+1] = j+1;
tasTempDatas[0].get()[2*j] += data;
tasTempDatas[0].get()[2*j+1] = j+1;
tasTempDatas[1].get()[2*j] += data;
tasTempDatas[1].get()[2*j+1] = j+1;
}
++tasTempAperatureRound[0];
++tasTempAperatureRound[1];
@@ -343,19 +345,15 @@ TemperatureData TemperatureDataReader::getTemperatureDataFromHJ(const std::strin
result.setTasTemperature(tasTempDatas);
result.setTasTemperatureRawdata(tasTempRawDatas);
//jumoTemp
JumoTemperaturePointer jumoTemp1;
JumoTemperaturePointer jumoTemp2;
JumoTemperaturePointer jumoTemp3;
JumoTemperaturePointer jumoTemp4;
unsigned int jumoTempArrayLength = aAperaturePosition;
std::shared_ptr<float> jumoTempArray1(new float[jumoTempArrayLength]{0},std::default_delete<float[]>());
jumoTemp1.setArray(jumoTempArray1,jumoTempArrayLength);
JumoTemperaturePointer jumoTemp1(jumoTempArray1,jumoTempArrayLength);
std::shared_ptr<float> jumoTempArray2(new float[jumoTempArrayLength]{0},std::default_delete<float[]>());
jumoTemp2.setArray(jumoTempArray2,jumoTempArrayLength);
JumoTemperaturePointer jumoTemp2(jumoTempArray2,jumoTempArrayLength);
std::shared_ptr<float> jumoTempArray3(new float[jumoTempArrayLength]{0},std::default_delete<float[]>());
jumoTemp3.setArray(jumoTempArray3,jumoTempArrayLength);
JumoTemperaturePointer jumoTemp3(jumoTempArray3,jumoTempArrayLength);
std::shared_ptr<float> jumoTempArray4(new float[jumoTempArrayLength]{0},std::default_delete<float[]>());
jumoTemp4.setArray(jumoTempArray4,jumoTempArrayLength);
JumoTemperaturePointer jumoTemp4(jumoTempArray4,jumoTempArrayLength);
for(unsigned short i = 0;i<jumoTempRound;++i)
{

10
src/Mapper/MapperDataBase.cpp
View File

@@ -26,6 +26,12 @@ namespace
}
return 0;
}
#ifdef WIN32
const char* MAPPER_DF_FILE = "./Mapper.db3";
#else
const char* MAPPER_DF_FILE = "/etc/UsctParser/Mapper.db3";
#endif
}
void MapperDataBase::initDatabase()
@@ -47,7 +53,7 @@ bool MapperDataBase::initMapperArray()
{
sqlite3* conn = nullptr;
char* errorMsg = nullptr;
if(sqlite3_open("./Mapper.db3", &conn) != SQLITE_OK)
if(sqlite3_open(MAPPER_DF_FILE, &conn) != SQLITE_OK)
{
std::cout<<"AMCStoredMapper initialize failed, please check DB file."<<std::endl;
return false;
@@ -77,7 +83,7 @@ bool MapperDataBase::getAmcMapper(int& aAmcNum, int& aAmcChannelNum, int aTasNum
}
sqlite3* conn = nullptr;
char* errorMsg = nullptr;
if(sqlite3_open("./Mapper.db3", &conn) != SQLITE_OK)
if(sqlite3_open(MAPPER_DF_FILE, &conn) != SQLITE_OK)
{
return false;
}

4
src/MatLab/MatlabCreator.cpp
View File

@@ -12,9 +12,9 @@ void MatlabCreator::setDirectoryPath(const std::string& aDirectoryPath)
mPrivate->setDirectoryPath(aDirectoryPath);
}
bool MatlabCreator::createKITMat()
bool MatlabCreator::createKITMat(const std::string& aOutputPath)
{
return mPrivate->createKITMat();
return mPrivate->createKITMat(aOutputPath);
}

2
src/MatLab/MatlabCreator.h
View File

@@ -12,7 +12,7 @@ class PARSERSHARED_EXPORT MatlabCreator
public:
MatlabCreator(const std::string& aDirectoryPath);
void setDirectoryPath(const std::string& aDirectoryPath);
bool createKITMat();
bool createKITMat(const std::string& aOutputPath);
MatlabCreator(const MatlabCreator& aMatlabCreator) = delete;
MatlabCreator& operator=(const MatlabCreator& aMatlabCreator) = delete;

70
src/MatLab/MatlabCreatorPrivate.cpp
View File

@@ -83,7 +83,7 @@ void MatlabCreatorPrivate::setDirectoryPath(const std::string& aDirectoryPath)
mFileList = FileListHelper::getFileList(mDirectoryPath);
}
bool MatlabCreatorPrivate::createKITMat()
bool MatlabCreatorPrivate::createKITMat(const std::string& aOutputPath)
{
progress = 0;
if(mFileList.size() == 0)
@@ -108,33 +108,33 @@ bool MatlabCreatorPrivate::createKITMat()
unsigned int tasNum = 0;
std::vector<std::shared_ptr<std::thread>> threads(static_cast<size_t>(threadCount));
std::string dirPath = mDirectoryPath + "_mat";
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));
// tasNum += tasOffSet;
// }
// for(unsigned int i=0; i< threadCount; ++i)
// {
// threads[i]->join();
// }
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);
createCEMeasuredMat(parser,dirPath);
createTasTemCompMat(parser,dirPath);
createMeasurementRotationMat(parser,dirPath);
@@ -142,9 +142,9 @@ bool MatlabCreatorPrivate::createKITMat()
return true;
}
void MatlabCreatorPrivate::createKITMatInThread(std::shared_ptr<Parser> aParser, unsigned short aStartTasNum,unsigned short aTasCount)
void MatlabCreatorPrivate::createKITMatInThread(std::shared_ptr<Parser> aParser, unsigned short aStartTasNum,unsigned short aTasCount, const std::string& aOutputPath)
{
std::string dirPath = mDirectoryPath + "_mat";
std::string dirPath = aOutputPath;
DirHelper dir;
ShotList* shotList = aParser->getShotList().get();
for(unsigned short t=aStartTasNum;t<aStartTasNum+aTasCount;++t)
@@ -201,11 +201,11 @@ void MatlabCreatorPrivate::createEmitterMat(std::shared_ptr<Parser> aParser,cons
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);
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.getArray().get(),tasIndicesPointer.getArray().get() + tasIndicesPointer.getLength(), tasIndicesData);
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 )
@@ -299,7 +299,7 @@ void MatlabCreatorPrivate::createCEMat(std::shared_ptr<Parser> aParser, const st
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);
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);
@@ -332,7 +332,7 @@ void MatlabCreatorPrivate::createInfoMat(std::shared_ptr<Parser> aParser, const
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);
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();
@@ -421,7 +421,7 @@ void MatlabCreatorPrivate::createCEMeasuredMat(std::shared_ptr<Parser> aParser,
//receiverIndices
ReceiverIndicesPointer receiverIndices = metaData.getReceiverIndices();
double* writeDataOfReceiverIndices = new double[receiverIndices.getLength()];
std::copy(receiverIndices.getArray().get(), receiverIndices.getArray().get() + receiverIndices.getLength(), writeDataOfReceiverIndices);
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;
@@ -429,7 +429,7 @@ void MatlabCreatorPrivate::createCEMeasuredMat(std::shared_ptr<Parser> aParser,
//TASIndices
TasIndicesPointer tasIndices = metaData.getTasIndices();
double* writeDataOfTasIndices = new double[tasIndices.getLength()];
std::copy(tasIndices.getArray().get(), tasIndices.getArray().get() + tasIndices.getLength(), writeDataOfTasIndices);
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;
@@ -486,7 +486,7 @@ void MatlabCreatorPrivate::createJumoTempMat(std::shared_ptr<Parser> aParser, co
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);
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;
@@ -495,7 +495,7 @@ void MatlabCreatorPrivate::createJumoTempMat(std::shared_ptr<Parser> aParser, co
JumoTemperaturePointer jumoTemperature2 = temperatureData.getJumoTemperature2();
jumoLength = jumoTemperature2.getLength();
writeData = new double[jumoLength];
std::copy(jumoTemperature2.getArray().get(), jumoTemperature2.getArray().get() + jumoLength, writeData);
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;
@@ -504,7 +504,7 @@ void MatlabCreatorPrivate::createJumoTempMat(std::shared_ptr<Parser> aParser, co
JumoTemperaturePointer jumoTemperature3 = temperatureData.getJumoTemperature3();
jumoLength = jumoTemperature3.getLength();
writeData = new double[jumoLength];
std::copy(jumoTemperature3.getArray().get(), jumoTemperature3.getArray().get() + jumoLength, writeData);
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;
@@ -513,7 +513,7 @@ void MatlabCreatorPrivate::createJumoTempMat(std::shared_ptr<Parser> aParser, co
JumoTemperaturePointer jumoTemperature4 = temperatureData.getJumoTemperature4();
jumoLength = jumoTemperature4.getLength();
writeData = new double[jumoLength];
std::copy(jumoTemperature4.getArray().get(), jumoTemperature4.getArray().get() + jumoLength, writeData);
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;
@@ -574,7 +574,7 @@ void MatlabCreatorPrivate::createTasTempMat(std::shared_ptr<Parser> aParser, con
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);
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);
@@ -597,7 +597,7 @@ void MatlabCreatorPrivate::createTasTempMat(std::shared_ptr<Parser> aParser, con
{
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);
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();
}
}
@@ -637,7 +637,7 @@ void MatlabCreatorPrivate::createTasTemCompMat(std::shared_ptr<Parser> aParser,
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);
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);
@@ -678,7 +678,7 @@ void MatlabCreatorPrivate::createMeasurementRotationMat(std::shared_ptr<Parser>
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);
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;
@@ -716,16 +716,16 @@ void MatlabCreatorPrivate::createMovementsMat(std::shared_ptr<Parser> aParser, c
MovementsListRealPointer movementsListReal = aParser->getMovementData().getMovementsListReal();
unsigned long long movementsListRealLength = movementsListReal.getLength();
unsigned short aperturePositionNum = metaData.getAperturePositionNumber();
size_t movementsListRealDims[2] ={aperturePositionNum,aperturePositionNum};
size_t movementsListRealDims[2] ={aperturePositionNum,2}; //2 means heigh and rotation;
double* writeData = new double[movementsListRealLength];
std::copy(movementsListReal.getArray().get(),movementsListReal.getArray().get()+movementsListRealLength,writeData);
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.getArray().get(),0);
matvar_t* timeStampsVar = Mat_VarCreate("TimeStamps",MAT_C_DOUBLE,MAT_T_DOUBLE,2,timeStampsDims,timeStamps.get(),0);
//MeasurementID
std::string measurementID = metaData.getMeasurementID();

4
src/MatLab/MatlabCreatorPrivate.h
View File

@@ -15,13 +15,13 @@ class MatlabCreatorPrivate
public:
MatlabCreatorPrivate(const std::string& aDirectoryPath);
void setDirectoryPath(const std::string& aDirectoryPath);
bool createKITMat();
bool createKITMat(const std::string& aOutputPath);
private:
void 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);
void getAScanOfCEAndAmplification(std::shared_ptr<Parser> aParser,ShotList* aShotList,OneTasAScanData aOneTasAScanData,std::shared_ptr<short> aAScanData,std::shared_ptr<double> aAmplificationData);
void createEmitterMat(std::shared_ptr<Parser> aParser, const std::string& aFileName,std::shared_ptr<short> aAScanData,std::shared_ptr<double> aAmplificationData);
void createKITMatInThread(std::shared_ptr<Parser> aParser,unsigned short aStartTasNum,unsigned short aTasCount);
void createKITMatInThread(std::shared_ptr<Parser> aParser,unsigned short aStartTasNum,unsigned short aTasCount, const std::string& aOutputPath);
void createCEMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath);
void createInfoMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath);
void createCEMeasuredMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath);

2
src/Parser.pro.user
View File

@@ -1,6 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE QtCreatorProject>
<!-- Written by QtCreator 4.8.0, 2023-01-31T18:01:45. -->
<!-- Written by QtCreator 4.8.0, 2023-04-17T18:12:29. -->
<qtcreator>
<data>
<variable>EnvironmentId</variable>

29
src/ParserPrivate.cpp
View File

@@ -89,12 +89,8 @@ namespace
}
}
ParserPrivate::ParserPrivate(const std::string& aPath, unsigned long long aDataLength, AscanDataType aDataType)
: mDataLength(aDataLength)
, mDataSize(getAscanDataSize(aDataType))
, mUnitSize((mDataLength + HEADER_SIZE + CRC_SIZE) * mDataSize)
, mBlockSize(mUnitSize * CHANNEL_SIZE)
, mDataType(aDataType)
ParserPrivate::ParserPrivate(const std::string& aPath, AscanDataType aDataType)
: mDataType(aDataType)
, mPath(FileListHelper::fixPathSlash(aPath))
, mFileList(FileListHelper::getFileList(mPath))
, mShotList()
@@ -105,6 +101,10 @@ ParserPrivate::ParserPrivate(const std::string& aPath, unsigned long long aDataL
, mMovementData()
, mPatientData()
, mTemperatureData()
, mDataLength()
, mDataSize()
, mUnitSize()
, mBlockSize()
{
MapperDataBase::initDatabase();
initParser();
@@ -139,6 +139,7 @@ void ParserPrivate::initParser()
initMovementData();
initPatientData();
initTemperatureData();
initDataLength();
}
void ParserPrivate::initShotList()
@@ -240,6 +241,22 @@ void ParserPrivate::initTemperatureData()
}
}
void ParserPrivate::initDataLength()
{
unsigned long long dataLength = mMetaData.getSampleNumber();
if(dataLength != 0)
{
mDataLength = dataLength;
}
else
{
mDataLength = 4000;
}
mDataSize = getAscanDataSize(mDataType);
mUnitSize = (mDataLength + HEADER_SIZE + CRC_SIZE) * mDataSize;
mBlockSize = mUnitSize * CHANNEL_SIZE;
}
void ParserPrivate::setPath(const std::string& aPath)
{
mPath = FileListHelper::fixPathSlash(aPath);

12
src/ParserPrivate.h
View File

@@ -27,7 +27,7 @@ enum class ParserMode : unsigned short
class ParserPrivate
{
public:
ParserPrivate(const std::string& aPath, unsigned long long aDataLength = 4000, AscanDataType aDataType = AscanDataType::int16);
ParserPrivate(const std::string& aPath, AscanDataType aDataType = AscanDataType::int16);
ParserPrivate(const ParserPrivate& aParserPrivate);
void setPath(const std::string& aPath);
@@ -63,13 +63,9 @@ private:
void initPatientData();
void initTemperatureData();
void initConfigHeader();
void initDataLength();
private:
unsigned long long mDataLength;
unsigned long long mDataSize;
unsigned long long mUnitSize;
unsigned long long mBlockSize;
unsigned long long mAreaSize;
AscanDataType mDataType;
std::string mPath;
std::vector<std::string> mFileList;
@@ -82,6 +78,10 @@ private:
PatientData mPatientData;
TemperatureData mTemperatureData;
ConfigHeader mConfigHeader;
unsigned long long mDataLength;
unsigned long long mDataSize;
unsigned long long mUnitSize;
unsigned long long mBlockSize;
};
#endif // PARSERPRIVATE_H

5
src/ShotList/ShotListPrivate.cpp
View File

@@ -494,7 +494,7 @@ void ShotListPrivate::restAllCurrentLoopIndex()
ShotListArray ShotListPrivate::getShotListArray()
{
unsigned long long shotCount = (mIsCEMeasured ? getTasSize()*getMuxSize() + getTasSize()*getMuxSize()*getElementSize()*getMotorPositionSize() : getTasSize()*getMuxSize());
unsigned long long shotCount = (mIsCEMeasured ? getTasSize()*getMuxSize() + getTasSize()*getMuxSize()*getElementSize()*getMotorPositionSize() : getTasSize()*getMuxSize()*getElementSize()*getMotorPositionSize());
unsigned long long shotListDataLength = shotCount * 4;
std::shared_ptr<double> array = std::shared_ptr<double>(new double[shotListDataLength], std::default_delete<double[]>());
unsigned long long index = 0;
@@ -532,7 +532,6 @@ ShotListArray ShotListPrivate::getShotListArray()
}
}
}
ShotListArray result;
result.setArray(array,shotListDataLength);
ShotListArray result(array,shotListDataLength);
return result;
}