making the loaded signal data buffer larger

modules/dsn/managers/signalmanager.cpp

@@ -36,29 +36,19 @@ namespace openspace {
     {
         bool dataFilesSuccess = DataFileHelper::checkFileNames(identifier, dictionary, _dataFiles);
         _fileStartTimes = DataFileHelper::getDaysFromFileNames(_dataFiles);
-        SignalManager::signalParser(0);
+        SignalManager::updateSignalData(0, 0);
 
         return dataFilesSuccess;
     }
 
     bool SignalManager::signalParser(int index) {
 
-        std::string filename;
-        if (index == -1 || index > _dataFiles.size())
-            return false;
-
-        filename = _dataFiles[index];
+        std::string filename = _dataFiles[index];
         std::ifstream ifs(filename);
         nlohmann::json j = nlohmann::json::parse(ifs);
 
-        SignalManager::Signal structSignal;
-        
-        std::string startTimeString = DataFileHelper::getDayFromFileName(filename);
-        const double triggerTime = Time::convertTime(startTimeString);
+        SignalManager::Signal structSignal;       
 
-       _signalData.sequenceStartTime = triggerTime;
-       _signalData.signals.clear();
-       _signalData.signals.reserve(0);
        // TODO handle the start time/ end time with regard to light time travel
        // ie. This has to be different for uplink and downlink
        // light time travel should extend endtime for uplink, and start time for downlink
@@ -74,8 +64,55 @@ namespace openspace {
           _signalData.signals.push_back(structSignal);
         }
 
-      _signalData.isLoaded = true;
-      return _signalData.isLoaded;
+      return true;
+    }
+
+    /* We load the signals for the current day, as well as a 
+    * buffer for the previous day and the next day. This allows 
+    * us to keep signal data in memory that transmit over midnight,
+    * as well as signals that have a long light travel time. */
+    void SignalManager::updateSignalData(int index, int sizeBuffer) {
+        
+        // This will all
+        int lightTimeTravelBuffer = 1;
+
+        if (index == -1 || index > _dataFiles.size())
+            return;
+
+        _signalData.signals.clear();
+        _signalData.signals.reserve(sizeBuffer);
+
+        std::string activeTimeFilename = _dataFiles[index];
+        std::string startTimeString = DataFileHelper::getDayFromFileName(activeTimeFilename);
+        const double triggerTime = Time::convertTime(startTimeString);
+
+        _signalData.sequenceStartTime = triggerTime;
+        //86400 equals 24hrs in seconds
+        _signalData.sequenceEndTime = triggerTime + 86400; 
+
+        if (index < lightTimeTravelBuffer)
+        {
+            signalParser(index);
+            signalParser(index + lightTimeTravelBuffer);
+            _signalData.isLoaded = true;
+            _signalData.signals.shrink_to_fit();
+            return;
+        }
+        else if (index == _dataFiles.size()) {
+
+            signalParser(index- lightTimeTravelBuffer);
+            signalParser(index);
+            _signalData.isLoaded = true;
+            _signalData.signals.shrink_to_fit();
+            return;  
+        }
+        else {
+            signalParser(index - lightTimeTravelBuffer);
+            signalParser(index);
+            signalParser(index + lightTimeTravelBuffer);
+            _signalData.isLoaded = true;
+            _signalData.signals.shrink_to_fit();
+        }
     }
 
 }

modules/dsn/managers/signalmanager.h

@@ -53,7 +53,9 @@ namespace openspace {
         //filename is on the format of YYYY-DDDT (excluding '.json')
         bool isLoaded = false;
         double sequenceStartTime;
-        double sequenceEndTime = sequenceStartTime + 86400.0; // 24 hours from startTime 
+        // 24 hours from startTime 
+        double sequenceEndTime;
+        //The currently loaded signals
         std::vector<Signal> signals;
      };
 
@@ -67,6 +69,8 @@ namespace openspace {
       static bool extractMandatoryInfoFromDictionary(const char* identifier, std::unique_ptr<ghoul::Dictionary> &dictionary);
       /* parses signaldata from a file given an index in our preloaded filename vector */
       static bool signalParser(int index);
+      /* updates the loaded signal data from disk */
+      static void updateSignalData(int index, int sizeBuffer);
 
     };
 }

modules/dsn/rendering/renderablesignals.cpp

@@ -260,12 +260,10 @@ void RenderableSignals::render(const RenderData& data, RendererTasks&) {
 void RenderableSignals::update(const UpdateData& data) {
 
     double currentTime = data.time.j2000Seconds();
-    //Todo: change this magic number. 86400 equals 24hrs in seconds
-    double endTime = 86400;
 
     //Bool if the current time is within the timeframe for the currently loaded data
     const bool isTimeInFileInterval = (currentTime >= SignalManager::_signalData.sequenceStartTime) &&
-        (currentTime < SignalManager::_signalData.sequenceStartTime + endTime);
+        (currentTime < SignalManager::_signalData.sequenceEndTime);
 
     //Reload data if it is not relevant anymore
     if (!isTimeInFileInterval) {
@@ -275,7 +273,8 @@ void RenderableSignals::update(const UpdateData& data) {
         //parse data for that file
         if (!SignalManager::_signalData.isLoaded)
         {
-            SignalManager::signalParser(activeFileIndex);
+            LDEBUG(fmt::format("{}: Reloading SignalData.", _identifier));
+            SignalManager::updateSignalData(activeFileIndex, _signalSizeBuffer);
         }
         else
             return;

modules/dsn/rendering/renderablesignals.h

@@ -182,10 +182,11 @@ namespace openspace {
 
         UniformCache(modelViewStation, modelViewSpacecraft, projection) _uniformCache;
 
-
         /*Checks if the current time is within a signal's start and endtime*/
         bool isSignalActive(double currentTime, std::string signalStartTime, std::string signalEndTime, double lightTravelTime);
 
+        /// Size buffer for signal vector
+        int _signalSizeBuffer = 10;
 
     };