Fixup some issues with background/secondary peaks.

The D3SpectrumDisplayDiv was displaying the primary spectrum instance background peaks for any instance of D3SpectrumDisplayDiv.
Moved to having the PeakModel also track background/secondary peaks, but in a very limited way - you can only set all the peaks for background/secondary - which triggers a single signal that these peaks were changed - not the granularity that the foreground offers.
So now D3SpectrumDisplayDiv uses the PeakModel to track and get the background/secondary peaks.

Author: wcjohns

InterSpec/InterSpec.h

@@ -383,7 +383,10 @@ class InterSpec : public Wt::WContainerWidget
                           const SpecUtils::SpectrumType spec_type,
                           const std::string &ref_line_name = "" );
 
-  /** Sets the peaks for the given spectrum.  If foreground, you should consider instead to use the PeakModel.
+  /** Sets the peaks for the given spectrum - taking care of adding a undo/redo step.
+   
+   If you do not wish to add a undo/redo step, you can call `PeakModel::setPeaks(peaks,SpectrumType).`
+   (the undo/redo is the only differnce between calling this function and the PeakModel function directly).
    
    @param spectrum Which spectrum to set the peaks for.
    @param peaks The peaks to set.  Must not be nullptr, or the currently set deque of peaks.

InterSpec/PeakModel.h

@@ -40,7 +40,11 @@
 
 class SpecMeas;
 
-namespace SpecUtils{ class Measurement; }
+namespace SpecUtils
+{
+  class Measurement;
+  enum class SpectrumType : int;
+}
 
 namespace SandiaDecay
 {
@@ -60,6 +64,9 @@ class PeakModel: public Wt::WAbstractItemModel
    That is, the row specifies the peak, and the column represents
    various peak values, as specified by the 'Columns' enum.
    
+   All functions refer to the foreground, except `peaks(SpectrumType)` and `measurement(SpectrumType)` - which just returns what
+   `setPeakFromSpecMeas(...)` was last called for the type (currently only the main InterSpec class do anything other than for foreground).
+   
    Incomplete TODO list:
    - add a `replacePeaks(orig,newer)` function to allow updating peak quanitites in one step
    - Or allow setting kLowerX/kUpperX columns in setData(...) function
@@ -98,7 +105,8 @@ class PeakModel: public Wt::WAbstractItemModel
   //  or the displayed sample numbers), then this function should be called to
   //  update the m_peaks pointer to be from the appropriate SpecMeas object.
   void setPeakFromSpecMeas( std::shared_ptr<SpecMeas> meas,
-                            const std::set<int> &samplenums );
+                            const std::set<int> &samplenums,
+                            const SpecUtils::SpectrumType specType );
 
   /** Normally we keep the peaks added/removed up to date with the #SpecMeas passed into
    #setPeakFromSpecMeas (i.e., the #SpecMeas "owns" the peaks), but if you dont want to do
@@ -141,6 +149,26 @@ class PeakModel: public Wt::WAbstractItemModel
 
   const std::deque<std::shared_ptr<const PeakDef>> &sortedPeaks() const;
 
+  /** Get the currently set peaks - this requires that `setPeakFromSpecMeas(spec, samples, type)`
+   has been called to set these - currently the only place that does this for anything besides the foreground is the main InterSpec class.
+   
+   All other functions in this class refer to foreground peaks, except `peaks(SpectrumType)` and `measurement(SpectrumType)`.
+   */
+  std::shared_ptr<const std::deque<std::shared_ptr<const PeakDef>>> peaks( const SpecUtils::SpectrumType type ) const;
+  
+  std::weak_ptr<SpecMeas> measurement( const SpecUtils::SpectrumType type );
+  
+  Wt::Signal<> &backgroundPeaksChanged();
+  Wt::Signal<> &secondaryPeaksChanged();
+  
+  
+  /** Get the currently set secondary peaks - this requires that `setPeakFromSpecMeas(back, backSamples, SpectrumType::SecondaryForeground)`
+   has been called to set these - currently the only place that does this is the main InterSpec class.
+   
+   All other functions in this class refer to foregorund peaks, except `backgroundPeaks()` and `secondaryPeaks()`.
+   */
+  std::shared_ptr<const std::deque<std::shared_ptr<const PeakDef>>> secondaryPeaks() const;
+  
   //definePeakXRangeAndChi2(...): Inorder to save cpu (and mostly memorry access
   //  time) later on, this function will define the lower and upper energy range
   //  of peaks that have a polynomial continum defined, and have not already had
@@ -176,6 +204,9 @@ class PeakModel: public Wt::WAbstractItemModel
    */
   void setPeaks( std::vector<std::shared_ptr<const PeakDef>> peaks );
 
+  
+  void setPeaks( const std::deque<std::shared_ptr<const PeakDef>> &peakdeque, const SpecUtils::SpectrumType type );
+  
   //removePeak( size_t ):  removes the specified `peakn`, where the peakn refers
   //  to the peak at position `peakn` when sorted by peak means (similar
   //  behavior as all other functions which refer to peaks by index).
@@ -439,8 +470,16 @@ class PeakModel: public Wt::WAbstractItemModel
 
   //Peaks are stored sorted according to peak.mean, since some of the algorithms
   //  that work on the peaks need them to be sorted by mean
-  std::shared_ptr< std::deque< PeakShrdPtr > > m_peaks;
-  std::weak_ptr<SpecMeas> m_measurment;
+  std::shared_ptr< std::deque< std::shared_ptr<const PeakDef> > > m_peaks;
+  std::weak_ptr<SpecMeas> m_measurment; //Foreground
+  
+  std::shared_ptr<std::deque<std::shared_ptr<const PeakDef>>> m_background_peaks;
+  std::weak_ptr<SpecMeas> m_background;
+  Wt::Signal<> m_backgroundPeaksChanged;
+  
+  std::shared_ptr<std::deque<std::shared_ptr<const PeakDef>>> m_secondary_peaks;
+  std::weak_ptr<SpecMeas> m_secondary;
+  Wt::Signal<> m_secondaryPeaksChanged;
 
   Columns m_sortColumn;
   Wt::SortOrder m_sortOrder;

src/D3SpectrumDisplayDiv.cpp

@@ -551,6 +551,8 @@ void D3SpectrumDisplayDiv::setPeakModel( PeakModel *model )
   m_peakModel->rowsInserted().connect(  boost::bind(&D3SpectrumDisplayDiv::schedulePeakRedraw, this, SpecUtils::SpectrumType::Foreground) );
   m_peakModel->layoutChanged().connect( boost::bind(&D3SpectrumDisplayDiv::schedulePeakRedraw, this, SpecUtils::SpectrumType::Foreground) );
   m_peakModel->modelReset().connect(    boost::bind(&D3SpectrumDisplayDiv::schedulePeakRedraw, this, SpecUtils::SpectrumType::Foreground) );
+  m_peakModel->backgroundPeaksChanged().connect( boost::bind(&D3SpectrumDisplayDiv::schedulePeakRedraw, this, SpecUtils::SpectrumType::Background) );
+  m_peakModel->secondaryPeaksChanged().connect( boost::bind(&D3SpectrumDisplayDiv::schedulePeakRedraw, this, SpecUtils::SpectrumType::SecondForeground) );
 }//void setPeakModel( PeakModel *model );
 
 
@@ -1374,7 +1376,7 @@ void D3SpectrumDisplayDiv::setForegroundPeaksToClient()
   
   if( m_peakModel )
   {
-    std::shared_ptr<const std::deque< PeakModel::PeakShrdPtr > > peaks = m_peakModel->peaks();
+    std::shared_ptr<const std::deque<shared_ptr<const PeakDef>> > peaks = m_peakModel->peaks();
     if( peaks )
     {
       vector< std::shared_ptr<const PeakDef> > inpeaks( peaks->begin(), peaks->end() );
@@ -1435,33 +1437,13 @@ void D3SpectrumDisplayDiv::setPeaksToClient( const SpecUtils::SpectrumType spect
   }//if( m_defaultPeakColor.isDefault() )
 
 
-  if( spectrum_type == SpecUtils::SpectrumType::Foreground )
+  shared_ptr<const deque<shared_ptr<const PeakDef>>> peaks = m_peakModel ? m_peakModel->peaks(spectrum_type) : nullptr;
+  if( peaks )
   {
-    shared_ptr<const deque< PeakModel::PeakShrdPtr > > peaks = m_peakModel ? m_peakModel->peaks() : nullptr;
-    if( peaks )
-    {
-      vector< std::shared_ptr<const PeakDef> > inpeaks( peaks->begin(), peaks->end() );
-      const std::shared_ptr<const Measurement> &foreground = m_foreground;
-      const WColor peak_color = m_defaultPeakColor.isDefault() ? WColor(0, 51, 255) : m_defaultPeakColor;
-      js = PeakDef::peak_json( inpeaks, foreground, peak_color, 255 );
-    }
-  }else if( InterSpec *viewer = InterSpec::instance() )
-  {
-    // This is totally not correct - the spectrum may not be the main InterSpec spectrum
-    std::shared_ptr<SpecMeas> meas = viewer->measurment( spectrum_type );
-    const std::set<int> &samples = viewer->displayedSamples( spectrum_type );
-    
-    if( meas && !samples.empty() )
-    {
-      std::shared_ptr<const std::deque< std::shared_ptr<const PeakDef> > > peaks = meas->peaks( samples );
-      if( peaks )
-      {
-        vector< std::shared_ptr<const PeakDef> > inpeaks( peaks->begin(), peaks->end() );
-        const WColor peak_color = m_defaultPeakColor.isDefault() ? WColor(0, 51, 255) : m_defaultPeakColor;
-        js = PeakDef::peak_json( inpeaks, spectrum_measurement, peak_color, alpha );
-      }
-    }
-  }//if( spectrum_type == SpecUtils::SpectrumType::Foreground ) / else
+    vector< std::shared_ptr<const PeakDef> > inpeaks( peaks->begin(), peaks->end() );
+    const WColor peak_color = m_defaultPeakColor.isDefault() ? WColor(0, 51, 255) : m_defaultPeakColor;
+    js = PeakDef::peak_json( inpeaks, spectrum_measurement, peak_color, alpha );
+  }
 
   if( js.empty() )
     js = "[]";
@@ -1913,8 +1895,8 @@ void D3SpectrumDisplayDiv::renderForegroundToClient()
     // Set the peak data for the spectrum
     if ( m_peakModel )
     {
-      std::shared_ptr<const std::deque< PeakModel::PeakShrdPtr > > peaks = m_peakModel->peaks();
-      vector< std::shared_ptr<const PeakDef> > inpeaks;
+      shared_ptr<const deque<shared_ptr<const PeakDef>>> peaks = m_peakModel->peaks();
+      vector<shared_ptr<const PeakDef>> inpeaks;
       if( peaks )
         inpeaks.insert( end(inpeaks), peaks->begin(), peaks->end() );
 
@@ -2556,51 +2538,26 @@ void D3SpectrumDisplayDiv::performExistingRoiEdgeDragWork( double new_lower_ener
                                                           std::string spectrum_type,
                                                           bool isfinal )
 {
-  std::unique_ptr<UndoRedoManager::PeakModelChange> peak_undo_creator;
+  assert( m_peakModel );
+  if( !m_peakModel )
+    return;
 
-  PeakModel *peakModel = nullptr;
-  shared_ptr<const Measurement> spectrum;
-  shared_ptr<const deque<PeakModel::PeakShrdPtr>> origpeaks;
-  shared_ptr<deque<PeakModel::PeakShrdPtr>> final_mondified_peaks;
+  std::unique_ptr<UndoRedoManager::PeakModelChange> peak_undo_creator;
+  if( isfinal )
+    peak_undo_creator.reset( new UndoRedoManager::PeakModelChange() );
 
   const bool for_background = (spectrum_type == "BACKGROUND");
   const bool for_secondary = (!for_background && (spectrum_type == "SECONDARY"));
-  SpecUtils::SpectrumType spec_type = SpecUtils::SpectrumType::Foreground;
+  assert( for_background || for_secondary || (spectrum_type == "FOREGROUND") );
+  const SpecUtils::SpectrumType spec_type = for_background ? SpecUtils::SpectrumType::Background
+          : (for_secondary ? SpecUtils::SpectrumType::SecondForeground : SpecUtils::SpectrumType::Foreground);
+  shared_ptr<const Measurement> spectrum = for_background ? m_background : (for_secondary ? m_secondary : m_foreground);
+  const shared_ptr<const deque<shared_ptr<const PeakDef>>> origpeaks = m_peakModel->peaks(spec_type);
+  
+  shared_ptr<deque<shared_ptr<const PeakDef>>> final_mondified_peaks;
+  if( (for_background || for_secondary) && isfinal && origpeaks )
+    final_mondified_peaks = make_shared<deque<shared_ptr<const PeakDef>>>( begin(*origpeaks), end(*origpeaks) );
 
-  if( for_background || for_secondary )
-  {
-    spectrum = for_background ? m_background : m_secondary;
-    spec_type = for_background ? SpecUtils::SpectrumType::Background : SpecUtils::SpectrumType::SecondForeground;
-    
-    InterSpec *viewer = InterSpec::instance();
-    assert( viewer );
-    if( !viewer )
-      return;
-    
-    shared_ptr<SpecMeas> meas = viewer->measurment( spec_type );
-    const set<int> &samples = viewer->displayedSamples( spec_type );
-    origpeaks = (meas && !samples.empty()) ? meas->peaks( samples ) : nullptr;
-    
-    if( isfinal && origpeaks )
-      final_mondified_peaks = make_shared<deque<PeakModel::PeakShrdPtr>>( begin(*origpeaks), end(*origpeaks) );
-  }else
-  {
-    assert( spectrum_type == "FOREGROUND" );
-    
-    spec_type = SpecUtils::SpectrumType::Foreground;
-    spectrum = m_foreground;
-    peakModel = m_peakModel;
-    origpeaks = peakModel ? peakModel->peaks() : nullptr;
-    
-    if( isfinal )
-      peak_undo_creator.reset( new UndoRedoManager::PeakModelChange() );
-    
-    
-    assert( peakModel );
-    if( !peakModel )
-      return;
-  }//if( background or secondary ) / else ( assume foreground )
-    
   assert( origpeaks && spectrum );
   if( !origpeaks || !spectrum )  //Shouldnt ever happen
     return;
@@ -2684,7 +2641,7 @@ void D3SpectrumDisplayDiv::performExistingRoiEdgeDragWork( double new_lower_ener
     {
       assert( final_mondified_peaks );
       final_mondified_peaks->erase( std::remove_if( begin(*final_mondified_peaks), end(*final_mondified_peaks),
-                                                   [&continuum]( const PeakModel::PeakShrdPtr &ptr ){
+                                                   [&continuum]( const shared_ptr<const PeakDef> &ptr ){
         return (continuum == ptr->continuum());
       }), end(*final_mondified_peaks) );
     }//if( isfinal && (for_background || for_secondary) )
@@ -2699,18 +2656,18 @@ void D3SpectrumDisplayDiv::performExistingRoiEdgeDragWork( double new_lower_ener
         {
           final_mondified_peaks->insert( end(*final_mondified_peaks), begin(new_roi_initial_peaks), end(new_roi_initial_peaks) );
           std::sort( begin(*final_mondified_peaks), end(*final_mondified_peaks), &PeakDef::lessThanByMeanShrdPtr );
-          InterSpec::instance()->setPeaks( spec_type, final_mondified_peaks );
+          m_peakModel->setPeaks( *final_mondified_peaks, spec_type );
         }else
         {
-          assert( peakModel );
+          assert( m_peakModel );
           // TODO: add a `PeakModel::replacePeaks(orig,newer)` function to allow updating peak quanitites in one step, or allow setting kLowerX/kUpperX columns in setData(...) function
-          peakModel->removePeaks( orig_roi_peaks );
+          m_peakModel->removePeaks( orig_roi_peaks );
 
           std::vector<PeakDef> peaks_to_add;
           for( auto p : new_roi_initial_peaks )
             peaks_to_add.push_back( *p );
 
-          peakModel->addPeaks( peaks_to_add );
+          m_peakModel->addPeaks( peaks_to_add );
         }
       }else
       {
@@ -2770,15 +2727,18 @@ void D3SpectrumDisplayDiv::performExistingRoiEdgeDragWork( double new_lower_ener
 
         if( for_background || for_secondary )
         {
-          final_mondified_peaks->insert( end(*final_mondified_peaks), begin(new_roi_initial_peaks), end(new_roi_initial_peaks) );
-          std::sort( begin(*final_mondified_peaks), end(*final_mondified_peaks), &PeakDef::lessThanByMeanShrdPtr );
-          
-          InterSpec::instance()->setPeaks( spec_type, final_mondified_peaks ); // will take care of undo/redo
+          if( origpeaks )
+          {
+            final_mondified_peaks->insert( end(*final_mondified_peaks), begin(new_roi_initial_peaks), end(new_roi_initial_peaks) );
+            std::sort( begin(*final_mondified_peaks), end(*final_mondified_peaks), &PeakDef::lessThanByMeanShrdPtr );
+            
+            m_peakModel->setPeaks( *final_mondified_peaks, spec_type ); // will take care of undo/redo
+          }
         }else
         {
-          assert( peakModel );
-          peakModel->removePeaks( orig_roi_peaks );
-          peakModel->addPeaks( peaks_to_add );
+          assert( m_peakModel );
+          m_peakModel->removePeaks( orig_roi_peaks );
+          m_peakModel->addPeaks( peaks_to_add );
         }
 
         m_continuum_being_drug.reset();
@@ -2797,11 +2757,11 @@ void D3SpectrumDisplayDiv::performExistingRoiEdgeDragWork( double new_lower_ener
       {
         if( for_background || for_secondary )
         {
-          InterSpec::instance()->setPeaks( spec_type, final_mondified_peaks ); //will take care of undo/redo
+          m_peakModel->setPeaks( *final_mondified_peaks, spec_type );
         }else
         {
-          assert( peakModel );
-          peakModel->removePeaks( orig_roi_peaks );
+          assert( m_peakModel );
+          m_peakModel->removePeaks( orig_roi_peaks );
         }
       }
     }//if( not narrow region ) / else
@@ -3070,7 +3030,7 @@ void D3SpectrumDisplayDiv::performDragCreateRoiWork( double lower_energy, double
 
         UndoRedoManager::PeakModelChange peak_undo_creator;
 
-        deque< PeakModel::PeakShrdPtr > preaddpeaks, postaddpeaks;
+        deque<shared_ptr<const PeakDef>> preaddpeaks, postaddpeaks;
         if( peakModel->peaks() ) //should always be true, but JIC
           preaddpeaks = *peakModel->peaks();
 
@@ -3085,7 +3045,7 @@ void D3SpectrumDisplayDiv::performDragCreateRoiWork( double lower_energy, double
         if( peakModel->peaks() ) //should always be true, but JIC
           postaddpeaks = *peakModel->peaks();
 
-        vector< PeakModel::PeakShrdPtr > added_peaks;
+        vector<shared_ptr<const PeakDef>> added_peaks;
         for( const auto &p : postaddpeaks )
         {
           if( !std::count(begin(preaddpeaks), end(preaddpeaks), p) )
@@ -3323,8 +3283,6 @@ D3SpectrumDisplayDiv::~D3SpectrumDisplayDiv()
   // Cleanup the instance-specific style rules we created.
   WCssStyleSheet &style = wApp->styleSheet();
   for( const auto &name_rule : m_cssRules )
-  {
     style.removeRule( name_rule.second );
-  }
   m_cssRules.clear();
 }//~D3SpectrumDisplayDiv()

src/DetectionLimitTool.cpp

@@ -1318,7 +1318,7 @@ DetectionLimitTool::DetectionLimitTool( InterSpec *viewer,
     m_our_meas = make_shared<SpecMeas>();
     m_our_meas->setDetector( primaryMeas->detector() );
     m_our_meas->add_measurement( ourspec, true );
-    m_peakModel->setPeakFromSpecMeas( m_our_meas, {ourspec->sample_number()} );
+    m_peakModel->setPeakFromSpecMeas( m_our_meas, {ourspec->sample_number()}, SpecUtils::SpectrumType::Foreground );
     m_chart->setData( ourspec, false );
   }//if( spec )
 

src/EnergyCalAddActions.cpp

@@ -567,6 +567,12 @@ void ConvertCalTypeTool::convertLowerChannelEnegies( const size_t ncoeffs,
 
   const auto foreground = viewer->measurment(SpecUtils::SpectrumType::Foreground);
   const auto &foreSamples = viewer->displayedSamples(SpecUtils::SpectrumType::Foreground);
+
+  const auto background = viewer->measurment(SpecUtils::SpectrumType::Background);
+  const auto &backSamples = viewer->displayedSamples(SpecUtils::SpectrumType::Background);
+
+  const auto secondary = viewer->measurment(SpecUtils::SpectrumType::SecondForeground);
+  const auto &secoSamples = viewer->displayedSamples(SpecUtils::SpectrumType::SecondForeground);
 
   for( const auto &mp : updated_peaks )
   {
@@ -576,7 +582,11 @@ void ConvertCalTypeTool::convertLowerChannelEnegies( const size_t ncoeffs,
     spec->setPeaks( newpeaks, samples );
 
     if( (spec == foreground) && (samples == foreSamples) )
-      peakmodel->setPeakFromSpecMeas( spec, samples);
+      peakmodel->setPeakFromSpecMeas( spec, samples, SpecUtils::SpectrumType::Foreground );
+    else if( (spec == background) && (samples == backSamples) )
+      peakmodel->setPeakFromSpecMeas( spec, samples, SpecUtils::SpectrumType::Background );
+    else if( (spec == secondary) && (samples == secoSamples) )
+      peakmodel->setPeakFromSpecMeas( spec, samples, SpecUtils::SpectrumType::SecondForeground );
   }//for( const auto &mp : updated_peaks )