jfjoch_viewer: Make code tighter regarding empty images

reader/JFJochHDF5Reader.cpp

@@ -487,6 +487,9 @@ bool JFJochHDF5Reader::LoadImage_i(std::shared_ptr<JFJochReaderDataset> &dataset
                                    bool update_dataset) {
     std::unique_lock ul(file_mutex);
 
+    if (!dataset)
+        return {};
+
     if (!master_file)
         throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                               "Cannot load image if file not loaded");

reader/JFJochHttpReader.cpp

@@ -10,15 +10,10 @@
 #include "../broker/gen/model/Plots.h"
 #include "../image_analysis/bragg_integration/CalcISigma.h"
 
-void JFJochHttpReader::Close_i() {
-    addr = "";
-    SetStartMessage({});
-
-}
-
 void JFJochHttpReader::Close() {
     std::unique_lock ul(http_mutex);
-    Close_i();
+    addr = "";
+    SetStartMessage({});
 }
 
 uint64_t JFJochHttpReader::GetNumberOfImages() const {
@@ -43,14 +38,21 @@ uint64_t JFJochHttpReader::GetNumberOfImages() const {
     }
 }
 
-std::shared_ptr<JFJochReaderDataset>  JFJochHttpReader::UpdateDataset_i() {
+std::shared_ptr<JFJochReaderDataset> JFJochHttpReader::UpdateDataset_i() {
     httplib::Client cli_cmd(addr);
 
     auto res = cli_cmd.Get("/image_buffer/start.cbor");
 
-    if (!res || res->status != httplib::StatusCode::OK_200)
+    if (!res || (res->status != httplib::StatusCode::OK_200
+        && res->status != httplib::StatusCode::NotFound_404))
         throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                               "Could not get image buffer status");
+
+    if (res->status == httplib::StatusCode::NotFound_404)
+        return {};
+    if (res->body.empty())
+        return {};
+
     try {
         auto msg = CBORStream2Deserialize(res->body);
 
@@ -125,19 +127,18 @@ std::shared_ptr<JFJochReaderDataset>  JFJochHttpReader::UpdateDataset_i() {
 
         return dataset;
     } catch (std::exception &e) {
-        Close_i();
         throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
-                              "Could not load dataset");
+                              std::string("Could not load dataset: ") + std::string(e.what()));
     }
 }
 
 void JFJochHttpReader::ReadURL(const std::string &url) {
     std::unique_lock ul(http_mutex);
-
     addr = url;
     if (url.empty())
-        Close_i();
-    SetStartMessage(UpdateDataset_i());
+        SetStartMessage({});
+    else
+        SetStartMessage(UpdateDataset_i());
 }
 
 bool JFJochHttpReader::LoadImage_i(std::shared_ptr<JFJochReaderDataset> &dataset,
@@ -155,6 +156,8 @@ bool JFJochHttpReader::LoadImage_i(std::shared_ptr<JFJochReaderDataset> &dataset
     // Always update dataset, as it might have changed from the last time
     if (update_dataset)
         dataset = UpdateDataset_i();
+    if (!dataset)
+        return false;
 
     auto res = cli_cmd.Get("/image_buffer/image.cbor?id=" + std::to_string(image_number));
 

reader/JFJochHttpReader.h

@@ -15,7 +15,6 @@ class JFJochHttpReader : public JFJochReader {
                      std::vector<uint8_t> &buffer,
                      int64_t image_number,
                      bool update_dataset) override;
-    void Close_i();
     std::shared_ptr<JFJochReaderDataset> UpdateDataset_i();
     std::vector<float> GetPlot_i(const std::string &plot_type, float fill_value = 0.0) const;
 public:

reader/JFJochReader.cpp

@@ -31,9 +31,6 @@ std::shared_ptr<JFJochReaderImage> JFJochReader::LoadImage(int64_t image_number,
     // yet copying share_ptr pointer is atomic and needs no mutex protection
     std::unique_lock ul(m);
 
-    if (!dataset)
-        return {};
-
     std::vector<uint8_t> buffer;
     DataMessage msg;
 
@@ -67,8 +64,6 @@ void JFJochReader::SetStartMessage(const std::shared_ptr<JFJochReaderDataset> &v
 
 std::shared_ptr<const JFJochReaderDataset> JFJochReader::GetDataset() const {
     std::unique_lock ul(m);
-    if (!dataset)
-        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "File not loaded");
     return dataset;
 }
 

reader/JFJochReader.h

@@ -19,7 +19,6 @@ class JFJochReader {
     mutable std::mutex m;
     std::shared_ptr<JFJochReaderDataset> dataset;
 
-
     virtual bool LoadImage_i(std::shared_ptr<JFJochReaderDataset> &dataset,
                              DataMessage& message,
                              std::vector<uint8_t> &buffer,

viewer/JFJochImageReadingWorker.cpp

@@ -34,39 +34,39 @@ void JFJochImageReadingWorker::LoadFile(const QString &filename, qint64 image_nu
         std::shared_ptr<const JFJochReaderDataset> dataset;
         auto start = std::chrono::high_resolution_clock::now();
 
-        if (!http_mode && filename == current_file) {
-            logger.Info("File {} already loaded", filename.toStdString());
-        } else {
-            if (filename.startsWith("http://")) {
-                http_mode = true;
-                http_reader.ReadURL(filename.toStdString());
-                total_images = http_reader.GetNumberOfImages();
-                dataset = http_reader.GetDataset();
-                if (image_number < 0)
-                    setAutoLoadMode_i(AutoloadMode::HTTPSync);
-                else
-                    setAutoLoadMode_i(AutoloadMode::None);
-            } else {
-                http_mode = false;
-                file_reader.ReadFile(filename.toStdString());
-                total_images = file_reader.GetNumberOfImages();
-                dataset = file_reader.GetDataset();
+        if (filename.startsWith("http://")) {
+            http_mode = true;
+            http_reader.ReadURL(filename.toStdString());
+            total_images = http_reader.GetNumberOfImages();
+            dataset = http_reader.GetDataset();
+            if (image_number < 0)
+                setAutoLoadMode_i(AutoloadMode::HTTPSync);
+            else
                 setAutoLoadMode_i(AutoloadMode::None);
-            }
-            current_image.reset();
-            current_summation = 1;
-            current_file = filename;
+
+        } else {
+            http_mode = false;
+            file_reader.ReadFile(filename.toStdString());
+            total_images = file_reader.GetNumberOfImages();
+            dataset = file_reader.GetDataset();
+            setAutoLoadMode_i(AutoloadMode::None);
+        }
+
+        current_image.reset();
+        current_summation = 1;
+        current_file = filename;
+        if (dataset) {
             curr_experiment = dataset->experiment;
             curr_experiment.ImportIndexingSettings(indexing_settings);
             curr_experiment.ImportAzimuthalIntegrationSettings(azint_settings);
             UpdateAzint_i(dataset.get());
-            emit datasetLoaded(dataset);
         }
 
+        emit datasetLoaded(dataset);
+
         auto end = std::chrono::high_resolution_clock::now();
         auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
         logger.Info("Loaded file {} in {} ms", filename.toStdString(), duration);
-
         LoadImage_i(image_number, summation);
     } catch (std::exception &e) {
         logger.Error("Error loading file {} {}", filename.toStdString(), e.what());
@@ -110,19 +110,21 @@ void JFJochImageReadingWorker::UpdateAzint_i(const JFJochReaderDataset *dataset)
 void JFJochImageReadingWorker::LoadImage_i(int64_t image_number, int64_t summation) {
     // Assumes m locked!
     try {
-        if (summation <= 0 || image_number + summation > total_images)
+        if (summation <= 0)
             return;
 
         std::vector<int32_t> image;
         auto start = std::chrono::high_resolution_clock::now();
+
         if (http_mode) {
             if (image_number < 0 && summation != 1)
                 return;
             current_image_ptr = http_reader.LoadImage(image_number, summation);
             total_images = http_reader.GetNumberOfImages();
+            logger.Info("Total images {}", total_images);
             emit datasetLoaded(http_reader.GetDataset());
         } else {
-            if (image_number < 0)
+            if (image_number < 0 || image_number + summation > total_images)
                 return;
             current_image_ptr = file_reader.LoadImage(image_number, summation);
         }
@@ -418,6 +420,7 @@ void JFJochImageReadingWorker::AutoLoadTimerExpired() {
     QMutexLocker locker(&m);
     switch (autoload_mode) {
         case AutoloadMode::HTTPSync:
+            logger.Info("Sync");
             if (http_mode)
                 LoadImage_i(-1 , 1);
             break;