void RecordData()
{
if (currentEEGCount > windowSize)
{
for (int i = windowSize - 2; i > 0; i--)
{
dataBuffer[i] = dataBuffer[i + 1];
}
dataBuffer[windowSize - 1] = EEGData.GetEEGData()[(int)channelToRecordFrom];
}
else
{
dataBuffer[currentEEGCount % windowSize] = EEGData.GetEEGData()[(int)channelToRecordFrom];
}
if (currentEEGCount < windowSize)
{
baselineArray[currentEEGCount] = EEGData.GetEEGData()[(int)channelToRecordFrom];
}
if (currentEEGCount == windowSize)
{
ProcessBaselinePowerSpectrum();
}
if ((currentEEGCount > windowSize) && ((currentEEGCount - windowSize) % 10 == 0))
{
ProcessData();
}
currentEEGCount++;
}
// Update is called once per frame
void Update()
{
if (EEGData.GetEEGData()[1] != 0)
{
Vector3 currentPosition = cube.transform.position;
Vector3 newPosition = new Vector3(currentPosition.x, EEGData.GetRelativeFrequency(EEGData.EEG_BANDS.ALPHA) * maxHeight, currentPosition.z);
cube.transform.position = Vector3.Lerp(currentPosition, newPosition, Time.deltaTime);
}
}
protected override void Manipulate()
{
Move(_handFeature.Position);
Renderer[] rends = GetComponentsInChildren <Renderer>();
foreach (Renderer rend in rends)
{
Color oldColour = rend.material.color;
float relAlpha = EEGData.GetRelativeAlpha();
Color newColour = new Color(relAlpha, 0.1f, (1.0f - relAlpha));
rend.material.color = Color.Lerp(oldColour, newColour, Time.deltaTime);
}
}
/// <summary>
/// Adds a data point to the list.
/// </summary>
/// <param name="data">An array with all the data.</param>
/// <param name="timestamp">The timestamp of when that particular data set was created.</param>
public void AddDataPoint(float[] data, double timestamp)
{
if (data.Length != nChannels)
{
Debug.LogError("You are trying to add data from an incorrect channel count.");
}
else
{
EEGData currentData = new EEGData(data, timestamp);
dataSet.Add(currentData);
}
}
void RecordData()
{
lastEEGreceived = currentEEGreceived;
currentEEGreceived = EEGData.GetEEGData()[1];
currentColour = material.color;
if (currentEEGreceived != lastEEGreceived)
{
newColour = new Color(1.0f - currentColour.r, 1.0f - currentColour.g, 1.0f - currentColour.b);
}
else
{
newColour = currentColour;
}
material.SetColor("_EmissionColor", Color.Lerp(currentColour, newColour, Time.deltaTime / Time.fixedDeltaTime));
}
// Update is called once per frame
void Update()
{
if (Time.time - timeLastUpdated >= timeBetweenUpdates)
{
float alphaThetaRatio = Mathf.Pow(10f, EEGData.GetAverage(EEGData.EEG_BANDS.ALPHA)) / Mathf.Pow(10f, EEGData.GetAverage(EEGData.EEG_BANDS.THETA));
if (alphaThetaRatio > 1)
{
audio.pitch += stepSize;
}
else
{
audio.pitch -= stepSize;
}
timeLastUpdated = Time.time;
}
}
public static float GetRelativeFrequency(EEG_BANDS freqBand, int samplesBefore = 0)
{
float sumBands = 0f;
foreach (EEG_BANDS eegBand in Enum.GetValues(typeof(EEG_BANDS)))
{
sumBands += Mathf.Abs(EEGData.GetAverage(eegBand, samplesBefore));
}
float relFreq = 0f;
if (sumBands > 0)
{
relFreq = Mathf.Abs(EEGData.GetAverage(freqBand, samplesBefore) / sumBands);
}
return(relFreq);
}
// Update is called once per frame
void Update()
{
float relAlpha = 0f;
try {
relAlpha = EEGData.GetRelativeFrequency(EEGData.EEG_BANDS.ALPHA);
if (relAlpha >= alphaThreshold && currentColour < 1.0f)
{
currentColour += stepSize;
}
else if (currentColour > 0f)
{
currentColour -= stepSize;
}
} catch {
}
RenderSettings.skybox.SetColor("_Tint", Color.Lerp(NIGHT_COLOUR, DAY_COLOUR, currentColour));
DynamicGI.UpdateEnvironment();
}
void RaiseTerrainUnderPointer()
{
RaycastHit hit = pointerRenderer.GetDestinationHit();
Vector3 point = hit.point;
int areax;
int areaz;
float smoothing;
int terX = (int)((point.x / terrain.terrainData.size.x) * xResolution);
int terZ = (int)((point.z / terrain.terrainData.size.z) * zResolution);
lenx += smooth;
lenz += smooth;
terX -= (lenx / 2);
terZ -= (lenz / 2);
if (terX < 0)
{
terX = 0;
}
if (terX > xResolution)
{
terX = xResolution;
}
if (terZ < 0)
{
terZ = 0;
}
if (terZ > zResolution)
{
terZ = zResolution;
}
float[,] heights = terrain.terrainData.GetHeights(terX, terZ, lenx, lenz);
float rateMultiplier = 1f;
if (EEGData.GetEEGData()[1] != 0)
{
rateMultiplier = GetRelativeAlpha();
}
float y = heights[lenx / 2, lenz / 2];
y += maxRaiseRate * rateMultiplier;
for (smoothing = 1; smoothing < smooth + 1; smoothing++)
{
float multiplier = smoothing / smooth;
for (areax = (int)(smoothing / 2); areax < lenx - (smoothing / 2); areax++)
{
for (areaz = (int)(smoothing / 2); areaz < lenz - (smoothing / 2); areaz++)
{
if ((areax > -1) && (areaz > -1) && (areax < xResolution) && (areaz < zResolution))
{
heights[areax, areaz] = Mathf.Clamp((float)y * multiplier, 0, 1);
}
}
}
}
lenx -= smooth;
lenz -= smooth;
UpdateObjectPositions(point, Mathf.Max(lenx, lenz), maxRaiseRate * rateMultiplier);
terrain.terrainData.SetHeights(terX, terZ, heights);
terrain.terrainData.RefreshPrototypes();
TerrainCollider terrainCollider = terrain.GetComponent <TerrainCollider>();
terrainCollider.terrainData = terrain.terrainData;
terrain.Flush();
}
private float GetRelativeAlpha()
{
float relAlpha = EEGData.GetRelativeFrequency(EEGData.EEG_BANDS.ALPHA);
return(relAlpha > alphaThreshold ? relAlpha : ((1f - relAlpha / alphaThreshold) * -1f));
}
public static float GetAverage(EEG_BANDS freqBand, int samplesBefore = 0)
{
return(EEGData.GetAbsoluteFrequency(freqBand, samplesBefore).Average());
}
