public BitmapSource VisualizeCalibrationResults(List<CalibrationTarget> calibTargets)
        {
            CanvasCalibration.Children.Clear();

            // Draw also to Drawing Visual
            DrawingVisual drawingVisual = new DrawingVisual();
            DrawingContext drawingContext = drawingVisual.RenderOpen();

            // Fill with background color
            drawingContext.DrawRectangle(
                this.CanvasCalibration.Background, 
                null, 
                new Rect(0, 0, this.ActualWidth, this.ActualHeight));

            // Redisplay cursor
            Cursor = Cursors.Arrow;

            double sumStdDeviation = 0;
            double sumDistFromTargetsX = 0;
            double sumDistFromTargetsY = 0;

            // Loop through Calpoints in the UserControl
            foreach (CalibrationPoint t in calibrationPoints)
            {
                CalibrationPoint calPoint = CopyPoint(t);

                #region Draw tracker data for calPoint

                foreach (CalibrationTarget trackerPoint in calibTargets)
                {
                    // If target number is the same, create visuals for calibration point
                    if (trackerPoint.targetNumber.Equals(calPoint.Number))
                    {
                        #region Draw raw estimated gaze positions

                        foreach (GTPoint gpLeft in trackerPoint.estimatedGazeCoordinatesLeft)
                        {
                            // compensate for relative to full screen coordinates
                            Point p = AdjustPointToPartial(new Point(gpLeft.X, gpLeft.Y));
                            Ellipse g = new Ellipse { Width = 3, Height = 3, Fill = new SolidColorBrush(Colors.Red) };
                            CanvasCalibration.Children.Add(g);
                            Canvas.SetTop(g, p.Y);
                            Canvas.SetLeft(g, p.X);

                            // Draw also to Drawing Visual
                            drawingContext.DrawEllipse(Brushes.Red, null, p, 3, 3);
                        }

                        foreach (GTPoint gpRight in trackerPoint.estimatedGazeCoordinatesRight)
                        {
                            Point p = AdjustPointToPartial(new Point(gpRight.X, gpRight.Y));
                            Ellipse g = new Ellipse { Width = 3, Height = 3, Fill = new SolidColorBrush(Colors.Blue) };
                            CanvasCalibration.Children.Add(g);
                            Canvas.SetTop(g, p.Y);
                            Canvas.SetLeft(g, p.X);

                            // Draw also to Drawing Visual
                            drawingContext.DrawEllipse(Brushes.Blue, null, p, 3, 3);
                        }

                        #endregion

                        #region Draw Standard deviation indicator

                        CalibrationFeedbackPoint feedback = new CalibrationFeedbackPoint();
                        double stdDevGazeCoordinates = trackerPoint.stdDeviationGazeCoordinatesLeft;

                        // binocular
                        if (trackerPoint.stdDeviationGazeCoordinatesRight != 0)
                        {
                            stdDevGazeCoordinates += trackerPoint.stdDeviationGazeCoordinatesRight;
                            stdDevGazeCoordinates = stdDevGazeCoordinates / 2;
                        }

                        feedback.Width = stdDevGazeCoordinates;
                        feedback.Height = stdDevGazeCoordinates;

                        if (feedback.Width > 80)
                            feedback.EllipseBackground.Fill = new SolidColorBrush(Colors.Red);
                        else
                            feedback.EllipseBackground.Fill = new SolidColorBrush(Colors.Green);

                        CanvasCalibration.Children.Add(feedback);

                        #endregion


                        #region Average mean gaze

                        Point avgMeanGazeCoordinates = new Point(trackerPoint.meanGazeCoordinatesLeft.X, trackerPoint.meanGazeCoordinatesLeft.Y);

                        //// binocular
                        //if (trackerPoint.meanGazeCoordinatesRight.X != 0)
                        //{
                        //    avgMeanGazeCoordinates.Y += trackerPoint.meanGazeCoordinatesRight.Y;
                        //    avgMeanGazeCoordinates.X += trackerPoint.meanGazeCoordinatesRight.X;

                        //    avgMeanGazeCoordinates.X = avgMeanGazeCoordinates.X/2;
                        //    avgMeanGazeCoordinates.Y = avgMeanGazeCoordinates.Y/2;
                        //}

                        // Position avgMean feedback, compensate for relative to full screen coordinates
                        Point adjustedAvgMeanGazePoint = AdjustPointToPartial(avgMeanGazeCoordinates);
                        Canvas.SetTop(feedback, adjustedAvgMeanGazePoint.Y);
                        Canvas.SetLeft(feedback, adjustedAvgMeanGazePoint.X);
                        Panel.SetZIndex(feedback, 2);

                        // Draw also to Drawing Visual
                        drawingContext.DrawEllipse(
                            feedback.EllipseBackground.Fill,
                            null,
                            adjustedAvgMeanGazePoint,
                            stdDevGazeCoordinates,
                            stdDevGazeCoordinates);


                        #region Connect with line if more than 80 px away

                        // When point is more than 80px. away connect it with a dotted line to center
                        if (trackerPoint.meanGazeCoordinatesLeft.Y >= calPoint.Point.Y + 80 ||
                            trackerPoint.meanGazeCoordinatesLeft.Y <= calPoint.Point.Y + 80)
                        {
                            // Start line
                            var myLine = new Line { X1 = calPoint.Point.X, Y1 = calPoint.Point.Y };

                            // End line
                            if (!double.IsNaN(feedback.Width))
                                myLine.X2 = adjustedAvgMeanGazePoint.X + feedback.Width / 2;

                            if (!double.IsNaN(feedback.Height))
                                myLine.Y2 = adjustedAvgMeanGazePoint.Y + feedback.Height / 2;

                            myLine.Stroke = Brushes.LightSteelBlue;

                            var dashes = new DoubleCollection { 2, 2 };
                            myLine.StrokeDashArray = dashes;
                            myLine.StrokeDashCap = PenLineCap.Round;

                            CanvasCalibration.Children.Add(myLine);

                            // Draw also to Drawing Visual
                            Pen linePen = new Pen();
                            linePen.Brush = myLine.Stroke;
                            linePen.DashStyle = DashStyles.Dash;
                            linePen.DashCap = PenLineCap.Round;

                            drawingContext.DrawLine(
                                linePen,
                                new Point(myLine.X1, myLine.Y1),
                                new Point(myLine.X2, myLine.Y2));
                        }

                        #endregion

                        #endregion

                        #region Calculate sum std dev

                        sumDistFromTargetsY += avgMeanGazeCoordinates.Y - (calPoint.Point.Y - calPoint.Diameter / 2);
                        sumDistFromTargetsX += avgMeanGazeCoordinates.X - (calPoint.Point.X - calPoint.Diameter / 2);

                        double sumStdDevAvg = trackerPoint.stdDeviationGazeCoordinatesLeft + trackerPoint.stdDeviationGazeCoordinatesRight;
                        sumStdDevAvg = sumStdDevAvg / 2;
                        sumStdDeviation += sumStdDevAvg;

                        #endregion
                    }
                }

                #endregion

                #region Draw calibration points (last to stay on top)

                calPoint.Visibility = Visibility.Visible;
                calPoint.Opacity = 0.5;
                CanvasCalibration.Children.Add(calPoint);
                Canvas.SetTop(calPoint, calPoint.Point.Y - calPoint.Diameter / 2);
                Canvas.SetLeft(calPoint, calPoint.Point.X - calPoint.Diameter / 2);
                Panel.SetZIndex(calPoint, 99);

                // Draw also to Drawing Visual
                SolidColorBrush whiteBrush = new SolidColorBrush();
                whiteBrush.Color = Color.FromArgb(122, 255, 255, 255);
                drawingContext.DrawEllipse(
                   whiteBrush,
                    null,
                    calPoint.Point,
                    calPoint.Diameter / 2,
                    calPoint.Diameter / 2);
                drawingContext.DrawEllipse(
                   null,
                    new Pen(Brushes.Black, 1f),
                    calPoint.Point,
                    8,
                    8);

                // Enable recalibration 
                calPoint.OnClick += RecalibratePoint;

                #endregion
            }

            // Generate values for the 1-5 star ratings-control from quality feeback
            AvgSumStdDev = sumStdDeviation / calibTargets.Count;
            AvgDistFromTargets = ((sumDistFromTargetsY + sumDistFromTargetsX) / 2) / calibTargets.Count;

            // Now perform the rendering of the Visual to a bitmap
            drawingContext.Close();
            var bmp = new RenderTargetBitmap((int)ActualWidth, (int)ActualHeight, 96, 96, PixelFormats.Pbgra32);
            bmp.Render(drawingVisual);
           
            return bmp;
        }
Example #2
0
        public BitmapSource VisualizeCalibrationResults(List <CalibrationTarget> calibTargets)
        {
            CanvasCalibration.Children.Clear();

            // Draw also to Drawing Visual
            DrawingVisual  drawingVisual  = new DrawingVisual();
            DrawingContext drawingContext = drawingVisual.RenderOpen();

            // Fill with background color
            drawingContext.DrawRectangle(
                this.CanvasCalibration.Background,
                null,
                new Rect(0, 0, this.ActualWidth, this.ActualHeight));

            // Redisplay cursor
            Cursor = Cursors.Arrow;

            double sumStdDeviation     = 0;
            double sumDistFromTargetsX = 0;
            double sumDistFromTargetsY = 0;

            // Loop through Calpoints in the UserControl
            foreach (CalibrationPoint t in calibrationPoints)
            {
                CalibrationPoint calPoint = CopyPoint(t);

                #region Draw tracker data for calPoint

                foreach (CalibrationTarget trackerPoint in calibTargets)
                {
                    // If target number is the same, create visuals for calibration point
                    if (trackerPoint.targetNumber.Equals(calPoint.Number))
                    {
                        #region Draw raw estimated gaze positions

                        foreach (GTPoint gpLeft in trackerPoint.estimatedGazeCoordinatesLeft)
                        {
                            // compensate for relative to full screen coordinates
                            Point   p = AdjustPointToPartial(new Point(gpLeft.X, gpLeft.Y));
                            Ellipse g = new Ellipse {
                                Width = 3, Height = 3, Fill = new SolidColorBrush(Colors.Red)
                            };
                            CanvasCalibration.Children.Add(g);
                            Canvas.SetTop(g, p.Y);
                            Canvas.SetLeft(g, p.X);

                            // Draw also to Drawing Visual
                            drawingContext.DrawEllipse(Brushes.Red, null, p, 3, 3);
                        }

                        foreach (GTPoint gpRight in trackerPoint.estimatedGazeCoordinatesRight)
                        {
                            Point   p = AdjustPointToPartial(new Point(gpRight.X, gpRight.Y));
                            Ellipse g = new Ellipse {
                                Width = 3, Height = 3, Fill = new SolidColorBrush(Colors.Blue)
                            };
                            CanvasCalibration.Children.Add(g);
                            Canvas.SetTop(g, p.Y);
                            Canvas.SetLeft(g, p.X);

                            // Draw also to Drawing Visual
                            drawingContext.DrawEllipse(Brushes.Blue, null, p, 3, 3);
                        }

                        #endregion

                        #region Draw Standard deviation indicator

                        CalibrationFeedbackPoint feedback = new CalibrationFeedbackPoint();
                        double stdDevGazeCoordinates      = trackerPoint.stdDeviationGazeCoordinatesLeft;

                        // binocular
                        if (trackerPoint.stdDeviationGazeCoordinatesRight != 0)
                        {
                            stdDevGazeCoordinates += trackerPoint.stdDeviationGazeCoordinatesRight;
                            stdDevGazeCoordinates  = stdDevGazeCoordinates / 2;
                        }

                        feedback.Width  = stdDevGazeCoordinates;
                        feedback.Height = stdDevGazeCoordinates;

                        if (feedback.Width > 80)
                        {
                            feedback.EllipseBackground.Fill = new SolidColorBrush(Colors.Red);
                        }
                        else
                        {
                            feedback.EllipseBackground.Fill = new SolidColorBrush(Colors.Green);
                        }

                        CanvasCalibration.Children.Add(feedback);

                        #endregion


                        #region Average mean gaze

                        Point avgMeanGazeCoordinates = new Point(trackerPoint.meanGazeCoordinatesLeft.X, trackerPoint.meanGazeCoordinatesLeft.Y);

                        //// binocular
                        //if (trackerPoint.meanGazeCoordinatesRight.X != 0)
                        //{
                        //    avgMeanGazeCoordinates.Y += trackerPoint.meanGazeCoordinatesRight.Y;
                        //    avgMeanGazeCoordinates.X += trackerPoint.meanGazeCoordinatesRight.X;

                        //    avgMeanGazeCoordinates.X = avgMeanGazeCoordinates.X/2;
                        //    avgMeanGazeCoordinates.Y = avgMeanGazeCoordinates.Y/2;
                        //}

                        // Position avgMean feedback, compensate for relative to full screen coordinates
                        Point adjustedAvgMeanGazePoint = AdjustPointToPartial(avgMeanGazeCoordinates);
                        Canvas.SetTop(feedback, adjustedAvgMeanGazePoint.Y);
                        Canvas.SetLeft(feedback, adjustedAvgMeanGazePoint.X);
                        Panel.SetZIndex(feedback, 2);

                        // Draw also to Drawing Visual
                        drawingContext.DrawEllipse(
                            feedback.EllipseBackground.Fill,
                            null,
                            adjustedAvgMeanGazePoint,
                            stdDevGazeCoordinates,
                            stdDevGazeCoordinates);


                        #region Connect with line if more than 80 px away

                        // When point is more than 80px. away connect it with a dotted line to center
                        if (trackerPoint.meanGazeCoordinatesLeft.Y >= calPoint.Point.Y + 80 ||
                            trackerPoint.meanGazeCoordinatesLeft.Y <= calPoint.Point.Y + 80)
                        {
                            // Start line
                            var myLine = new Line {
                                X1 = calPoint.Point.X, Y1 = calPoint.Point.Y
                            };

                            // End line
                            if (!double.IsNaN(feedback.Width))
                            {
                                myLine.X2 = adjustedAvgMeanGazePoint.X + feedback.Width / 2;
                            }

                            if (!double.IsNaN(feedback.Height))
                            {
                                myLine.Y2 = adjustedAvgMeanGazePoint.Y + feedback.Height / 2;
                            }

                            myLine.Stroke = Brushes.LightSteelBlue;

                            var dashes = new DoubleCollection {
                                2, 2
                            };
                            myLine.StrokeDashArray = dashes;
                            myLine.StrokeDashCap   = PenLineCap.Round;

                            CanvasCalibration.Children.Add(myLine);

                            // Draw also to Drawing Visual
                            Pen linePen = new Pen();
                            linePen.Brush     = myLine.Stroke;
                            linePen.DashStyle = DashStyles.Dash;
                            linePen.DashCap   = PenLineCap.Round;

                            drawingContext.DrawLine(
                                linePen,
                                new Point(myLine.X1, myLine.Y1),
                                new Point(myLine.X2, myLine.Y2));
                        }

                        #endregion

                        #endregion

                        #region Calculate sum std dev

                        sumDistFromTargetsY += avgMeanGazeCoordinates.Y - (calPoint.Point.Y - calPoint.Diameter / 2);
                        sumDistFromTargetsX += avgMeanGazeCoordinates.X - (calPoint.Point.X - calPoint.Diameter / 2);

                        double sumStdDevAvg = trackerPoint.stdDeviationGazeCoordinatesLeft + trackerPoint.stdDeviationGazeCoordinatesRight;
                        sumStdDevAvg     = sumStdDevAvg / 2;
                        sumStdDeviation += sumStdDevAvg;

                        #endregion
                    }
                }

                #endregion

                #region Draw calibration points (last to stay on top)

                calPoint.Visibility = Visibility.Visible;
                calPoint.Opacity    = 0.5;
                CanvasCalibration.Children.Add(calPoint);
                Canvas.SetTop(calPoint, calPoint.Point.Y - calPoint.Diameter / 2);
                Canvas.SetLeft(calPoint, calPoint.Point.X - calPoint.Diameter / 2);
                Panel.SetZIndex(calPoint, 99);

                // Draw also to Drawing Visual
                SolidColorBrush whiteBrush = new SolidColorBrush();
                whiteBrush.Color = Color.FromArgb(122, 255, 255, 255);
                drawingContext.DrawEllipse(
                    whiteBrush,
                    null,
                    calPoint.Point,
                    calPoint.Diameter / 2,
                    calPoint.Diameter / 2);
                drawingContext.DrawEllipse(
                    null,
                    new Pen(Brushes.Black, 1f),
                    calPoint.Point,
                    8,
                    8);

                // Enable recalibration
                calPoint.OnClick += RecalibratePoint;

                #endregion
            }

            // Generate values for the 1-5 star ratings-control from quality feeback
            AvgSumStdDev       = sumStdDeviation / calibTargets.Count;
            AvgDistFromTargets = ((sumDistFromTargetsY + sumDistFromTargetsX) / 2) / calibTargets.Count;

            // Now perform the rendering of the Visual to a bitmap
            drawingContext.Close();
            var bmp = new RenderTargetBitmap((int)ActualWidth, (int)ActualHeight, 96, 96, PixelFormats.Pbgra32);
            bmp.Render(drawingVisual);

            return(bmp);
        }