Cache SpikeViewer settings

Author: medengineer

Plugins/BasicSpikeDisplay/SpikeDetector/PopupConfigurationWindow.h

@@ -105,7 +105,7 @@ class ChannelSelectorCustomComponent :
         for (int i = 0; i < newChannels.size(); i++)
         {
             newArray.add(newChannels[i]);
-            std::cout << "Channel " << newChannels[i] << " selected" << std::endl;
+            LOGD("Channel ", newChannels[i], " selected");
         }
 
         String s = "[";

Plugins/BasicSpikeDisplay/SpikeDisplayNode/SpikeDisplay.cpp

@@ -59,6 +59,8 @@ void SpikeDisplay::clear()
 SpikePlot* SpikeDisplay::addSpikePlot(int numChannels, int electrodeNum, String name_)
 {
 
+    LOGD("Adding spike plot for electrode: ", electrodeNum, " named: ", name_, " with ", numChannels, " channels");
+
     SpikePlot* spikePlot = new SpikePlot(canvas, electrodeNum, 1000 + numChannels, name_);
     spikePlots.add(spikePlot);
     addAndMakeVisible(spikePlot);
@@ -266,3 +268,15 @@ void SpikeDisplay::setRangeForWaveAxis(int plotNum, int axisNum, float range)
     if (spikePlots.size() > plotNum)
         return spikePlots[plotNum]->setRangeForChannel(axisNum, range);
 }
+
+bool SpikeDisplay::getMonitorStateForPlot(int plotNum)
+{
+    if (spikePlots.size() > plotNum)
+        return spikePlots[plotNum]->getMonitorState();
+}
+
+void SpikeDisplay::setMonitorStateForPlot(int plotNum, bool state)
+{
+    if (spikePlots.size() > plotNum)
+        return spikePlots[plotNum]->setMonitorState(state);
+}

Plugins/BasicSpikeDisplay/SpikeDisplayNode/SpikeDisplay.h

@@ -95,6 +95,12 @@ class SpikeDisplay : public Component
     /** Sets the range for a given plot*/
     void setRangeForWaveAxis(int plotNum, int axisNum, float range);
 
+    /** Returns the monitor state for a given plot*/
+    bool getMonitorStateForPlot(int plotNum);
+
+    /** Sets the monitor state for a given plot*/
+    void setMonitorStateForPlot(int plotNum, bool monitorState);
+
     /** Allows the threshold coordinator to change thresholds synchronously*/
     void registerThresholdCoordinator(SpikeThresholdCoordinator* stc);
 

Plugins/BasicSpikeDisplay/SpikeDisplayNode/SpikeDisplayCanvas.cpp

@@ -110,6 +110,25 @@ SpikeDisplayCanvas::SpikeDisplayCanvas(SpikeDisplayNode* processor_) :
     update();
 }
 
+void SpikeDisplayCanvas::cacheDisplaySettings(int electrode, int channel, double threshold, double range, bool isMonitored)
+{
+    thresholds[electrode][channel] = threshold;
+    ranges[electrode][channel] = range;
+    monitors[electrode] = isMonitored;
+}
+
+bool SpikeDisplayCanvas::hasCachedDisplaySettings(int electrode, int channel)
+{
+    return thresholds[electrode].count(channel) > 0;
+}
+
+void SpikeDisplayCanvas::invalidateDisplaySettings(int electrodeIndex)
+{
+    thresholds.erase(electrodeIndex);
+    ranges.erase(electrodeIndex);
+    monitors.erase(electrodeIndex);
+}
+
 
 void SpikeDisplayCanvas::update()
 {
@@ -128,22 +147,27 @@ void SpikeDisplayCanvas::update()
                                                    processor->getNameForElectrode(i));
         processor->addSpikePlotForElectrode(sp, i);
 
-        if (shouldApplySavedParams)
+        if (monitors.size())
         {
+
+            spikeDisplay->setMonitorStateForPlot(i, monitors[i]);
+
             for (int j = 0; j < processor->getNumberOfChannelsForElectrode(i); j++)
             {
+
+                LOGD("Updating spike plot: ", i, " channel: ", j, " threshold: ", thresholds[i][j], " range: ", ranges[i][j])
                 spikeDisplay->setThresholdForWaveAxis(i,j,thresholds[i][j]);
                 spikeDisplay->setRangeForWaveAxis(i,j,ranges[i][j]);
+                spikeDisplay->setMonitorStateForPlot(i,monitors[i]);
             }
+
         }
     }
 
     spikeDisplay->resized();
 
 }
 
-
-
 void SpikeDisplayCanvas::refreshState()
 {
     // called when the component's tab becomes visible again
@@ -215,11 +239,14 @@ void SpikeDisplayCanvas::saveCustomParametersToXml(XmlElement* xml)
     {
         XmlElement* plotNode = xmlNode->createNewChildElement("PLOT");
 
+        plotNode->setAttribute("isMonitored", spikeDisplay->getMonitorStateForPlot(i));
+
         for (int j = 0; j < spikeDisplay->getNumChannelsForPlot(i); j++)
         {
             XmlElement* axisNode = plotNode->createNewChildElement("AXIS");
             axisNode->setAttribute("thresh",spikeDisplay->getThresholdForWaveAxis(i,j));
             axisNode->setAttribute("range",spikeDisplay->getRangeForWaveAxis(i,j));
+
         }
     }
 
@@ -248,6 +275,8 @@ void SpikeDisplayCanvas::loadCustomParametersFromXml(XmlElement* xml)
 
                     plotIndex++;
 
+                    monitors[plotIndex] = plotNode->getBoolAttribute("isMonitored");
+
                     //std::cout << "PLOT NUMBER " << plotIndex << std::endl;
 
                     int channelIndex = -1;
@@ -266,5 +295,4 @@ void SpikeDisplayCanvas::loadCustomParametersFromXml(XmlElement* xml)
         }
     }
 
-    shouldApplySavedParams = true;
 }

Plugins/BasicSpikeDisplay/SpikeDisplayNode/SpikeDisplayCanvas.h

@@ -125,6 +125,12 @@ class SpikeDisplayCanvas : public Visualizer,
     /** Pointer to the underlying SpikeDisplayNode*/
     SpikeDisplayNode* processor;
 
+    void cacheDisplaySettings(int electrodeIndex, int channelIndex, double threshold, double range, bool isMonitored);
+
+    bool hasCachedDisplaySettings(int electrodeIndex, int channelIndex);
+
+    void invalidateDisplaySettings(int electrodeIndex);
+
 private:
 
     std::unique_ptr<SpikeDisplay> spikeDisplay;
@@ -141,7 +147,7 @@ class SpikeDisplayCanvas : public Visualizer,
 
     std::map<int, std::map<int, double>> ranges;
     std::map<int, std::map<int, double>> thresholds;
-    bool shouldApplySavedParams = false;
+    std::map<int, bool> monitors;
 
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(SpikeDisplayCanvas);
 

Plugins/BasicSpikeDisplay/SpikeDisplayNode/SpikePlots.cpp

@@ -84,6 +84,9 @@ SpikePlot::SpikePlot(SpikeDisplayCanvas* sdc,
 
         rangeButtons.add(rangeButton);
         setDisplayThresholdForChannel(i, 0);
+
+        if (!canvas->hasCachedDisplaySettings(electrodeNumber, i))
+            canvas->cacheDisplaySettings(electrodeNumber, i, 0, 250.0, false);
     }
 
     monitorButton = std::make_unique<UtilityButton>("MON", Font("Small Text", 8, Font::plain));
@@ -286,6 +289,13 @@ void SpikePlot::buttonClicked(Button* button)
 
     setLimitsOnAxes();
 
+    LOGD("Updating electrode: ", electrodeNumber, " range: ", ranges[index], " index: ", index);
+
+    double threshold = getDisplayThresholdForChannel(index);
+    bool monitorState = monitorButton->getToggleState();
+
+    canvas->cacheDisplaySettings(electrodeNumber, index, threshold, ranges[index], monitorState);
+
 }
 
 void SpikePlot::setLimitsOnAxes()
@@ -370,6 +380,16 @@ void SpikePlot::setRangeForChannel(int i, float range)
     rangeButtons[i]->setLabel(String(int(range)));
 }
 
+bool SpikePlot::getMonitorState()
+{
+    return monitorButton->getToggleState();
+}
+
+void SpikePlot::setMonitorState(bool state)
+{
+    monitorButton->setToggleState(state, sendNotification);
+}
+
 void SpikePlot::setDetectorThresholdForChannel(int i, float t)
 {
     // std::cout << "Setting threshold to " << t << std::endl;

Plugins/BasicSpikeDisplay/SpikeDisplayNode/SpikePlots.h

@@ -114,9 +114,18 @@ class SpikePlot : public Component,
     void setDisplayThresholdForChannel(int axisNum, float threshold);
     void setDetectorThresholdForChannel(int, float);
 
+    /** Returns the range for a given channel*/
     float getRangeForChannel(int);
+
+    /** Sets the range for a given channel*/
     void setRangeForChannel(int axisNum, float range);
 
+    /**Returns the monitor state for this electrode */
+    bool getMonitorState();
+
+    /** Sets the monitor state for this electrode */
+    void setMonitorState(bool);
+
     //For locking the tresholds
     void registerThresholdCoordinator(SpikeThresholdCoordinator* stc);
     void setAllThresholds(float displayThreshold, float range);