private void ComputeVelocities(TrajectoryKinematics kinematics, CalibrationHelper calibrationHelper)
{
if (kinematics.Length <= 2)
{
PadVelocities(kinematics);
return;
}
for (int i = 1; i < kinematics.Length - 1; i++)
{
PointF a = kinematics.Coordinates(i - 1);
PointF b = kinematics.Coordinates(i + 1);
float t = calibrationHelper.GetTime(2);
kinematics.Speed[i] = (double)calibrationHelper.ConvertSpeed(GetSpeed(a, b, t, Component.Magnitude));
kinematics.HorizontalVelocity[i] = (double)calibrationHelper.ConvertSpeed(GetSpeed(a, b, t, Component.Horizontal));
kinematics.VerticalVelocity[i] = (double)calibrationHelper.ConvertSpeed(GetSpeed(a, b, t, Component.Vertical));
}
PadVelocities(kinematics);
double constantVelocitySpan = 40;
MovingAverage filter = new MovingAverage();
kinematics.Speed = filter.FilterSamples(kinematics.Speed, calibrationHelper.CaptureFramesPerSecond, constantVelocitySpan, 1);
kinematics.HorizontalVelocity = filter.FilterSamples(kinematics.HorizontalVelocity, calibrationHelper.CaptureFramesPerSecond, constantVelocitySpan, 1);
kinematics.VerticalVelocity = filter.FilterSamples(kinematics.VerticalVelocity, calibrationHelper.CaptureFramesPerSecond, constantVelocitySpan, 1);
}
private void ComputeRawVelocities(TrajectoryKinematics kinematics, CalibrationHelper calibrationHelper)
{
if (kinematics.Length <= 2)
{
PadRawVelocities(kinematics);
return;
}
for (int i = 1; i < kinematics.Length - 1; i++)
{
PointF a = kinematics.RawCoordinates(i - 1);
PointF b = kinematics.RawCoordinates(i + 1);
float t = calibrationHelper.GetTime(2);
kinematics.RawSpeed[i] = (double)calibrationHelper.ConvertSpeed(GetSpeed(a, b, t, Component.Magnitude));
kinematics.RawHorizontalVelocity[i] = (double)calibrationHelper.ConvertSpeed(GetSpeed(a, b, t, Component.Horizontal));
kinematics.RawVerticalVelocity[i] = (double)calibrationHelper.ConvertSpeed(GetSpeed(a, b, t, Component.Vertical));
}
PadRawVelocities(kinematics);
}
private void ComputeVelocities(TimeSeriesCollection tsc, CalibrationHelper calibrationHelper, Func <int, PointF> getCoord)
{
if (tsc.Length <= 2)
{
PadVelocities(tsc);
return;
}
for (int i = 1; i < tsc.Length - 1; i++)
{
PointF a = getCoord(i - 1);
PointF b = getCoord(i + 1);
float t = calibrationHelper.GetTime(2);
tsc[Kinematics.LinearSpeed][i] = (double)calibrationHelper.ConvertSpeed(GetSpeed(a, b, t, Component.Magnitude));
tsc[Kinematics.LinearHorizontalVelocity][i] = (double)calibrationHelper.ConvertSpeed(GetSpeed(a, b, t, Component.Horizontal));
tsc[Kinematics.LinearVerticalVelocity][i] = (double)calibrationHelper.ConvertSpeed(GetSpeed(a, b, t, Component.Vertical));
}
PadVelocities(tsc);
// Second pass: apply extra smoothing to the derivatives.
// This is only applied for high speed videos where the digitization is very noisy
// due to the combination of increased time resolution and decreased spatial resolution.
double constantVelocitySpan = 40;
MovingAverage filter = new MovingAverage();
double[] averagedVelocity = filter.FilterSamples(tsc[Kinematics.LinearSpeed], calibrationHelper.CaptureFramesPerSecond, constantVelocitySpan, 1);
double[] averagedHorizontalVelocity = filter.FilterSamples(tsc[Kinematics.LinearHorizontalVelocity], calibrationHelper.CaptureFramesPerSecond, constantVelocitySpan, 1);
double[] averagedVerticalVelocity = filter.FilterSamples(tsc[Kinematics.LinearVerticalVelocity], calibrationHelper.CaptureFramesPerSecond, constantVelocitySpan, 1);
for (int i = 0; i < tsc.Length; i++)
{
tsc[Kinematics.LinearSpeed][i] = averagedVelocity[i];
tsc[Kinematics.LinearHorizontalVelocity][i] = averagedHorizontalVelocity[i];
tsc[Kinematics.LinearVerticalVelocity][i] = averagedVerticalVelocity[i];
}
}
private void ComputeAngularVelocities(TrajectoryKinematics kinematics, CalibrationHelper calibrationHelper)
{
if (kinematics.Length <= 2)
{
PadAngularVelocities(kinematics);
return;
}
for (int i = 1; i < kinematics.Length - 1; i++)
{
double d1 = GetDisplacementAngle(kinematics, i, i - 1);
double d2 = GetDisplacementAngle(kinematics, i + 1, i);
float time = calibrationHelper.GetTime(2);
float inRadPerSecond = (float)((d1 + d2) / time);
kinematics.AngularVelocity[i] = calibrationHelper.ConvertAngularVelocity(inRadPerSecond);
kinematics.TangentialVelocity[i] = calibrationHelper.ConvertSpeed((float)(inRadPerSecond * kinematics.RotationRadius));
kinematics.CentripetalAcceleration[i] = calibrationHelper.ConvertAcceleration((float)(inRadPerSecond * inRadPerSecond * kinematics.RotationRadius));
}
PadAngularVelocities(kinematics);
}
private void ComputeVelocity(TimeSeriesCollection tsc, CalibrationHelper calibrationHelper)
{
if (tsc.Length <= 2)
{
PadVelocities(tsc);
return;
}
for (int i = 1; i < tsc.Length - 1; i++)
{
float a1 = positions[i - 1];
float a2 = positions[i + 1];
float t = calibrationHelper.GetTime(2);
float omega = (a2 - a1) / t;
velocities[i] = omega;
tsc[Kinematics.AngularVelocity][i] = (double)calibrationHelper.ConvertAngularVelocity(omega);
float v = radii[i] * omega;
tsc[Kinematics.TangentialVelocity][i] = (double)calibrationHelper.ConvertSpeed(v);
}
PadVelocities(tsc);
}
