Merge remote-tracking branch 'origin/master' into recondemopy

Author: KrisThielemans

documentation/release_6.3.htm

@@ -77,7 +77,14 @@ <h4>Python</h4>
       <code>a = b + c</code> and <code>a -= 3</code>. Note that <code>a = 1 + b</code> is not
       yet available.<br>
       <a href=https://github.com/UCL/STIR/pull/1630>PR #1630</a>
-      </li>
+    </li>
+    <li>
+      The above "container" classes now have an extra member `as_array()` which returns a numpy <code>ndarray</code>. This
+      is equivalent to `stirextra.to_numpy()` which will become deprecated later. In addition, the
+      <code>fill()</code> method now directly accepts an <code>ndarray</code>, avoiding the need to go via an iterator.
+      These additions also make it easier to prt SIRF python code to STIR.<br>
+      <a href=https://github.com/UCL/STIR/pull/1632>PR #1632</a>
+    </li>
     <li>
       Added a Python script to convert e7tools generated Siemens Biograph Vision 600 sinograms to STIR compatible format.<br>
       <a href=https://github.com/UCL/STIR/pull/1593>PR #1593</a>

src/include/stir/recon_buildblock/PoissonLogLikelihoodWithLinearModelForMean.h

@@ -180,15 +180,19 @@ class PoissonLogLikelihoodWithLinearModelForMean : public GeneralisedObjectiveFu
   bool get_recompute_sensitivity() const;
 
   //! get filename to read (or write) the total sensitivity
-  /*! will be a zero string if not set */
+  /*! will be a zero-length string if not set */
   std::string get_sensitivity_filename() const;
   //! get filename pattern to read (or write) the subset sensitivities
-  /*! will be a zero string if not set.
+  /*! will be a zero-length string if not set.
   Could be e.g. "subsens_%d.hv"
   fmt::format is used with the pattern
  */
   std::string get_subsensitivity_filenames() const;
 
+  //!  Return the filename for a particular subset
+  /*! \sa get_subsensitivity_filenames() */
+  std::string get_subsensitivity_filename(const int subset_num) const;
+
   /*! \name Functions to set parameters
     This can be used as alternative to the parsing mechanism.
    \warning After using any of these, you have to call set_up().

src/recon_buildblock/PoissonLogLikelihoodWithLinearModelForMean.cxx

@@ -67,7 +67,8 @@ PoissonLogLikelihoodWithLinearModelForMean<TargetT>::post_processing()
 {
   if (base_type::post_processing() == true)
     return true;
-
+  // call set, which will do some checks
+  this->set_subsensitivity_filenames(this->subsensitivity_filenames);
   return false;
 }
 
@@ -85,6 +86,19 @@ PoissonLogLikelihoodWithLinearModelForMean<TargetT>::get_subsensitivity_filename
   return this->subsensitivity_filenames;
 }
 
+template <typename TargetT>
+std::string
+PoissonLogLikelihoodWithLinearModelForMean<TargetT>::get_subsensitivity_filename(const int subset_num) const
+{
+  if (this->subsensitivity_filenames.empty())
+    return this->subsensitivity_filenames;
+
+  if (this->subsensitivity_filenames.find("%") != std::string::npos)
+    return boost::str(boost::format(this->subsensitivity_filenames) % subset_num);
+  else
+    return runtime_format(this->subsensitivity_filenames, subset_num);
+}
+
 template <typename TargetT>
 void
 PoissonLogLikelihoodWithLinearModelForMean<TargetT>::set_sensitivity_filename(const std::string& filename)
@@ -101,20 +115,17 @@ PoissonLogLikelihoodWithLinearModelForMean<TargetT>::set_subsensitivity_filename
   this->subsensitivity_filenames = filenames;
   try
     {
-      if (this->subsensitivity_filenames.find("%"))
+      if (this->subsensitivity_filenames.find("%") != std::string::npos)
         {
-          warning("The subsensitivity_filenames pattern is using the boost::format convention ('\%d')."
+          warning("The subsensitivity_filenames pattern is using the boost::format convention ('%%d')."
                   "It is recommended to use fmt::format/std::format style formatting ('{}').");
-          const std::string test_sensitivity_filename = boost::str(boost::format(this->subsensitivity_filenames) % 0);
-        }
-      else
-        {
-          const std::string test_sensitivity_filename = runtime_format(this->subsensitivity_filenames.c_str(), 0);
         }
+      const std::string test_sensitivity_filename = this->get_subsensitivity_filename(0);
     }
   catch (std::exception& e)
     {
-      error(format("argument {} to set_subsensitivity_filenames is invalid (see fmt::format documentation)\n. Error message: {}",
+      error(format("argument {} to set_subsensitivity_filenames is invalid (see fmt::format or boost::format documentation)\n. "
+                   "Error message: {}",
                    filenames.c_str(),
                    e.what()));
     }
@@ -224,35 +235,25 @@ PoissonLogLikelihoodWithLinearModelForMean<TargetT>::set_up(shared_ptr<TargetT>
                   // read subsensitivies
                   for (int subset = 0; subset < this->get_num_subsets(); ++subset)
                     {
-                      std::string current_sensitivity_filename;
-                      try
+                      const std::string current_sensitivity_filename = this->get_subsensitivity_filename(subset);
+
+                      if (subset > 0)
                         {
-                          if (this->subsensitivity_filenames.find("%"))
-                            {
-                              warning("The subsensitivity_filenames pattern is using the boost::format convention ('\%d')."
-                                      "It is recommended to use fmt::format/std::format style formatting ('{}').");
-                              current_sensitivity_filename = boost::str(boost::format(this->subsensitivity_filenames) % subset);
-                            }
-                          else
+                          if (current_sensitivity_filename == this->get_subsensitivity_filename(0))
                             {
-                              current_sensitivity_filename = runtime_format(this->subsensitivity_filenames.c_str(), subset);
+                              error(format(
+                                  "subset sensitivity filename pattern should lead to a different filename for every subset,"
+                                  "but seems to always give '{}'",
+                                  current_sensitivity_filename));
                             }
                         }
-                      catch (std::exception& e)
-                        {
-                          error(format("Error using 'subset sensitivity filenames' pattern (which is set to '{}'). "
-                                       "Check syntax for fmt::format. Error is:\n{}",
-                                       this->subsensitivity_filenames,
-                                       e.what()));
-                          return Succeeded::no;
-                        }
                       info(format("Reading sensitivity from '{}'", current_sensitivity_filename));
 
                       this->subsensitivity_sptrs[subset] = read_from_file<TargetT>(current_sensitivity_filename);
                       string explanation;
                       if (!target_sptr->has_same_characteristics(*this->subsensitivity_sptrs[subset], explanation))
                         {
-                          error("sensitivity and target should have the same characteristics.\n%s", explanation.c_str());
+                          error("sensitivity and target should have the same characteristics.\n" + explanation);
                           return Succeeded::no;
                         }
                     }
@@ -321,8 +322,7 @@ PoissonLogLikelihoodWithLinearModelForMean<TargetT>::set_up(shared_ptr<TargetT>
                 {
                   for (int subset = 0; subset < this->get_num_subsets(); ++subset)
                     {
-                      const std::string current_sensitivity_filename
-                          = runtime_format(this->subsensitivity_filenames.c_str(), subset);
+                      const std::string current_sensitivity_filename = this->get_subsensitivity_filename(subset);
                       info(format("Writing sensitivity to '{}'", current_sensitivity_filename));
                       write_to_file(current_sensitivity_filename, this->get_subset_sensitivity(subset));
                     }