/// <summary>
/// Shows all the information for a trial-level node highlighted in the treeview.
/// </summary>
/// <param name="node">The highlighted node in the left treeview, assumed to represent an individual trial.</param>
private void ShowTrialInfo(TreeNode node)
{
//
// Get the trial and its condition from the 'Tag' field from the selected node.
//
_tdata = (TrialData)node.Tag;
_cdata = (ConditionData)node.Parent.Tag;
//
// Get the resampled and smoothed velocity, acceleration, and jerk profiles.
//
MovementData.Profiles resampled = _tdata.Movement.CreateResampledProfiles();
MovementData.Profiles smoothed = _tdata.Movement.CreateSmoothedProfiles();
//
// Clear any series in the graphs.
//
grfDistance.ClearSeries();
grfVelocity.ClearSeries();
grfAcceleration.ClearSeries();
grfJerk.ClearSeries();
//
// Graph the resampled distance to the target over time.
//
List <PointF> rdist = new List <PointF>(resampled.Position.Count);
for (int i = 0; i < resampled.Position.Count; i++)
{
long t = resampled.Position[i].Time - resampled.Position[0].Time;
double dx = GeotrigEx.Distance(resampled.Position[i], _tdata.TargetCenterFromStart);
rdist.Add(new PointF(t, (float)dx));
}
Graph.Series rd = new Graph.Series("resampled distance", Color.Salmon, Color.Salmon, false, true);
rd.AddPoints(rdist);
//
// Graph the smoothed distance from the target over time.
//
List <PointF> sdist = new List <PointF>(smoothed.Position.Count);
for (int i = 0; i < smoothed.Position.Count; i++)
{
long t = smoothed.Position[i].Time - smoothed.Position[0].Time;
double dx = GeotrigEx.Distance(smoothed.Position[i], _tdata.TargetCenterFromStart);
sdist.Add(new PointF(t, (float)dx));
}
Graph.Series sd = new Graph.Series("smoothed distance", Color.MediumBlue, Color.MediumBlue, false, true);
sd.AddPoints(sdist);
grfDistance.AddSeries(rd);
grfDistance.AddSeries(sd);
//
// Graph the velocity.
//
Graph.Series rv = new Graph.Series("resampled velocity", Color.Salmon, Color.Salmon, false, true);
rv.AddPoints(resampled.Velocity);
Graph.Series sv = new Graph.Series("smoothed velocity", Color.MediumBlue, Color.MediumBlue, false, true);
sv.AddPoints(smoothed.Velocity);
grfVelocity.AddSeries(rv);
grfVelocity.AddSeries(sv);
//
// Graph the acceleration.
//
Graph.Series aaxis = new Graph.Series("zero line", Color.Gray, Color.Gray, false, true);
aaxis.AddPoint(0f, 0f);
aaxis.AddPoint(resampled.Acceleration[resampled.Acceleration.Count - 1].X, 0f);
Graph.Series ra = new Graph.Series("resampled acceleration", Color.Salmon, Color.Salmon, false, true);
ra.AddPoints(resampled.Acceleration);
Graph.Series sa = new Graph.Series("smoothed acceleration", Color.MediumBlue, Color.MediumBlue, false, true);
sa.AddPoints(smoothed.Acceleration);
grfAcceleration.AddSeries(aaxis);
grfAcceleration.AddSeries(ra);
grfAcceleration.AddSeries(sa);
//
// Graph the jerk.
//
Graph.Series jaxis = new Graph.Series("zero line", Color.Gray, Color.Gray, false, true);
jaxis.AddPoint(0f, 0f);
jaxis.AddPoint(resampled.Jerk[resampled.Jerk.Count - 1].X, 0f);
Graph.Series rj = new Graph.Series("resampled jerk", Color.Salmon, Color.Salmon, false, true);
rj.AddPoints(resampled.Jerk);
Graph.Series sj = new Graph.Series("smoothed jerk", Color.MediumBlue, Color.MediumBlue, false, true);
sj.AddPoints(smoothed.Jerk);
grfJerk.AddSeries(jaxis);
grfJerk.AddSeries(rj);
grfJerk.AddSeries(sj);
//
// Now show the trial-level XML in the web control.
//
XmlTextWriter writer = null;
string tmpXml = String.Format("{0}{1}.xml", Path.GetTempPath(), Path.GetRandomFileName());
try
{
writer = new XmlTextWriter(tmpXml, Encoding.UTF8);
writer.Formatting = Formatting.Indented;
_tdata.WriteXmlHeader(writer);
}
catch (Exception ex)
{
Console.WriteLine(ex);
tmpXml = String.Empty;
}
finally
{
if (writer != null)
{
writer.Close();
}
if (tmpXml != String.Empty)
{
webXml.Navigate(tmpXml);
rtxXml.LoadFile(tmpXml, RichTextBoxStreamType.PlainText);
_tmpXml.Add(tmpXml);
}
}
//
// Invalidate everything that needs to be repainted based on the node just selected.
//
pnlTrial.Invalidate();
grfDistance.Invalidate();
grfVelocity.Invalidate();
grfAcceleration.Invalidate();
grfJerk.Invalidate();
}
/// <summary>
/// Handles the Load event for the form. Loads the data from the model into the graph control, and
/// displays the model terms in the read-only textbox.
/// </summary>
/// <param name="sender">The sender of this event.</param>
/// <param name="e">The arguments for this event.</param>
private void ModelForm_Load(object sender, EventArgs e)
{
//
// Ask the session instance to build a Fitts' law model.
//
Model fm = _sdata.BuildModel();
fm.RoundTerms(4); // round for display
if (_sdata.MTPct == null) // regular Fitts experiment
{
PointF min = PointF.Empty;
PointF max = PointF.Empty;
//
// Add the (IDe, MTe) points for plotting.
//
Graph.Series s1 = new Graph.Series("Fitts model 1D points", Color.Tomato, Color.Tomato, true, false);
s1.AddPoints(fm.FittsPts_1d); // add the points to the series
grfFitts1D.AddSeries(s1); // add the series to the graph
if (s1.NumPoints > 1)
{
RectangleF r = s1.DomainRange; // get the domain and range of the first series
Graph.Series s3 = new Graph.Series("Fitts model 1D line", Color.OrangeRed, Color.OrangeRed, false, true);
s3.AddPoint(0f, (float)fm.Fitts_a_1d); // y-intercept
s3.AddPoint(r.Right, (float)(fm.Fitts_b_1d * r.Right + fm.Fitts_a_1d)); // rightmost point
grfFitts1D.AddSeries(s3);
min = s3[0];
max = s3[1];
}
if (_sdata.Is2D)
{
Graph.Series s2 = new Graph.Series("Fitts model 2D points", Color.Tomato, Color.Tomato, true, false);
s2.AddPoints(fm.FittsPts_2d);
grfFitts2D.AddSeries(s2);
if (s2.NumPoints > 1)
{
RectangleF r = s2.DomainRange; // get the domain and range of the first series
Graph.Series s4 = new Graph.Series("Fitts model 2D line", Color.OrangeRed, Color.OrangeRed, false, true);
s4.AddPoint(0f, (float)fm.Fitts_a_2d); // y-intercept
s4.AddPoint(r.Right, (float)(fm.Fitts_b_2d * r.Right + fm.Fitts_a_2d)); // rightmost point
grfFitts2D.AddSeries(s4);
min.X = Math.Min(min.X, s4[0].X);
min.Y = Math.Min(min.Y, s4[0].Y);
max.X = Math.Max(max.X, s4[1].X);
max.Y = Math.Max(max.Y, s4[1].Y);
}
}
// add a series to ensure both graphs display at the same scale for better comparisons
Graph.Series s5 = new Graph.Series("Fitts min-max", Color.Black, Color.Black, false, false);
s5.AddPoint(min);
s5.AddPoint(max);
grfFitts1D.AddSeries(s5);
grfFitts2D.AddSeries(s5);
//
// Fill the text box with the Fitts' law model parameters.
//
txtFitts1D.Text =
String.Format("Fitts' Law - Univariate for Subject {0}\r\n", _sdata.Subject) +
String.Format("N = {0}\r\n", fm.N) +
String.Format("MTavg = {0} ms\r\n", fm.MTe) +
String.Format("Error% = {0}\r\n", fm.ErrorPct) +
String.Format("MT(1d) = {0} + {1} * ID\r\n", fm.Fitts_a_1d, fm.Fitts_b_1d) +
String.Format("TP_avg(1d) = {0} bits/s\r\n", fm.Fitts_TP_avg_1d) +
String.Format("TP_inv(1d) = {0} bits/s\r\n", fm.Fitts_TP_inv_1d) +
String.Format("a(1d) = {0} ms\r\n", fm.Fitts_a_1d) +
String.Format("b(1d) = {0} ms/bit\r\n", fm.Fitts_b_1d) +
String.Format("r(1d) = {0}\r\n", fm.Fitts_r_1d);
if (_sdata.Is2D)
{
txtFitts2D.Text =
String.Format("Fitts' Law - Bivariate for Subject {0}\r\n", _sdata.Subject) +
String.Format("N = {0}\r\n", fm.N) +
String.Format("MTavg = {0} ms\r\n", fm.MTe) +
String.Format("Error% = {0}\r\n", fm.ErrorPct) +
String.Format("MT(2d) = {0} + {1} * ID\r\n", fm.Fitts_a_2d, fm.Fitts_b_2d) +
String.Format("TP_avg(2d) = {0} bits/s\r\n", fm.Fitts_TP_avg_2d) +
String.Format("TP_inv(2d) = {0} bits/s\r\n", fm.Fitts_TP_inv_2d) +
String.Format("a(2d) = {0} ms\r\n", fm.Fitts_a_2d) +
String.Format("b(2d) = {0} ms/bit\r\n", fm.Fitts_b_2d) +
String.Format("r(2d) = {0}\r\n", fm.Fitts_r_2d);
}
else
{
tabModel.TabPages.RemoveAt(1); // remove the Fitts' law 2D tab
}
tabModel.TabPages.RemoveAt(tabModel.TabPages.Count - 1); // remove the Error model 2D tab
tabModel.TabPages.RemoveAt(tabModel.TabPages.Count - 1); // remove the Error model 1D tab
}
else // metronome experiment
{
//
// Add the diagonal line for easy visual model comparisons.
//
Graph.Series s0 = new Graph.Series("Diagonal", Color.LightGray, Color.LightGray, false, true);
s0.AddPoint(0f, 0f);
s0.AddPoint(1f, 1f);
grfErrors1D.AddSeries(s0);
grfErrors2D.AddSeries(s0);
//
// Add the (predicted error rate, observed error rate) points for plotting.
//
Graph.Series s1 = new Graph.Series("Error model 1D points", Color.Tomato, Color.Tomato, true, false);
s1.AddPoints(fm.ErrorPts_1d);
grfErrors1D.AddSeries(s1);
if (s1.NumPoints > 1)
{
RectangleF r = s1.DomainRange;
Graph.Series s3 = new Graph.Series("Error model 1D line", Color.OrangeRed, Color.OrangeRed, false, true);
s3.AddPoint(0f, (float)fm.Error_b_1d); // y-intercept
s3.AddPoint(r.Right, (float)(fm.Error_m_1d * r.Right + fm.Error_b_1d));
grfErrors1D.AddSeries(s3);
}
if (_sdata.Is2D)
{
Graph.Series s2 = new Graph.Series("Error model 2D points", Color.Tomato, Color.Tomato, true, false);
s2.AddPoints(fm.ErrorPts_2d);
grfErrors2D.AddSeries(s2);
if (s2.NumPoints > 1)
{
RectangleF r = s2.DomainRange;
Graph.Series s4 = new Graph.Series("Error model 2D line", Color.OrangeRed, Color.OrangeRed, false, true);
s4.AddPoint(0f, (float)fm.Error_b_2d); // y-intercept
s4.AddPoint(r.Right, (float)(fm.Error_m_2d * r.Right + fm.Error_b_2d));
grfErrors2D.AddSeries(s4);
}
}
//
// Fill the text box with the Error model parameters.
//
txtErrors1D.Text =
String.Format("Pointing Error Model - Univariate for Subject {0}\r\n", _sdata.Subject) +
String.Format("N = {0}\r\n", fm.N) +
String.Format("MTavg = {0} ms\r\n", fm.MTe) +
String.Format("Error% = {0}\r\n", fm.ErrorPct) +
String.Format("Predicted(1d) = 1 - erf[(2.066 * W/A * (2^((MT-{0})/{1}) - 1)) / sqrt(2)]\r\n", fm.Fitts_a_1d, fm.Fitts_b_1d) +
String.Format("Observed(1d) = {0} * Predicted + {1}\r\n", fm.Error_m_1d, fm.Error_b_1d) +
String.Format("m(1d) = {0}\r\n", fm.Error_m_1d) +
String.Format("b(1d) = {0}\r\n", fm.Error_b_1d) +
String.Format("r(1d) = {0}\r\n", fm.Error_r_1d);
if (_sdata.Is2D)
{
txtErrors2D.Text =
String.Format("Pointing Error Model - Bivariate for Subject {0}\r\n", _sdata.Subject) +
String.Format("N = {0}\r\n", fm.N) +
String.Format("MTavg = {0} ms\r\n", fm.MTe) +
String.Format("Error% = {0}\r\n", fm.ErrorPct) +
String.Format("Predicted(2d) = 1 - erf[(2.066 * W/A * (2^((MT-{0})/{1}) - 1)) / sqrt(2)]\r\n", fm.Fitts_a_2d, fm.Fitts_b_2d) +
String.Format("Observed(2d) = {0} * Predicted + {1}\r\n", fm.Error_m_2d, fm.Error_b_2d) +
String.Format("m(2d) = {0}\r\n", fm.Error_m_2d) +
String.Format("b(2d) = {0}\r\n", fm.Error_b_2d) +
String.Format("r(2d) = {0}\r\n", fm.Error_r_2d);
}
else
{
tabModel.TabPages.RemoveAt(3); // remove the Error model 2D tab
}
tabModel.TabPages.RemoveAt(0); // remove the Fitts' law 1D tab
tabModel.TabPages.RemoveAt(0); // remove the Fitts' law 2D tab
}
}