Parser新采集脚本对应。

src/Data/Arraypointer.h

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

src/DataReader/CEDataReader.cpp

@@ -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 cePointer(ceData,ceDataLength);
-        cePointer.setArray(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;
+    CEPointer ce(ceArrayPointer,arrayLength);
-    ce.setArray(ceArrayPointer,arrayLength);
     result.setCE(ce);
 
     nlohmann::json jsonObj;

src/DataReader/MetaDataReader.cpp

@@ -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);
+         result.setAperturePositionNumber(aShotList->getMotorPositionSize());
-         if(aperturePositionVar != nullptr)
-         {
-             unsigned short aperturePositionNum =  static_cast<unsigned short>(aperturePositionVar->nbytes / static_cast<unsigned long long>(aperturePositionVar->data_size));
-             result.setAperturePositionNumber(aperturePositionNum);
-         }
     }
     //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 tasIndicesPointer(tasIndices,tasIndicesLength);
-    tasIndicesPointer.setArray(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 receiverIndicesPointer(receiverIndices,receiverIndicesLength);
-    receiverIndicesPointer.setArray(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;
+    TasIndicesPointer tasIndices(tasIndicesArray,arrayLength);
-    tasIndices.setArray(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;
+    TasIndicesPointer receiverIndices(receiverIndicesArray,arrayLength);
-    receiverIndices.setArray(receiverIndicesArray,arrayLength);
     result.setReceiverIndices(receiverIndices);
 
     stream.close();

src/DataReader/MovementDataReader.cpp

@@ -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 rotationMatrixPointer(rotationMatrixArray,16);
-                rotationMatrixPointer.setArray(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);
         }
     }

src/DataReader/TemperatureDataReader.cpp

@@ -17,10 +17,21 @@ namespace
         JumoTemperaturePointer jumoTemperaturePointer;
         if(jumoTemperatureVar!=nullptr)
         {
-            unsigned long long jumoTemperatureLength = jumoTemperatureVar->nbytes / static_cast<unsigned long long>(jumoTemperatureVar->data_size);
+            size_t dims = jumoTemperatureVar->dims[0];
-            std::shared_ptr<float> jumoTemperature = std::shared_ptr<float>(new float[jumoTemperatureLength], std::default_delete<float[]>());
+            std::shared_ptr<float> jumoTemperature = std::shared_ptr<float>(new float[dims], std::default_delete<float[]>());
-            jumoTemperaturePointer.setArray(jumoTemperature,jumoTemperatureLength);
+            jumoTemperaturePointer = JumoTemperaturePointer(jumoTemperature,dims);
-            std::copy(reinterpret_cast<double*>(jumoTemperatureVar->data),reinterpret_cast<double*>(jumoTemperatureVar->data) + jumoTemperatureLength,jumoTemperature.get());
+            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;
+                TasTemperaturePointer tasTempPointer1(tasTampAp1,tasTempLength);
-                tasTempPointer.setArray(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;
+                TasTemperaturePointer tasTempPointer(tasTamp,tasTempLength);
-                tasTempPointer.setArray(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;
+                        TasTemperatureRawdataPointer rawDataPointer(tasTampRawData,tasTempLength);
-                        rawDataPointer.setArray(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);
+                aTasTemperatureDatas.at(i).get()[2*j] /= aAperaturePositionRound.at(i);
-                if(aTasTemperatureDatas.at(i).getArray().get()[2*j] < -200)
+                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;
+        TasTemperaturePointer tasTempCompPointer(tasTempCompArray,tasTempCompArrayLength);
-        tasTempCompPointer.setArray(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].get()[2*j] += data;
-                tasTempCompDatas[0].getArray().get()[2*j+1] = j+1;
+                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].get()[2*j] += data;
-                tasTempCompDatas[1].getArray().get()[2*j+1] = j+1;
+                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].get()[2*j] += data;
-                tasTempCompDatas[0].getArray().get()[2*j+1] = j+1;
+                tasTempCompDatas[0].get()[2*j+1] = j+1;
-                tasTempCompDatas[1].getArray().get()[2*j] += data;
+                tasTempCompDatas[1].get()[2*j] += data;
-                tasTempCompDatas[1].getArray().get()[2*j+1] = j+1;
+                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;
+        TasTemperaturePointer tasTempPointer(tasTempArray,tasTempArrayLength);
-        tasTempPointer.setArray(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;
+            TasTemperatureRawdataPointer tasTempRawDataPointer(tasTempRawDataArray,tasTempCompArrayLength);
-            tasTempRawDataPointer.setArray(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.get()[2*j] = data;
-                tasTempRawDataPointer.getArray().get()[2*j+1] = j+1;
+                tasTempRawDataPointer.get()[2*j+1] = j+1;
-                tasTempDatas[0].getArray().get()[2*j] += data;
+                tasTempDatas[0].get()[2*j] += data;
-                tasTempDatas[0].getArray().get()[2*j+1] = j+1;
+                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;
+            TasTemperatureRawdataPointer tasTempRawDataPointer(tasTempRawDataArray,tasTempArrayLength);
-            tasTempRawDataPointer.setArray(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.get()[2*j] = data;
-                tasTempRawDataPointer.getArray().get()[2*j+1] = j+1;
+                tasTempRawDataPointer.get()[2*j+1] = j+1;
-                tasTempDatas[1].getArray().get()[2*j] += data;
+                tasTempDatas[1].get()[2*j] += data;
-                tasTempDatas[1].getArray().get()[2*j+1] = j+1;
+                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;
+            TasTemperatureRawdataPointer tasTempRawDataPointer1(tasTempRawDataArray1,tasTempArrayLength);
-            tasTempRawDataPointer1.setArray(tasTempRawDataArray1,tasTempArrayLength);
             tasTempRawDatas[0].push_back(tasTempRawDataPointer1);
             std::shared_ptr<float> tasTempRawDataArray2(new float[tasTempArrayLength]{0},std::default_delete<float[]>());
-            TasTemperatureRawdataPointer tasTempRawDataPointer2;
+            TasTemperatureRawdataPointer tasTempRawDataPointer2(tasTempRawDataArray2,tasTempArrayLength);
-            tasTempRawDataPointer2.setArray(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.get()[2*j] = data;
-                tasTempRawDataPointer1.getArray().get()[2*j+1] = j+1;
+                tasTempRawDataPointer1.get()[2*j+1] = j+1;
-                tasTempRawDataPointer2.getArray().get()[2*j] = data;
+                tasTempRawDataPointer2.get()[2*j] = data;
-                tasTempRawDataPointer2.getArray().get()[2*j+1] = j+1;
+                tasTempRawDataPointer2.get()[2*j+1] = j+1;
                 //tasTemp
-                tasTempDatas[0].getArray().get()[2*j] += data;
+                tasTempDatas[0].get()[2*j] += data;
-                tasTempDatas[0].getArray().get()[2*j+1] = j+1;
+                tasTempDatas[0].get()[2*j+1] = j+1;
-                tasTempDatas[1].getArray().get()[2*j] += data;
+                tasTempDatas[1].get()[2*j] += data;
-                tasTempDatas[1].getArray().get()[2*j+1] = j+1;
+                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)
     {

src/Mapper/MapperDataBase.cpp

@@ -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;
     }

src/MatLab/MatlabCreator.cpp

@@ -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);
 }
 
 

src/MatLab/MatlabCreator.h

@@ -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;

src/MatLab/MatlabCreatorPrivate.cpp

@@ -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)
+    for(unsigned int i=0;i<threadCount;++i)
-//    {
+    {
-//        if(i == threadRemainder && threadRemainder!=0)
+        if(i == threadRemainder && threadRemainder!=0)
-//        {
+        {
-//            --tasOffSet;
+            --tasOffSet;
-//        }
+        }
-//        threads[i] = std::shared_ptr<std::thread>(new std::thread(&MatlabCreatorPrivate::createKITMatInThread, this, parser->clone(), tasNum, tasOffSet));
+        threads[i] = std::shared_ptr<std::thread>(new std::thread(&MatlabCreatorPrivate::createKITMatInThread, this, parser->clone(), tasNum, tasOffSet, dirPath));
-//        tasNum += tasOffSet;
+        tasNum += tasOffSet;
-//    }
+    }
-//    for(unsigned int i=0; i< threadCount; ++i)
+    for(unsigned int i=0; i< threadCount; ++i)
-//    {
+    {
-//        threads[i]->join();
+        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();

src/MatLab/MatlabCreatorPrivate.h

@@ -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);

src/Parser.pro.user

@@ -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>

src/ParserPrivate.cpp

@@ -89,12 +89,8 @@ namespace
     }
 }
 
-ParserPrivate::ParserPrivate(const std::string& aPath, unsigned long long aDataLength, AscanDataType aDataType)
+ParserPrivate::ParserPrivate(const std::string& aPath, AscanDataType aDataType)
-    : mDataLength(aDataLength)
+    : mDataType(aDataType)
-    , mDataSize(getAscanDataSize(aDataType))
-    , mUnitSize((mDataLength + HEADER_SIZE + CRC_SIZE) * mDataSize)
-    , mBlockSize(mUnitSize * CHANNEL_SIZE)
-    , 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);

src/ParserPrivate.h

@@ -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

src/ShotList/ShotListPrivate.cpp

@@ -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;
+    ShotListArray result(array,shotListDataLength);
-    result.setArray(array,shotListDataLength);
     return result;
 }