/// <summary>
/// Average the Earth Velocity data.
/// </summary>
/// <param name="scale">Scale value to multiply to the averaged data.</param>
/// <returns>Average the Earth Velocity data.</returns>
private float[] AverageEarthVelocity(float scale)
{
// Accumulate the data
AccumulatedBtData data = Accumulate(_earthVelocityAccum);
// Then average the data
return(AverageData(data, scale));
}
/// <summary>
/// Average the Amplitude data.
/// </summary>
/// <param name="scale">Scale value to multiply to the averaged data.</param>
/// <returns>Average the Amplitude data.</returns>
private float[] AverageAmplitude(float scale)
{
// Accumulate the data
AccumulatedBtData data = Accumulate(_amplitudeAccum);
// Then average the data
return(AverageData(data, scale));
}
/// <summary>
/// Average the Correlation data.
/// </summary>
/// <param name="scale">Scale value to multiply to the averaged data.</param>
/// <returns>Average the Correlation data.</returns>
private float[] AverageCorrelation(float scale)
{
// Accumulate the data
AccumulatedBtData data = Accumulate(_correlationAccum);
// Then average the data
return(AverageData(data, scale));
}
/// <summary>
/// Average the SNR data.
/// </summary>
/// <param name="scale">Scale value to multiply to the averaged data.</param>
/// <returns>Average the SNR data.</returns>
private float[] AverageSnr(float scale)
{
// Accumulate the data
AccumulatedBtData data = Accumulate(_sNRAccum);
// Then average the data
return(AverageData(data, scale));
}
/// <summary>
/// Average all the given accumulated data. This will then multiple a
/// scale value to the averaged data.
/// </summary>
/// <param name="accumData">Accumulated values.</param>
/// <returns>Array with the averaged and scaled value.</returns>
/// <param name="scale">Scale value to multiply to the averaged value.</param>
protected float[] AverageData(AccumulatedBtData accumData, float scale = 1.0f)
{
// Create an array, if no data is accumulated, null will be retruned
float[] result = null;
if (accumData.AvgAccum != null && accumData.AvgCount != null)
{
// Create the results array based off the accumulated values
result = new float[accumData.AvgAccum.GetLength(0)];
int numBeams = accumData.AvgCount.GetLength(0);
// Check if it has at least 1 beams
if (numBeams > 0)
{
// Calculate the average values
float B0 = 0.0f;
if (accumData.AvgCount[DataSet.Ensemble.BEAM_0_INDEX] > 0)
{
B0 = accumData.AvgAccum[DataSet.Ensemble.BEAM_0_INDEX] / accumData.AvgCount[DataSet.Ensemble.BEAM_0_INDEX]; // Beam 0 Average
}
// Set results
B0 *= scale;
result[DataSet.Ensemble.BEAM_0_INDEX] = B0;
}
// Check if it has at least 2 beams
if (numBeams > 1)
{
float B1 = 0.0f;
if (accumData.AvgCount[DataSet.Ensemble.BEAM_1_INDEX] > 0)
{
B1 = accumData.AvgAccum[DataSet.Ensemble.BEAM_1_INDEX] / accumData.AvgCount[DataSet.Ensemble.BEAM_1_INDEX]; // Beam 1 Average
}
// Set Results
B1 *= scale;
result[DataSet.Ensemble.BEAM_1_INDEX] = B1;
}
// Check if it has a least 3 beams
if (numBeams > 2)
{
float B2 = 0.0f;
if (accumData.AvgCount[DataSet.Ensemble.BEAM_2_INDEX] > 0)
{
B2 = accumData.AvgAccum[DataSet.Ensemble.BEAM_2_INDEX] / accumData.AvgCount[DataSet.Ensemble.BEAM_2_INDEX]; // Beam 2 Average
}
// Set Results
B2 *= scale;
result[DataSet.Ensemble.BEAM_2_INDEX] = B2;
}
// Check if it has a least 4 beams
if (numBeams > 3)
{
float B3 = 0.0f;
if (accumData.AvgCount[DataSet.Ensemble.BEAM_3_INDEX] > 0)
{
B3 = accumData.AvgAccum[DataSet.Ensemble.BEAM_3_INDEX] / accumData.AvgCount[DataSet.Ensemble.BEAM_3_INDEX]; // Beam 3 Average
}
// Set Result
B3 *= scale;
result[DataSet.Ensemble.BEAM_3_INDEX] = B3;
}
}
return(result);
}
/// <summary>
/// Accumulate the data.
/// </summary>
/// <returns>The accumulated data.</returns>
private AccumulatedBtData Accumulate(List <float[]> input)
{
AccumulatedBtData result = new AccumulatedBtData();
if (input.Count > 0)
{
// Get the number of bins and beams
// These values should be the same for all the accumulated data
float[] firstData = input.First();
int numBeams = firstData.GetLength(0);
// Create arrays to accumulate the data
float[] avgAccum = new float[numBeams];
int[] avgCount = new int[numBeams];
// Accumulate the data for each accumulate array
for (int x = 0; x < input.Count; x++)
{
// Get the data from the list
float[] data = input[x];
// Accumulate the values
for (int bin = 0; bin < data.GetLength(0); bin++)
{
// Beam 0
if (numBeams > 0)
{
float b0 = data[DataSet.Ensemble.BEAM_0_INDEX];
if (b0 != DataSet.Ensemble.BAD_VELOCITY)
{
avgAccum[DataSet.Ensemble.BEAM_0_INDEX] += b0;
avgCount[DataSet.Ensemble.BEAM_0_INDEX]++;
}
}
// Beam 1
if (numBeams > 1)
{
float b1 = data[DataSet.Ensemble.BEAM_1_INDEX];
if (b1 != DataSet.Ensemble.BAD_VELOCITY)
{
avgAccum[DataSet.Ensemble.BEAM_1_INDEX] += b1;
avgCount[DataSet.Ensemble.BEAM_1_INDEX]++;
}
}
// Beam 2
if (numBeams > 2)
{
float b2 = data[DataSet.Ensemble.BEAM_2_INDEX];
if (b2 != DataSet.Ensemble.BAD_VELOCITY)
{
avgAccum[DataSet.Ensemble.BEAM_2_INDEX] += b2;
avgCount[DataSet.Ensemble.BEAM_2_INDEX]++;
}
}
// Beam 3
if (numBeams > 3)
{
float b3 = data[DataSet.Ensemble.BEAM_3_INDEX];
if (b3 != DataSet.Ensemble.BAD_VELOCITY)
{
avgAccum[DataSet.Ensemble.BEAM_3_INDEX] += b3;
avgCount[DataSet.Ensemble.BEAM_3_INDEX]++;
}
}
}
}
// Set the accumulated data
result.AvgAccum = avgAccum;
result.AvgCount = avgCount;
}
return(result);
}
/// <summary>
/// Average all the given accumulated data. This will then multiple a
/// scale value to the averaged data.
/// </summary>
/// <param name="accumData">Accumulated values.</param>
/// <returns>Array with the averaged and scaled value.</returns>
/// <param name="scale">Scale value to multiply to the averaged value.</param>
protected float[] AverageData(AccumulatedBtData accumData, float scale = 1.0f)
{
// Create an array, if no data is accumulated, null will be retruned
float[] result = null;
if (accumData.AvgAccum != null && accumData.AvgCount != null)
{
// Create the results array based off the accumulated values
result = new float[accumData.AvgAccum.GetLength(0)];
int numBeams = accumData.AvgCount.GetLength(0);
// Check if it has at least 1 beams
if (numBeams > 0)
{
// Calculate the average values
float B0 = 0.0f;
if (accumData.AvgCount[DataSet.Ensemble.BEAM_0_INDEX] > 0)
{
B0 = accumData.AvgAccum[DataSet.Ensemble.BEAM_0_INDEX] / accumData.AvgCount[DataSet.Ensemble.BEAM_0_INDEX]; // Beam 0 Average
}
// Set results
B0 *= scale;
result[DataSet.Ensemble.BEAM_0_INDEX] = B0;
}
// Check if it has at least 2 beams
if (numBeams > 1)
{
float B1 = 0.0f;
if (accumData.AvgCount[DataSet.Ensemble.BEAM_1_INDEX] > 0)
{
B1 = accumData.AvgAccum[DataSet.Ensemble.BEAM_1_INDEX] / accumData.AvgCount[DataSet.Ensemble.BEAM_1_INDEX]; // Beam 1 Average
}
// Set Results
B1 *= scale;
result[DataSet.Ensemble.BEAM_1_INDEX] = B1;
}
// Check if it has a least 3 beams
if (numBeams > 2)
{
float B2 = 0.0f;
if (accumData.AvgCount[DataSet.Ensemble.BEAM_2_INDEX] > 0)
{
B2 = accumData.AvgAccum[DataSet.Ensemble.BEAM_2_INDEX] / accumData.AvgCount[DataSet.Ensemble.BEAM_2_INDEX]; // Beam 2 Average
}
// Set Results
B2 *= scale;
result[DataSet.Ensemble.BEAM_2_INDEX] = B2;
}
// Check if it has a least 4 beams
if (numBeams > 3)
{
float B3 = 0.0f;
if (accumData.AvgCount[DataSet.Ensemble.BEAM_3_INDEX] > 0)
{
B3 = accumData.AvgAccum[DataSet.Ensemble.BEAM_3_INDEX] / accumData.AvgCount[DataSet.Ensemble.BEAM_3_INDEX]; // Beam 3 Average
}
// Set Result
B3 *= scale;
result[DataSet.Ensemble.BEAM_3_INDEX] = B3;
}
}
return result;
}
/// <summary>
/// Accumulate the data.
/// </summary>
/// <returns>The accumulated data.</returns>
private AccumulatedBtData Accumulate(List<float[]> input)
{
AccumulatedBtData result = new AccumulatedBtData();
if (input.Count > 0)
{
// Get the number of bins and beams
// These values should be the same for all the accumulated data
float[] firstData = input.First();
int numBeams = firstData.GetLength(0);
// Create arrays to accumulate the data
float[] avgAccum = new float[numBeams];
int[] avgCount = new int[numBeams];
// Accumulate the data for each accumulate array
for (int x = 0; x < input.Count; x++)
{
// Get the data from the list
float[] data = input[x];
// Accumulate the values
for (int bin = 0; bin < data.GetLength(0); bin++)
{
// Beam 0
if (numBeams > 0)
{
float b0 = data[DataSet.Ensemble.BEAM_0_INDEX];
if (b0 != DataSet.Ensemble.BAD_VELOCITY)
{
avgAccum[DataSet.Ensemble.BEAM_0_INDEX] += b0;
avgCount[DataSet.Ensemble.BEAM_0_INDEX]++;
}
}
// Beam 1
if (numBeams > 1)
{
float b1 = data[DataSet.Ensemble.BEAM_1_INDEX];
if (b1 != DataSet.Ensemble.BAD_VELOCITY)
{
avgAccum[DataSet.Ensemble.BEAM_1_INDEX] += b1;
avgCount[DataSet.Ensemble.BEAM_1_INDEX]++;
}
}
// Beam 2
if (numBeams > 2)
{
float b2 = data[DataSet.Ensemble.BEAM_2_INDEX];
if (b2 != DataSet.Ensemble.BAD_VELOCITY)
{
avgAccum[DataSet.Ensemble.BEAM_2_INDEX] += b2;
avgCount[DataSet.Ensemble.BEAM_2_INDEX]++;
}
}
// Beam 3
if (numBeams > 3)
{
float b3 = data[DataSet.Ensemble.BEAM_3_INDEX];
if (b3 != DataSet.Ensemble.BAD_VELOCITY)
{
avgAccum[DataSet.Ensemble.BEAM_3_INDEX] += b3;
avgCount[DataSet.Ensemble.BEAM_3_INDEX]++;
}
}
}
}
// Set the accumulated data
result.AvgAccum = avgAccum;
result.AvgCount = avgCount;
}
return result;
}
