Refactor FFT settings variables across the GUI and Add GlobalFFTSettings Class

Author: retiutut

OpenBCI_GUI/BandPowerEnums.pde

@@ -0,0 +1,121 @@
+
+public enum BPAutoClean implements IndexingInterface
+{
+    ON (0, "On"),
+    OFF (1, "Off");
+
+    private int index;
+    private String label;
+    private static BPAutoClean[] vals = values();
+
+    BPAutoClean(int _index, String _label) {
+        this.index = _index;
+        this.label = _label;
+    }
+
+    @Override
+    public String getString() {
+        return label;
+    }
+
+    @Override
+    public int getIndex() {
+        return index;
+    }
+
+    public static List<String> getEnumStringsAsList() {
+        List<String> enumStrings = new ArrayList<String>();
+        for (IndexingInterface val : vals) {
+            enumStrings.add(val.getString());
+        }
+        return enumStrings;
+    }
+}
+
+public enum BPAutoCleanThreshold implements IndexingInterface
+{
+    FORTY (0, 40f, "40 uV"),
+    FIFTY (1, 50f, "50 uV"),
+    SIXTY (2, 60f, "60 uV"),
+    SEVENTY (3, 70f, "70 uV"),
+    EIGHTY (4, 80f, "80 uV"),
+    NINETY (5, 90f, "90 uV"),
+    ONE_HUNDRED(6, 100f, "100 uV");
+
+    private int index;
+    private float value;
+    private String label;
+    private static BPAutoCleanThreshold[] vals = values();
+
+    BPAutoCleanThreshold(int _index, float _value, String _label) {
+        this.index = _index;
+        this.value = _value;
+        this.label = _label;
+    }
+
+    public float getValue() {
+        return value;
+    }
+
+    @Override
+    public String getString() {
+        return label;
+    }
+
+    @Override
+    public int getIndex() {
+        return index;
+    }
+
+    public static List<String> getEnumStringsAsList() {
+        List<String> enumStrings = new ArrayList<String>();
+        for (IndexingInterface val : vals) {
+            enumStrings.add(val.getString());
+        }
+        return enumStrings;
+    }
+}
+
+public enum BPAutoCleanTimer implements IndexingInterface
+{
+    HALF_SECOND (0, 500, ".5 sec"),
+    ONE_SECOND (1, 1000, "1 sec"),
+    THREE_SECONDS (2, 2000, "3 sec"),
+    FIVE_SECONDS (3, 5000, "5 sec"),
+    TEN_SECONDS (4, 10000, "10 sec"),
+    TWENTY_SECONDS (5, 20000, "20 sec"),
+    THIRTY_SECONDS(6, 30000, "30 sec");
+
+    private int index;
+    private float value;
+    private String label;
+    private static BPAutoCleanTimer[] vals = values();
+
+    BPAutoCleanTimer(int _index, float _value, String _label) {
+        this.index = _index;
+        this.value = _value;
+        this.label = _label;
+    }
+
+    public float getValue() {
+        return value;
+    }
+
+    @Override
+    public String getString() {
+        return label;
+    }
+
+    @Override
+    public int getIndex() {
+        return index;
+    }
+
+    public static List<String> getEnumStringsAsList() {
+        List<String> enumStrings = new ArrayList<String>();
+        for (IndexingInterface val : vals) {
+            enumStrings.add(val.getString());
+        }
+        return enumStrings;
+    }
+}

OpenBCI_GUI/DataProcessing.pde

@@ -28,24 +28,24 @@ void processNewData() {
     }
 
     //update the data buffers
-    for (int Ichan=0; Ichan < channelCount; Ichan++) {
+    for (int channel=0; channel < channelCount; channel++) {
         for(int i = 0; i < getCurrentBoardBufferSize(); i++) {
-            dataProcessingRawBuffer[Ichan][i] = (float)currentData.get(i)[exgChannels[Ichan]];
+            dataProcessingRawBuffer[channel][i] = (float)currentData.get(i)[exgChannels[channel]];
         }
 
-        dataProcessingFilteredBuffer[Ichan] = dataProcessingRawBuffer[Ichan].clone();
+        dataProcessingFilteredBuffer[channel] = dataProcessingRawBuffer[channel].clone();
     }
 
     //apply additional processing for the time-domain montage plot (ie, filtering)
     dataProcessing.process(dataProcessingFilteredBuffer, fftBuff);
 
     //look to see if the latest data is railed so that we can notify the user on the GUI
-    for (int Ichan=0; Ichan < globalChannelCount; Ichan++) is_railed[Ichan].update(dataProcessingRawBuffer[Ichan], Ichan);
+    for (int channel=0; channel < globalChannelCount; channel++) is_railed[channel].update(dataProcessingRawBuffer[channel], channel);
 
     //compute the electrode impedance. Do it in a very simple way [rms to amplitude, then uVolt to Volt, then Volt/Amp to Ohm]
-    for (int Ichan=0; Ichan < globalChannelCount; Ichan++) {
+    for (int channel=0; channel < globalChannelCount; channel++) {
         // Calculate the impedance
-        float impedance = (sqrt(2.0)*dataProcessing.data_std_uV[Ichan]*1.0e-6) / BoardCytonConstants.leadOffDrive_amps;
+        float impedance = (sqrt(2.0)*dataProcessing.data_std_uV[channel]*1.0e-6) / BoardCytonConstants.leadOffDrive_amps;
         // Subtract the 2.2kOhm resistor
         impedance -= BoardCytonConstants.series_resistor_ohms;
         // Verify the impedance is not less than 0
@@ -54,25 +54,24 @@ void processNewData() {
             impedance = 0;
         }
         // Store to the global variable
-        data_elec_imp_ohm[Ichan] = impedance;
+        data_elec_imp_ohm[channel] = impedance;
     }
 }
 
-void initializeFFTObjects(ddf.minim.analysis.FFT[] fftBuff, float[][] dataProcessingRawBuffer, int Nfft, float fs_Hz) {
-
+void initializeFFTObjects(ddf.minim.analysis.FFT[] fftBuff, float[][] dataProcessingRawBuffer, int fftPointCount, float fs_Hz) {
     float[] fooData;
-    for (int Ichan=0; Ichan < globalChannelCount; Ichan++) {
+    for (int channel=0; channel < globalChannelCount; channel++) {
         //make the FFT objects...Following "SoundSpectrum" example that came with the Minim library
-        fftBuff[Ichan].window(ddf.minim.analysis.FFT.HAMMING);
+        fftBuff[channel].window(ddf.minim.analysis.FFT.HAMMING);
 
         //do the FFT on the initial data
-        if (isFFTFiltered == true) {
-            fooData = dataProcessingFilteredBuffer[Ichan];  //use the filtered data for the FFT
+        if (globalFFTSettings.getDataIsFiltered()) {
+            fooData = dataProcessingFilteredBuffer[channel];  //use the filtered data for the FFT
         } else {
-            fooData = dataProcessingRawBuffer[Ichan];  //use the raw data for the FFT
+            fooData = dataProcessingRawBuffer[channel];  //use the raw data for the FFT
         }
-        fooData = Arrays.copyOfRange(fooData, fooData.length-Nfft, fooData.length);
-        fftBuff[Ichan].forward(fooData); //compute FFT on this channel of data
+        fooData = Arrays.copyOfRange(fooData, fooData.length-fftPointCount, fooData.length);
+        fftBuff[channel].forward(fooData); //compute FFT on this channel of data
     }
 }
 
@@ -112,37 +111,37 @@ class DataProcessing {
     }
 
     //Process data on a channel-by-channel basis
-    private synchronized void processChannel(int Ichan, float[][] data_forDisplay_uV, float[] prevFFTdata) {            
-        int Nfft = getNfftSafe();
+    private synchronized void processChannel(int channel, float[][] data_forDisplay_uV, float[] prevFFTdata) {            
+        int fftPointCount = getNumFFTPoints();
         double foo;
 
         // Filter the data in the time domain
         // TODO: Use double arrays here and convert to float only to plot data.
         // ^^^ This might not feasible or meaningful performance improvement. I looked into it a while ago and it seems we need floats for the FFT library also. -RW 2022)
         try {
-            double[] tempArray = floatToDoubleArray(data_forDisplay_uV[Ichan]);
+            double[] tempArray = floatToDoubleArray(data_forDisplay_uV[channel]);
 
             //Apply BandStop filter if the filter should be active on this channel
-            if (filterSettings.values.bandStopFilterActive[Ichan].isActive()) {
+            if (filterSettings.values.bandStopFilterActive[channel].isActive()) {
                 DataFilter.perform_bandstop(
                     tempArray,
                     currentBoard.getSampleRate(),
-                    filterSettings.values.bandStopStartFreq[Ichan],
-                    filterSettings.values.bandStopStopFreq[Ichan],
-                    filterSettings.values.bandStopFilterOrder[Ichan].getValue(),
-                    filterSettings.values.bandStopFilterType[Ichan].getValue(),
+                    filterSettings.values.bandStopStartFreq[channel],
+                    filterSettings.values.bandStopStopFreq[channel],
+                    filterSettings.values.bandStopFilterOrder[channel].getValue(),
+                    filterSettings.values.bandStopFilterType[channel].getValue(),
                     1.0);
             }
 
             //Apply BandPass filter if the filter should be active on this channel
-            if (filterSettings.values.bandPassFilterActive[Ichan].isActive()) {
+            if (filterSettings.values.bandPassFilterActive[channel].isActive()) {
                 DataFilter.perform_bandpass(
                     tempArray,
                     currentBoard.getSampleRate(),
-                    filterSettings.values.bandPassStartFreq[Ichan],
-                    filterSettings.values.bandPassStopFreq[Ichan],
-                    filterSettings.values.bandPassFilterOrder[Ichan].getValue(),
-                    filterSettings.values.bandPassFilterType[Ichan].getValue(),
+                    filterSettings.values.bandPassStartFreq[channel],
+                    filterSettings.values.bandPassStopFreq[channel],
+                    filterSettings.values.bandPassFilterOrder[channel].getValue(),
+                    filterSettings.values.bandPassFilterType[channel].getValue(),
                     1.0);
             }
 
@@ -190,66 +189,68 @@ class DataProcessing {
                     break;
             }
 
-            doubleToFloatArray(tempArray, data_forDisplay_uV[Ichan]);
+            doubleToFloatArray(tempArray, data_forDisplay_uV[channel]);
         } catch (BrainFlowError e) {
             e.printStackTrace();
         }
 
         //compute the standard deviation of the filtered signal...this is for the head plot
-        float[] fooData_filt = dataProcessingFilteredBuffer[Ichan];  //use the filtered data
+        float[] fooData_filt = dataProcessingFilteredBuffer[channel];  //use the filtered data
         fooData_filt = Arrays.copyOfRange(fooData_filt, fooData_filt.length-((int)fs_Hz), fooData_filt.length);   //just grab the most recent second of data
-        data_std_uV[Ichan]=std(fooData_filt); //compute the standard deviation for the whole array "fooData_filt"
+        data_std_uV[channel] = std(fooData_filt); //compute the standard deviation for the whole array "fooData_filt"
 
         //copy the previous FFT data...enables us to apply some smoothing to the FFT data
-        for (int I=0; I < fftBuff[Ichan].specSize(); I++) {
-            prevFFTdata[I] = fftBuff[Ichan].getBand(I); //copy the old spectrum values
+        for (int I=0; I < fftBuff[channel].specSize(); I++) {
+            prevFFTdata[I] = fftBuff[channel].getBand(I); //copy the old spectrum values
         }
 
         //prepare the data for the new FFT
         float[] fooData;
-        if (isFFTFiltered == true) {
-            fooData = dataProcessingFilteredBuffer[Ichan];  //use the filtered data for the FFT
+        if (globalFFTSettings.getDataIsFiltered()) {
+            fooData = dataProcessingFilteredBuffer[channel];  //use the filtered data for the FFT
         } else {
-            fooData = dataProcessingRawBuffer[Ichan];  //use the raw data for the FFT
+            fooData = dataProcessingRawBuffer[channel];  //use the raw data for the FFT
         }
-        fooData = Arrays.copyOfRange(fooData, fooData.length-Nfft, fooData.length);   //trim to grab just the most recent block of data
+        fooData = Arrays.copyOfRange(fooData, fooData.length-fftPointCount, fooData.length);   //trim to grab just the most recent block of data
         float meanData = mean(fooData);  //compute the mean
         for (int I=0; I < fooData.length; I++) fooData[I] -= meanData; //remove the mean (for a better looking FFT
 
         //compute the FFT
-        fftBuff[Ichan].forward(fooData); //compute FFT on this channel of data
+        fftBuff[channel].forward(fooData); //compute FFT on this channel of data
 
         // FFT ref: https://www.mathworks.com/help/matlab/ref/fft.html
         // first calculate double-sided FFT amplitude spectrum
-        for (int I=0; I <= Nfft/2; I++) {
-            fftBuff[Ichan].setBand(I, (float)(fftBuff[Ichan].getBand(I) / Nfft));
+        for (int I=0; I <= fftPointCount/2; I++) {
+            fftBuff[channel].setBand(I, (float)(fftBuff[channel].getBand(I) / fftPointCount));
         }
         // then convert into single-sided FFT spectrum: DC & Nyquist (i=0 & i=N/2) remain the same, others multiply by two.
-        for (int I=1; I < Nfft/2; I++) {
-            fftBuff[Ichan].setBand(I, (float)(fftBuff[Ichan].getBand(I) * 2));
+        for (int I=1; I < fftPointCount/2; I++) {
+            fftBuff[channel].setBand(I, (float)(fftBuff[channel].getBand(I) * 2));
         }
 
         //average the FFT with previous FFT data so that it makes it smoother in time
         double min_val = 0.01d;
-        for (int I=0; I < fftBuff[Ichan].specSize(); I++) {   //loop over each fft bin
+        float smoothingFactor = globalFFTSettings.getSmoothingFactor().getValue();
+        for (int I=0; I < fftBuff[channel].specSize(); I++) {   //loop over each fft bin
             if (prevFFTdata[I] < min_val) prevFFTdata[I] = (float)min_val; //make sure we're not too small for the log calls
-            foo = fftBuff[Ichan].getBand(I);
+            foo = fftBuff[channel].getBand(I);
             if (foo < min_val) foo = min_val; //make sure this value isn't too small
 
             if (true) {
                 //smooth in dB power space
-                foo =   (1.0d-smoothFac[smoothFac_ind]) * java.lang.Math.log(java.lang.Math.pow(foo, 2));
-                foo += smoothFac[smoothFac_ind] * java.lang.Math.log(java.lang.Math.pow((double)prevFFTdata[I], 2));
+                foo =   (1.0d - smoothingFactor) * java.lang.Math.log(java.lang.Math.pow(foo, 2));
+                foo += smoothingFactor * java.lang.Math.log(java.lang.Math.pow((double)prevFFTdata[I], 2));
                 foo = java.lang.Math.sqrt(java.lang.Math.exp(foo)); //average in dB space
             } else {
+                //LEGACY CODE -- NOT USED
                 //smooth (average) in linear power space
-                foo =   (1.0d-smoothFac[smoothFac_ind]) * java.lang.Math.pow(foo, 2);
-                foo+= smoothFac[smoothFac_ind] * java.lang.Math.pow((double)prevFFTdata[I], 2);
+                foo =   (1.0d - smoothingFactor) * java.lang.Math.pow(foo, 2);
+                foo+= smoothingFactor * java.lang.Math.pow((double)prevFFTdata[I], 2);
                 // take sqrt to be back into uV_rtHz
                 foo = java.lang.Math.sqrt(foo);
             }
-            fftBuff[Ichan].setBand(I, (float)foo); //put the smoothed data back into the fftBuff data holder for use by everyone else
-            // fftBuff[Ichan].setBand(I, 1.0f);  // test
+            fftBuff[channel].setBand(I, (float)foo); //put the smoothed data back into the fftBuff data holder for use by everyone else
+            // fftBuff[channel].setBand(I, 1.0f);  // test
         } //end loop over FFT bins
 
         // calculate single-sided psd by single-sided FFT amplitude spectrum
@@ -260,22 +261,22 @@ class DataProcessing {
         for (int i = 0; i < processing_band_low_Hz.length; i++) {
             float sum = 0;
             // int binNum = 0;
-            for (int Ibin = 0; Ibin <= Nfft/2; Ibin ++) { // loop over FFT bins
-                float FFT_freq_Hz = fftBuff[Ichan].indexToFreq(Ibin);   // center frequency of this bin
+            for (int Ibin = 0; Ibin <= fftPointCount/2; Ibin ++) { // loop over FFT bins
+                float FFT_freq_Hz = fftBuff[channel].indexToFreq(Ibin);   // center frequency of this bin
                 float psdx = 0;
                 // if the frequency matches a band
                 if (FFT_freq_Hz >= processing_band_low_Hz[i] && FFT_freq_Hz < processing_band_high_Hz[i]) {
-                    if (Ibin != 0 && Ibin != Nfft/2) {
-                        psdx = fftBuff[Ichan].getBand(Ibin) * fftBuff[Ichan].getBand(Ibin) * Nfft/currentBoard.getSampleRate() / 4;
+                    if (Ibin != 0 && Ibin != fftPointCount/2) {
+                        psdx = fftBuff[channel].getBand(Ibin) * fftBuff[channel].getBand(Ibin) * fftPointCount/currentBoard.getSampleRate() / 4;
                     }
                     else {
-                        psdx = fftBuff[Ichan].getBand(Ibin) * fftBuff[Ichan].getBand(Ibin) * Nfft/currentBoard.getSampleRate();
+                        psdx = fftBuff[channel].getBand(Ibin) * fftBuff[channel].getBand(Ibin) * fftPointCount/currentBoard.getSampleRate();
                     }
                     sum += psdx;
                     // binNum ++;
                 }
             }
-            avgPowerInBins[Ichan][i] = sum;   // total power in a band
+            avgPowerInBins[channel][i] = sum;   // total power in a band
             // println(i, binNum, sum);
         }
     }
@@ -284,8 +285,8 @@ class DataProcessing {
 
         float prevFFTdata[] = new float[fftBuff[0].specSize()];
 
-        for (int Ichan=0; Ichan < globalChannelCount; Ichan++) { 
-            processChannel(Ichan, data_forDisplay_uV, prevFFTdata);
+        for (int channel=0; channel < globalChannelCount; channel++) { 
+            processChannel(channel, data_forDisplay_uV, prevFFTdata);
         } //end the loop over channels.
 
         for (int i = 0; i < processing_band_low_Hz.length; i++) {
@@ -304,14 +305,14 @@ class DataProcessing {
         float[] refData_uV = dataProcessingFilteredBuffer[refChanInd];  //use the filtered data
         refData_uV = Arrays.copyOfRange(refData_uV, refData_uV.length-((int)fs_Hz), refData_uV.length);   //just grab the most recent second of data
         // Compute polarity of each channel
-        for (int Ichan=0; Ichan < globalChannelCount; Ichan++) {
-            float[] fooData_filt = dataProcessingFilteredBuffer[Ichan];  //use the filtered data
+        for (int channel=0; channel < globalChannelCount; channel++) {
+            float[] fooData_filt = dataProcessingFilteredBuffer[channel];  //use the filtered data
             fooData_filt = Arrays.copyOfRange(fooData_filt, fooData_filt.length-((int)fs_Hz), fooData_filt.length);   //just grab the most recent second of data
             float dotProd = calcDotProduct(fooData_filt, refData_uV);
             if (dotProd >= 0.0f) {
-                polarity[Ichan]=1.0;
+                polarity[channel]=1.0;
             } else {
-                polarity[Ichan]=-1.0;
+                polarity[channel]=-1.0;
             }
         }