Esempio n. 1
0
        /// <summary>
        /// Overridden <see cref="VGElement.GrabHandleMoved(ref GrabHandle, Point)"/>.
        /// Resets bounds of the arrow
        /// according to the movement of the given grab handle
        /// </summary>
        /// <param name="handle">GrabHandle that moved</param>
        /// <param name="handleMovement">Movement in stimulus coordinates</param>
        public override void GrabHandleMoved(ref GrabHandle handle, Point handleMovement)
        {
            if (handle.GrabHandlePosition == GrabHandle.HandlePosition.Center)
            {
                PointF newCenter = new PointF(this.Center.X - handleMovement.X, this.Center.Y - handleMovement.Y);
                this.Center = newCenter;
                this.AddGrabHandles();
            }
            else
            {
                if (VGPolyline.Distance(handle.Center, this.firstPoint) < GrabHandle.HANDLESIZE)
                {
                    this.firstPoint.X -= handleMovement.X;
                    this.firstPoint.Y -= handleMovement.Y;
                }
                else if (VGPolyline.Distance(handle.Center, this.secondPoint) < GrabHandle.HANDLESIZE)
                {
                    this.secondPoint.X -= handleMovement.X;
                    this.secondPoint.Y -= handleMovement.Y;
                }

                PointF newHandleLocation = new PointF(
                    handle.Location.X - handleMovement.X,
                    handle.Location.Y - handleMovement.Y);

                handle.Location = newHandleLocation;
            }

            this.Modified = true;
        }
Esempio n. 2
0
 /// <summary>
 /// Initializes a new instance of the VGPolyline class.
 /// Clone Constructor. Creates new polyline element that is
 /// identical to the given polyline.
 /// </summary>
 /// <param name="newPolyline">Polyline to clone</param>
 private VGPolyline(VGPolyline newPolyline)
     : base(
         newPolyline.ShapeDrawAction,
         newPolyline.Pen,
         newPolyline.Brush,
         newPolyline.Font,
         newPolyline.FontColor,
         newPolyline.Bounds,
         newPolyline.StyleGroup,
         newPolyline.Name,
         newPolyline.ElementGroup,
         newPolyline.Sound)
 {
     this.Path = new GraphicsPath();
     this.Path = newPolyline.GetPathCopy();
 }
Esempio n. 3
0
    /// <summary>
    /// Loads the shapes that are listed in the given database table
    ///   and creates corresponding graphic elements.
    /// </summary>
    /// <param name="areaOfInterestTableRows">
    /// Areas of interest table as
    ///   a <see cref="DataGridViewRowCollection"/>
    /// </param>
    public void LoadShapesFromDataGridView(DataGridViewRowCollection areaOfInterestTableRows)
    {
      try
      {
        // Create aoi elements from data view
        this.AoiCollection = new VGElementCollection();

        foreach (DataGridViewRow row in areaOfInterestTableRows)
        {
          if (!row.IsNewRow)
          {
            // retrieve shape parameters from cell values.
            var shapeName = row.Cells["colShapeName"].Value.ToString();
            var strPtList = row.Cells["colShapePts"].Value.ToString();
            Pen usedPen;
            Font usedFont;
            Color usedFontColor;
            VGAlignment usedAlignment;
            VGStyleGroup usedStyleGroup;
            var pointList = ObjectStringConverter.StringToPointFList(strPtList);
            var usedElementGroup = row.Cells["colShapeGroup"].Value.ToString();
            switch (usedElementGroup)
            {
              case "Target":
                usedPen = this.TargetPen;
                usedFont = this.TargetFont;
                usedFontColor = this.TargetFontColor;
                usedStyleGroup = VGStyleGroup.AOI_TARGET;
                usedAlignment = this.TargetTextAlignment;
                break;
              case "SearchRect":
                usedPen = this.SearchRectPen;
                usedFont = this.SearchRectFont;
                usedFontColor = this.SearchRectFontColor;
                usedStyleGroup = VGStyleGroup.AOI_SEARCHRECT;
                usedAlignment = this.SearchRectTextAlignment;
                break;
              default:
                usedPen = this.DefaultPen;
                usedFont = this.DefaultFonts;
                usedFontColor = this.DefaultFontColor;
                usedStyleGroup = VGStyleGroup.AOI_NORMAL;
                usedAlignment = this.DefaultTextAlignment;
                break;
            }

            // Create the shape depending on ShapeType
            var boundingRect = new RectangleF();
            switch (row.Cells["colShapeType"].Value.ToString())
            {
              case "Rectangle":
                boundingRect.Location = pointList[0];
                boundingRect.Width = pointList[2].X - pointList[0].X;
                boundingRect.Height = pointList[2].Y - pointList[0].Y;

                // Create Rect with defined stroke
                var newRect =
                  new VGRectangle(
                    this.hideAOIDescription ? ShapeDrawAction.Edge : ShapeDrawAction.NameAndEdge, 
                    usedPen, 
                    usedFont, 
                    usedFontColor, 
                    boundingRect, 
                    usedStyleGroup, 
                    shapeName, 
                    usedElementGroup);
                newRect.TextAlignment = usedAlignment;
                this.AoiCollection.Add(newRect);
                break;
              case "Ellipse":
                boundingRect.Location = pointList[0];
                boundingRect.Width = pointList[2].X - pointList[0].X;
                boundingRect.Height = pointList[2].Y - pointList[0].Y;

                // Create Rect with defined stroke
                var newEllipse =
                  new VGEllipse(
                    this.hideAOIDescription ? ShapeDrawAction.Edge : ShapeDrawAction.NameAndEdge, 
                    usedPen, 
                    usedFont, 
                    usedFontColor, 
                    boundingRect, 
                    usedStyleGroup, 
                    shapeName, 
                    usedElementGroup);
                newEllipse.TextAlignment = usedAlignment;
                this.AoiCollection.Add(newEllipse);
                break;
              case "Polyline":

                // Create Polyline with defined stroke
                var newPolyline =
                  new VGPolyline(
                    this.hideAOIDescription ? ShapeDrawAction.Edge : ShapeDrawAction.NameAndEdge, 
                    usedPen, 
                    usedFont, 
                    usedFontColor, 
                    usedStyleGroup, 
                    shapeName, 
                    usedElementGroup);
                newPolyline.TextAlignment = usedAlignment;
                foreach (var point in pointList)
                {
                  newPolyline.AddPt(point);
                }

                newPolyline.ClosePolyline();
                this.AoiCollection.Add(newPolyline);
                break;
            }
          }
        }

        // Reset Elements (deselect and clear all)
        this.ResetPicture();

        this.Elements.AddRange(this.AoiCollection);

        // If there were a selected element before updating, try
        // to select it again.
        if (this.SelectedElement != null)
        {
          foreach (VGElement element in this.Elements)
          {
            if (VGPolyline.Distance(element.Location, this.SelectedElement.Location) < 1)
            {
              this.SelectedElement = element;
              element.IsInEditMode = true;
            }
          }
        }

        this.DrawForeground(true);
      }
      catch (Exception ex)
      {
        ExceptionMethods.HandleException(ex);
      }
    }
Esempio n. 4
0
    ///////////////////////////////////////////////////////////////////////////////
    // Eventhandler for Custom Defined Events                                    //
    ///////////////////////////////////////////////////////////////////////////////
    #region CUSTOMEVENTHANDLER
    #endregion //CUSTOMEVENTHANDLER

    #endregion //EVENTS

    ///////////////////////////////////////////////////////////////////////////////
    // Methods and Eventhandling for Background tasks                            //
    ///////////////////////////////////////////////////////////////////////////////
    #region BACKGROUNDWORKER
    #endregion //BACKGROUNDWORKER

    ///////////////////////////////////////////////////////////////////////////////
    // Inherited methods                                                         //
    ///////////////////////////////////////////////////////////////////////////////
    #region OVERRIDES
    #endregion //OVERRIDES

    ///////////////////////////////////////////////////////////////////////////////
    // Methods for doing main class job                                          //
    ///////////////////////////////////////////////////////////////////////////////
    #region METHODS

    /// <summary>
    /// This method creates the shape that is defined in this dialog to be added to a slide.
    /// </summary>
    /// <returns>The ready to use <see cref="VGElement"/>.</returns>
    private VGElement GenerateNewShape()
    {
      VGElement element = null;
      if (this.rdbRectangle.Checked)
      {
        element = new VGRectangle(
          this.pbcStyle.DrawAction,
          this.pbcStyle.NewPen,
          this.pbcStyle.NewBrush,
          this.pbcStyle.NewFont, 
          this.pbcStyle.NewFontColor,
          new RectangleF(0, 0, 100, 100), 
          VGStyleGroup.None,
          this.pbcStyle.NewName,
          string.Empty);
      }
      else if (this.rdbEllipse.Checked)
      {
        element = new VGEllipse(
          this.pbcStyle.DrawAction,
          this.pbcStyle.NewPen,
          this.pbcStyle.NewBrush, 
          this.pbcStyle.NewFont, 
          this.pbcStyle.NewFontColor,
          new RectangleF(0, 0, 100, 100),
          VGStyleGroup.None, 
          this.pbcStyle.NewName,
          string.Empty);
      }
      else if (this.rdbPolyline.Checked)
      {
        element = new VGPolyline(
          this.pbcStyle.DrawAction,
          this.pbcStyle.NewPen,
          this.pbcStyle.NewBrush,
          this.pbcStyle.NewFont,
          this.pbcStyle.NewFontColor, 
          VGStyleGroup.None,
          this.pbcStyle.NewName,
          string.Empty);
      }
      else if (this.rdbSharp.Checked)
      {
        element = new VGSharp(
          this.pbcStyle.DrawAction,
          this.pbcStyle.NewPen, 
          this.pbcStyle.NewFont, 
          this.pbcStyle.NewFontColor,
          new RectangleF(0, 0, 100, 100), 
          VGStyleGroup.None,
          this.pbcStyle.NewName,
          string.Empty);
      }
      else if (this.rdbLine.Checked)
      {
        element = new VGLine(
          this.pbcStyle.DrawAction,
          this.pbcStyle.NewPen, 
          this.pbcStyle.NewFont, 
          this.pbcStyle.NewFontColor,
          VGStyleGroup.None, 
          this.pbcStyle.NewName,
          string.Empty);
      }

      element.Sound = this.audioControl.Sound;

      return element;
    }
Esempio n. 5
0
    /// <summary>
    /// Adds new points to given polyline, and truncates to <see cref="maxLengthPath"/>
    /// if DiscreteLength flag is set.
    /// </summary>
    /// <param name="polyline">
    /// Polyline to modify
    /// </param>
    /// <param name="validSamples">
    /// A <see cref="List{PointF}"/> with the new samples
    /// to be added to the <see cref="VGPolyline"/>.
    /// </param>
    /// <param name="discreteLength">
    /// <strong>True</strong>, if path should be truncated,
    /// otherwise <strong>false</strong>.
    /// </param>
    /// <param name="time">
    /// The <see cref="Int64"/> with the last points time.
    /// </param>
    private void AddPtsToPolyline(VGPolyline polyline, List<PointF> validSamples, bool discreteLength, long time)
    {
      // Add Point to Polyline
      polyline.AddPts(validSamples);
      polyline.EndTime = time;

      // Switch to fixed length if choosen in UI
      if (discreteLength && (polyline.GetPointCount() > this.maxLengthPath))
      {
        polyline.RemoveFirstPts(polyline.GetPointCount() - this.maxLengthPath);
      }
    }
Esempio n. 6
0
    /// <summary>
    /// Adds new point to given polyline, and truncates to <see cref="maxLengthPath"/>
    /// if DiscreteLength flag is set.
    /// </summary>
    /// <param name="polyline">
    /// Polyline to modify
    /// </param>
    /// <param name="currPt">
    /// new Position
    /// </param>
    /// <param name="discreteLength">
    /// <strong>True</strong>, if path should be truncated,
    /// otherwise <strong>false</strong>.
    /// </param>
    /// <param name="time">
    /// The <see cref="Int64"/> with the points time.
    /// </param>
    private void AddPtToPolyline(VGPolyline polyline, PointF currPt, bool discreteLength, long time)
    {
      // Add Point to Polyline
      polyline.AddPt(currPt);
      polyline.EndTime = time;

      // Switch to fixed length if choosen in UI
      if (discreteLength && (polyline.GetPointCount() > this.maxLengthPath))
      {
        polyline.RemoveFirstPt();
      }
    }
Esempio n. 7
0
    /// <summary>
    /// Initializes standard values of drawing elements
    /// </summary>
    private void InitializeElements()
    {
      try
      {
        this.penGazeCursor = new Pen(Properties.Settings.Default.GazeCursorColor, Properties.Settings.Default.GazeCursorWidth);
        this.penGazeCursor.DashStyle = Properties.Settings.Default.GazeCursorStyle;

        this.penGazePath = new Pen(Properties.Settings.Default.GazePathColor, Properties.Settings.Default.GazePathWidth);
        this.penGazePath.DashStyle = Properties.Settings.Default.GazePathStyle;
        this.penGazePath.LineJoin = LineJoin.Round;

        this.penGazeFixation = new Pen(Properties.Settings.Default.GazeFixationsPenColor, Properties.Settings.Default.GazeFixationsPenWidth);
        this.penGazeFixation.DashStyle = Properties.Settings.Default.GazeFixationsPenStyle;

        this.penGazeFixationConnection = new Pen(Properties.Settings.Default.GazeFixationConnectionsPenColor, Properties.Settings.Default.GazeFixationConnectionsPenWidth);
        this.penGazeFixation.DashStyle = Properties.Settings.Default.GazeFixationConnectionsPenStyle;

        this.penGazeNoData = new Pen(Properties.Settings.Default.GazeNoDataColor, Properties.Settings.Default.GazeNoDataWidth);
        this.penGazeNoData.DashStyle = Properties.Settings.Default.GazeNoDataStyle;

        this.penMouseCursor = new Pen(Properties.Settings.Default.MouseCursorColor, Properties.Settings.Default.MouseCursorWidth);
        this.penMouseCursor.DashStyle = Properties.Settings.Default.MouseCursorStyle;

        this.penMousePath = new Pen(Properties.Settings.Default.MousePathColor, Properties.Settings.Default.MousePathWidth);
        this.penMousePath.DashStyle = Properties.Settings.Default.MousePathStyle;
        this.penMousePath.LineJoin = LineJoin.Round;

        this.penMouseFixation = new Pen(Properties.Settings.Default.MouseFixationsPenColor, Properties.Settings.Default.MouseFixationsPenWidth);
        this.penMouseFixation.DashStyle = Properties.Settings.Default.MouseFixationsPenStyle;

        this.penMouseFixationConnection = new Pen(Properties.Settings.Default.MouseFixationConnectionsPenColor, Properties.Settings.Default.MouseFixationConnectionsPenWidth);
        this.penMouseFixationConnection.DashStyle = Properties.Settings.Default.MouseFixationConnectionsPenStyle;

        this.gazePicEllipse = new VGEllipse(ShapeDrawAction.Fill, this.GrayBrush);
        this.gazePicEllipse.Inverted = true;
        this.gazePicEllipse.ElementGroup = "Default";
        this.mousePicEllipse = new VGEllipse(ShapeDrawAction.Fill, this.GrayBrush);
        this.mousePicEllipse.Inverted = true;
        this.mousePicEllipse.ElementGroup = "Default";

        this.gazeRawPolyline = new VGPolyline(ShapeDrawAction.Edge, this.penGazePath, VGStyleGroup.RPL_PEN_GAZE_PATH, string.Empty, string.Empty);
        this.gazeRawPolyline.ElementGroup = "Default";
        this.mouseRawPolyline = new VGPolyline(ShapeDrawAction.Edge, this.penMousePath, VGStyleGroup.RPL_PEN_MOUSE_PATH, string.Empty, string.Empty);
        this.mouseRawPolyline.ElementGroup = "Default";
        this.gazeFixEllipse = new VGEllipse(ShapeDrawAction.Edge, this.penGazeFixation, VGStyleGroup.RPL_PEN_GAZE_FIX, string.Empty, string.Empty);
        this.gazeFixEllipse.ElementGroup = "Default";
        this.mouseFixEllipse = new VGEllipse(ShapeDrawAction.Edge, this.penMouseFixation, VGStyleGroup.RPL_PEN_MOUSE_FIX, string.Empty, string.Empty);
        this.mouseFixEllipse.ElementGroup = "Default";
        this.gazeFixConPolyline = new VGPolyline(ShapeDrawAction.Edge, this.penGazeFixationConnection, VGStyleGroup.RPL_PEN_GAZE_FIXCON, string.Empty, string.Empty);
        this.gazeFixConPolyline.ElementGroup = "Default";
        this.mouseFixConPolyline = new VGPolyline(ShapeDrawAction.Edge, this.penMouseFixationConnection, VGStyleGroup.RPL_PEN_MOUSE_FIXCON, string.Empty, string.Empty);
        this.mouseFixConPolyline.ElementGroup = "Default";
        this.gazeFixConLine = new VGLine(ShapeDrawAction.Edge, this.penGazeFixationConnection, VGStyleGroup.RPL_PEN_GAZE_FIXCON, string.Empty, string.Empty);
        this.gazeFixConLine.ElementGroup = "Default";
        this.mouseFixConLine = new VGLine(ShapeDrawAction.Edge, this.penMouseFixationConnection, VGStyleGroup.RPL_PEN_MOUSE_FIXCON, string.Empty, string.Empty);
        this.mouseFixConLine.ElementGroup = "Default";

        var gazeCursorSize = (float)Properties.Settings.Default.GazeCursorSize;
        var gazeCursorType = (VGCursor.DrawingCursors)Enum.Parse(
          typeof(VGCursor.DrawingCursors), Properties.Settings.Default.GazeCursorType);
        this.gazeCursor = new VGCursor(this.penGazeCursor, gazeCursorType, gazeCursorSize, VGStyleGroup.RPL_PEN_GAZE_CURSOR);
        this.gazeCursor.ElementGroup = "Default";

        var mouseCursorSize = (float)Properties.Settings.Default.MouseCursorSize;
        var mouseCursorType = (VGCursor.DrawingCursors)Enum.Parse(
          typeof(VGCursor.DrawingCursors), Properties.Settings.Default.MouseCursorType);
        this.mouseCursor = new VGCursor(this.penMouseCursor, mouseCursorType, mouseCursorSize, VGStyleGroup.RPL_PEN_MOUSE_CURSOR);
        this.mouseCursor.ElementGroup = "Default";

        if (Document.ActiveDocument != null)
        {
          this.visiblePartOfScreen = new VGRectangle(
            ShapeDrawAction.Edge, 
            Pens.Red, 
            Document.ActiveDocument.PresentationSizeRectangle);
          this.visiblePartOfScreen.Visible = false;
        }
      }
      catch (Exception ex)
      {
        ExceptionMethods.HandleException(ex);
      }
    }
Esempio n. 8
0
    /// <summary>
    /// This method returns an default colored <see cref="VGElement"/>
    /// that represents the object in the database described by the three parameters
    /// </summary>
    /// <param name="shapeType">A <see cref="String"/> with the shape type Rectangle, Ellipse or Polyline</param>
    /// <param name="shapeName">A <see cref="String"/> with the shape name</param>
    /// <param name="shapeGroup">A <see cref="String"/> with the shapes group</param>
    /// <param name="strPtList">A <see cref="String"/> with the list of points to be converted
    /// with <see cref="ObjectStringConverter.StringToPointFList(String)"/></param>
    /// <returns>A <see cref="VGElement"/> that represents the object in the database described by the three parameters.</returns>
    public static VGElement GetVGElementFromDatabase(
      string shapeType,
      string shapeName,
      string shapeGroup,
      string strPtList)
    {
      // Create the shape depending on ShapeType
      RectangleF boundingRect = new RectangleF();
      List<PointF> pointList = ObjectStringConverter.StringToPointFList(strPtList);

      switch (shapeType)
      {
        case "Rectangle":
          boundingRect.Location = pointList[0];
          boundingRect.Width = pointList[2].X - pointList[0].X;
          boundingRect.Height = pointList[2].Y - pointList[0].Y;

          // Create Rect with defined stroke
          VGRectangle newRect = new VGRectangle(
            ShapeDrawAction.NameAndEdge,
            Pens.Red,
            SystemFonts.MenuFont,
            Color.Black,
            boundingRect,
            VGStyleGroup.None,
            shapeName,
            shapeGroup);
          newRect.TextAlignment = VGAlignment.Center;
          return newRect;
        case "Ellipse":
          boundingRect.Location = pointList[0];
          boundingRect.Width = pointList[2].X - pointList[0].X;
          boundingRect.Height = pointList[2].Y - pointList[0].Y;

          // Create Rect with defined stroke
          VGEllipse newEllipse = new VGEllipse(
            ShapeDrawAction.NameAndEdge,
            Pens.Red,
            SystemFonts.MenuFont,
            Color.Black,
            boundingRect,
            VGStyleGroup.None,
            shapeName,
            shapeGroup);
          newEllipse.TextAlignment = VGAlignment.Center;
          return newEllipse;
        case "Polyline":
          // Create Polyline with defined stroke
          VGPolyline newPolyline = new VGPolyline(
            ShapeDrawAction.NameAndEdge,
            Pens.Red,
            SystemFonts.MenuFont,
            Color.Black,
            VGStyleGroup.None,
            shapeName,
            shapeGroup);
          newPolyline.TextAlignment = VGAlignment.Center;
          foreach (PointF point in pointList)
          {
            newPolyline.AddPt(point);
          }

          newPolyline.ClosePolyline();
          boundingRect = newPolyline.Bounds;
          return newPolyline;
      }

      return null;
    }
Esempio n. 9
0
    /// <summary>
    /// This method converts the AOI table with areas of interest from the database
    /// into a list of <see cref="VGElement"/>s.
    /// </summary>
    /// <param name="aoiTable">The <see cref="DataTable"/> with the AOIs.</param>
    /// <returns>A <see cref="List{VGElement}"/> with the shapes.</returns>
    protected virtual VGElementCollection GetAOIElements(DataTable aoiTable)
    {
      Pen defaultPen = new Pen(Properties.Settings.Default.AOIStandardColor, Properties.Settings.Default.AOIStandardWidth);
      Pen targetPen = new Pen(Properties.Settings.Default.AOITargetColor, Properties.Settings.Default.AOITargetWidth);
      Pen searchRectPen = new Pen(Properties.Settings.Default.AOISearchRectColor, Properties.Settings.Default.AOISearchRectWidth);
      Font defaultFont = (Font)Properties.Settings.Default.AOIStandardFont.Clone();
      Font targetFont = (Font)Properties.Settings.Default.AOITargetFont.Clone();
      Font searchRectFont = (Font)Properties.Settings.Default.AOISearchRectFont.Clone();
      Color defaultFontColor = Properties.Settings.Default.AOIStandardFontColor;
      Color targetFontColor = Properties.Settings.Default.AOITargetFontColor;
      Color searchRectFontColor = Properties.Settings.Default.AOISearchRectFontColor;

      VGElementCollection aoiList = new VGElementCollection();
      int counter = 0;

      try
      {
        foreach (DataRow row in aoiTable.Rows)
        {
          string strPtList = row["ShapePts"].ToString();
          string shapeName = row["ShapeName"].ToString();
          Pen usedPen = defaultPen;
          Font usedFont = defaultFont;
          Color usedFontColor = defaultFontColor;
          VGStyleGroup usedStyleGroup = VGStyleGroup.AOI_NORMAL;
          List<PointF> pointList = ObjectStringConverter.StringToPointFList(strPtList);
          string usedElementGroup = row["ShapeGroup"].ToString();
          switch (usedElementGroup)
          {
            case "Target":
              usedPen = targetPen;
              usedFont = targetFont;
              usedFontColor = targetFontColor;
              usedStyleGroup = VGStyleGroup.SCA_GRID_AOI;
              break;
            case "SearchRect":
              usedPen = searchRectPen;
              usedFont = searchRectFont;
              usedFontColor = searchRectFontColor;
              usedStyleGroup = VGStyleGroup.SCA_GRID_AOI;
              break;
            default:
              usedPen = defaultPen;
              usedFont = defaultFont;
              usedFontColor = defaultFontColor;
              usedStyleGroup = VGStyleGroup.SCA_GRID_AOI;
              break;
          }

          // Create the shape depending on ShapeType
          RectangleF boundingRect = new RectangleF();
          switch (row["ShapeType"].ToString())
          {
            case "Rectangle":
              boundingRect.Location = pointList[0];
              boundingRect.Width = pointList[2].X - pointList[0].X;
              boundingRect.Height = pointList[2].Y - pointList[0].Y;

              // Create Rect with defined stroke
              VGRectangle newRect = new VGRectangle(
                ShapeDrawAction.NameAndEdge,
                usedPen,
                usedFont,
                usedFontColor,
                boundingRect,
                usedStyleGroup,
                shapeName,
                usedElementGroup);

              aoiList.Add(newRect);
              break;
            case "Ellipse":
              boundingRect.Location = pointList[0];
              boundingRect.Width = pointList[2].X - pointList[0].X;
              boundingRect.Height = pointList[2].Y - pointList[0].Y;

              // Create Rect with defined stroke
              VGEllipse newEllipse = new VGEllipse(
                ShapeDrawAction.NameAndEdge,
                usedPen,
                usedFont,
                usedFontColor,
                boundingRect,
                usedStyleGroup,
                shapeName,
                usedElementGroup);

              aoiList.Add(newEllipse);
              break;
            case "Polyline":
              // Create Polyline with defined stroke
              VGPolyline newPolyline = new VGPolyline(
                ShapeDrawAction.NameAndEdge,
                usedPen,
                usedFont,
                usedFontColor,
                usedStyleGroup,
                shapeName,
                usedElementGroup);

              foreach (PointF point in pointList)
              {
                newPolyline.AddPt(point);
              }

              newPolyline.ClosePolyline();
              aoiList.Add(newPolyline);
              boundingRect = newPolyline.Bounds;
              break;
          }

          counter++;
        }
      }
      catch (Exception ex)
      {
        ExceptionMethods.HandleException(ex);
      }

      return aoiList;
    }
Esempio n. 10
0
 /// <summary>
 /// Initializes a new instance of the VGPolyline class.
 /// Clone Constructor. Creates new polyline element that is
 /// identical to the given polyline.
 /// </summary>
 /// <param name="newPolyline">Polyline to clone</param>
 private VGPolyline(VGPolyline newPolyline)
   : base(
   newPolyline.ShapeDrawAction,
   newPolyline.Pen,
   newPolyline.Brush,
   newPolyline.Font,
   newPolyline.FontColor,
   newPolyline.Bounds,
   newPolyline.StyleGroup,
   newPolyline.Name,
   newPolyline.ElementGroup,
   newPolyline.Sound)
 {
   this.Path = new GraphicsPath();
   this.Path = newPolyline.GetPathCopy();
 }
Esempio n. 11
0
    /// <summary>
    /// This static method calculates the sum of fixation connections,
    /// which is a gaze path length.
    /// </summary>
    /// <param name="fixationTable">A <see cref="DataTable"/> with the fixations
    /// to use.</param>
    /// <returns>A <see cref="Single"/> with the path length in pixel.</returns>
    private static float CalcPathLengthOfFixationConnections(DataTable fixationTable)
    {
      // Fixation PathLength
      // no fixation available
      float pathLengthGaze = -1f;

      VGPolyline polylineGaze = new VGPolyline(ShapeDrawAction.Edge, Pens.Green);
      foreach (DataRow row in fixationTable.Rows)
      {
        float gazeX = !row.IsNull("PosX") ? Convert.ToSingle(row["PosX"]) : 0;
        float gazeY = !row.IsNull("PosY") ? Convert.ToSingle(row["PosY"]) : 0;
        if (gazeX != 0 || gazeY != 0)
        {
          polylineGaze.AddPt(new PointF(gazeX, gazeY));
        }
      }

      if (polylineGaze.GetPointCount() >= 2)
      {
        // Connections available
        pathLengthGaze = polylineGaze.GetLength();
      }
      else if (polylineGaze.GetPointCount() == 1)
      {
        // Only one fixation, so no connections
        pathLengthGaze = 0;
      }

      return pathLengthGaze;
    }
Esempio n. 12
0
    /// <summary>
    /// This static method calculates the raw data related variables as there 
    /// are distance of gaze and mouse path along with loss and out of
    /// monitor values.
    /// </summary>
    /// <param name="subjectName">A <see cref="string"/> with the subject name.</param>
    /// <param name="trialSequence">An <see cref="int"/> with the trial sequence number.</param>
    /// <param name="countBlinkLoss">Ref. Counts the samples the are lost due to blinks.</param>
    /// <param name="countOutOfMonitorLoss">Ref. Counts the samples the are lost due to out of monitor samples.</param>
    /// <param name="pathLengthMouse">Ref. Returns the path length of the mouse path.</param>
    /// <param name="averageDistance">Ref. Returns the average distance of gaze and mouse path in pixel.</param>
    /// <param name="countSamples">Ref. Counts the number of samples.</param>
    private static void CalcRawDataRelatedVariables(
      string subjectName,
      int trialSequence,
      ref int countBlinkLoss,
      ref int countOutOfMonitorLoss,
      ref float pathLengthMouse,
      ref float averageDistance,
      ref int countSamples)
    {
      // Get RawData
      DataTable rawDataTable =
        Queries.GetRawDataBySubjectAndTrialSequenceWithoutEvents(subjectName, trialSequence);

      // In this section only mouse polyline is created, 
      // because the gaze path length is calculated as the 
      // distance between fixations to avoid
      // including microsaccade movements.
      VGPolyline polylineMouse = new VGPolyline(ShapeDrawAction.Edge, Pens.Red);
      float sumDistance = 0;
      int distancesCount = 0;

      // Loop RawData and drawPolyline
      foreach (DataRow row in rawDataTable.Rows)
      {
        PointF? newGazePoint;
        SampleValidity isGazeValidData = Queries.GetGazeData(
          row,
          Document.ActiveDocument.PresentationSize,
          out newGazePoint);

        switch (isGazeValidData)
        {
          case SampleValidity.Valid:
            break;
          case SampleValidity.Empty:
            countBlinkLoss++;
            break;
          case SampleValidity.Null:
            countBlinkLoss++;
            break;
          case SampleValidity.OutOfStimulus:
            countOutOfMonitorLoss++;
            break;
        }

        PointF? newMousePoint;
        SampleValidity isMouseValidData = Queries.GetMouseData(
          row,
          Document.ActiveDocument.PresentationSize,
          out newMousePoint);

        switch (isMouseValidData)
        {
          case SampleValidity.Valid:
          case SampleValidity.Empty:
          case SampleValidity.OutOfStimulus:
            // mouse is always detected and never out of screen
            polylineMouse.AddPt(newMousePoint.Value);
            break;
          case SampleValidity.Null:
            break;
        }

        // Calculate Distance of Gaze And Mouse Path
        if (isGazeValidData == SampleValidity.Valid &&
          (isMouseValidData == SampleValidity.Valid || isMouseValidData == SampleValidity.Empty))
        {
          sumDistance += VGPolyline.Distance(newGazePoint.Value, newMousePoint.Value);
          distancesCount++;
        }
      }

      if (polylineMouse.GetPointCount() >= 2)
      {
        pathLengthMouse = polylineMouse.GetLength();
      }
      else if (polylineMouse.GetPointCount() == 1)
      {
        pathLengthMouse = 0;        // No Movement in MouseData
      }

      if (distancesCount > 0)
      {
        averageDistance = sumDistance / distancesCount;
      }
      else
      {
        averageDistance = -1;
      }

      countSamples = rawDataTable.Rows.Count;

      rawDataTable.Dispose();
    }