Spectrum

Download from [GitHub](https://github.com/BrainbitLLC/spectrum-lib-cpp) all folders and add .dll to your project by your preferred way.
            

The Android version is designed for APIs >= 21.

Neurosdk for android is distributed using JitPack as an aar library. Here is an example of adding SDK to an AndroidStudio project using gradle:

Add to `build.gradle` of project:

```
allprojects {
    repositories {
        ...
        maven { url 'https://jitpack.io' }
    }
}
```

and to `build.gradle` of app:

```
dependencies {
    implementation 'com.github.BrainbitLLC:SpectrumLib:version'
}
```

To prevent build errors add to build.gradle this settings:

```groovy
android {
    packagingOptions {
        pickFirst 'lib/x86_64/libc++_shared.so'
        pickFirst 'lib/x86_64/libfilters.so'
        pickFirst 'lib/x86/libc++_shared.so'
        pickFirst 'lib/x86/libfilters.so'
        pickFirst 'lib/arm64-v8a/libc++_shared.so'
        pickFirst 'lib/arm64-v8a/libfilters.so'
        pickFirst 'lib/armeabi-v7a/libfilters.so'
        pickFirst 'lib/armeabi-v7a/libc++_shared.so'
    }
    ...
}
```
            

coming soon...
            

> Python package available only for Windows

By pip:

```
pip install pyspectrum_lib
```

The package has the following structure:
 - spectrum_lib - the main package with the implementation of methods
 - libs - contain dll library files

SpectrumMath - one main module contains all methods of library

```python
from spectrum_lib import SpectrumMath
```
            

coming soon...
            

Coming soon...
            

Install latest version `SpectrumLib` package from NuGet Gallery in your preferred way.
            

int sampling_rate = 250; // raw signal sampling frequency
int fft_window = 1000; // spectrum calculation window length
int process_win_rate = 5; // spectrum calculation frequency
SpectrumMath* tSpectMathPtr = createSpectrumMath(sampling_rate, fft_window, process_win_rate);
            

int samplingRate = 250; // raw signal sampling frequency
int fftWindow = 1000; // spectrum calculation window length
int processWinRate = 5; // spectrum calculation frequency
SpectrumMath math = new SpectrumMath(samplingRate, fftWindow, processWinRate);
            

int samplingRate = 250; // raw signal sampling frequency
int fftWindow = 1000; // spectrum calculation window length
int processWinRate = 5; // spectrum calculation frequency
SpectrumMath math = new SpectrumMath(samplingRate, fftWindow, processWinRate);
            

sampling_rate = 250 # raw signal sampling frequency
fft_window = sampling_rate * 4 # spectrum calculation window length
process_win_rate = 5 # spectrum calculation frequency
spectrum_math = SpectrumMath(sampling_rate, fft_window, process_win_rate)
            

int bord_frequency = 50; // upper bound of frequencies for spectrum calculation
bool normalize_spect_by_bandwidth = true; // normalization of the EEG spectrum by the width of the wavebands
SpectrumMathInitParams(tSpectMathPtr, bord_frequency, normalize_spect_by_bandwidth);
            

int bordFrequency = 50; // upper bound of frequencies for spectrum calculation
boolean normalizeSpectByBandwidth = true; // normalization of the EEG spectrum by the width of the wavebands
math.initParams(bordFrequency, normalizeSpectByBandwidth);
            

int bordFrequency = 50; // upper bound of frequencies for spectrum calculation
bool normalizeSpectByBandwidth = true; // normalization of the EEG spectrum by the width of the wavebands
math.InitParams(bordFrequency, normalizeSpectByBandwidth);
            

bord_frequency = 50 # upper bound of frequencies for spectrum calculation
normalize_spect_by_bandwidth = True # normalization of the EEG spectrum by the width of the wavebands
pectrum_math.init_params(bord_frequency, normalize_spect_by_bandwidth)
            

double delta_coef = 0.0;
double theta_coef = 1.0;
double alpha_coef = 1.0;
double beta_coef = 1.0;
double gamma_coef = 0.0;
SpectrumMathSetWavesCoeffs(tSpectMathPtr, delta_coef, theta_coef, alpha_coef, beta_coef, gamma_coef);
            

double alphaCoef = 1.0;
double betaCoef  = 1.0;
double deltaCoef = 0.0;
double gammaCoef = 0.0;
double thetaCoef = 1.0;
math.setWavesCoeffs(deltaCoef, thetaCoef, alphaCoef, betaCoef, gammaCoef);
            

double alphaCoef = 1.0;
double betaCoef  = 1.0;
double deltaCoef = 0.0;
double gammaCoef = 0.0;
double thetaCoef = 1.0;
math.SetWavesCoeffs(deltaCoef, thetaCoef, alphaCoef, betaCoef, gammaCoef);
            

delta_coef = 0.0
theta_coef = 1.0
alpha_coef = 1.0
beta_coef = 1.0
gamma_coef = 0.0
spectrum_math.set_waves_coeffs(delta_coef, theta_coef, alpha_coef, beta_coef, gamma_coef)
            

SpectrumMathSetHanningWinSpect(tSpectMathPtr); // by Hanning (by default)

SpectrumMathSetHammingWinSpect(tSpectMathPtr); // by Hamming
            

math.setHanningWinSpect(); // by Hanning (by default)

math.setHammingWinSpect(); // by Hamming
            

math.SetHanningWinSpect(); // by Hanning (by default)

math.SetHammingWinSpect(); // by Hamming
            

spectrum_math.set_hanning_win_spect() # by Hanning (by default)

spectrum_math.set_hamming_win_spect() # by Hamming
            

double fftBinsFor1Hz = SpectrumMathGetFFTBinsFor1Hz(tSpectMathPtr);
            

double numberBinsFor1Hz = math.getFFTBinsFor1Hz();
            

double fftBinsFor1Hz = math.GetFFTBinsFor1Hz();
            

spectrum_math.get_fft_bins_for_1_hz()
            

double* raw_data = new double[SIGNAL_SAMPLES_COUNT];
SpectrumMathPushData(tSpectMathPtr, raw_data, SIGNAL_SAMPLES_COUNT);
SpectrumMathProcessData(tSpectMathPtr);
            

double[] samples = new double[SIGNAL_SAMPLES_COUNT];
math.pushData(data);
            

double[] samples = new double[SIGNAL_SAMPLES_COUNT];
math.PushData(samples);
// data processing into PushData method
            

samples = [0 for _ in range(sample_count)]
spectrum_math.push_data(samples)
spectrum_math.process_data()
            

uint32_t arr_sz = SpectrumMathReadSpectrumArrSize(tSpectMathPtr);

RawSpectrumData* raw_spect_data = new RawSpectrumData[arr_sz];
SpectrumMathReadRawSpectrumInfoArr(tSpectMathPtr, raw_spect_data, &arr_sz);

WavesSpectrumData* waves_spect_data = new WavesSpectrumData[arr_sz];
SpectrumMathReadWavesSpectrumInfoArr(tSpectMathPtr, waves_spect_data, &arr_sz);
            

RawSpectrumData[] rawSpectrumData = math.readRawSpectrumInfoArr();
WavesSpectrumData[] wavesSpectrumData = math.readWavesSpectrumInfoArr();
            

var rawSpectrumData   = _math.ReadRawSpectrumInfoArr();
var wavesSpectrumData = _math.ReadWavesSpectrumInfoArr();
            

raw_spectrum_data = spectrum_math.read_raw_spectrum_info_arr()
waves_spectrum_data = spectrum_math.read_waves_spectrum_info_arr()
            

SpectrumMathSetNewSampleSize(tSpectMathPtr);
            

math.setNewSampleSize();
            

math.SetNewSampleSize();
            

spectrum_math.set_new_sample_size()
            

double* vals_arr = new double[arr_size];
SpectrumMathComputeSpectrum(tSpectMathPtr, vals_arr, arr_size);
            

double[] samples = new double[SIGNAL_SAMPLES_COUNT];
math.computeSpectrum(samples);
            

double[] samples = new double[SIGNAL_SAMPLES_COUNT];
math.ComputeSpectrum(samples);
            

samples = [0 for _ in range(sample_count)]
spectrum_math.compute_spectrum(samples)
            

RawSpectrumData raw_spect_data;
SpectrumMathReadRawSpectrumInfo(tSpectMathPtr, &raw_spect_data);

WavesSpectrumData waves_spect_data;
SpectrumMathReadWavesSpectrumInfo(tSpectMathPtr, &waves_spect_data)
            

RawSpectrumData rawSpectrumData = math.readRawSpectrumInfo();
WavesSpectrumData wavesSpectrumData = math.readWavesSpectrumInfo();
            

RawSpectrumData data = math.ReadRawSpectrumInfo();
WavesSpectrumData waves = math.ReadWavesSpectrumInfo();
            

raw_spectrum_data = spectrum_math.read_raw_spectrum_info()
waves_spectrum_data = spectrum_math.read_waves_spectrum_info()
            

SpectrumMathClearData(tSpectMathPtr);
            

math.clearData();
            

math.ClearData();
            

del spectrum_lib