public System.Drawing.PointF GetRelativePosition(Control c) {
	    	System.Drawing.Point relPoint;
	    	System.Drawing.PointF relPointF;
	    	relPoint = c.PointToClient(new System.Drawing.Point((int)ScreenX,(int)ScreenY));
	    	relPointF = new System.Drawing.PointF(relPoint.X + ScreenX - (float)((int)ScreenX),
	    	                                      relPoint.Y + ScreenY - (float)((int)ScreenY));
	    	return relPointF;
	    }

 public PointF(float x, float y)
 {
     InternalVector2 = new Vector2(x, y);
     InternalPointF = new System.Drawing.PointF(x, y);
     X = x;
     Y = y;
 }

        public VirtualProjector(string name, string uuid, Size imageSize, PointF principal, double focalLength, Screen screen, Chessboard chessboard, CaptureCamera captureCamera)
            : base(name, uuid, imageSize, principal, focalLength, screen, chessboard, captureCamera)
        {
            OrbitCamera = new OrbitCamera("{0} Orbit".FormatWith(name), "N/A", imageSize, principal, focalLength,
                Intrinsics.NearPlaneDistance, Intrinsics.FarPlaneDistance) { Color = Color.DarkCyan.Alpha(0.7f), };
            Color = Color.DarkKhaki.Alpha(0.6f);
            
            ProgramTask.AttachInputToCamera(Program.WhenInput.Where(input => !input.KeyPressed(Keys.C)), Window, OrbitCamera);

            Program.WhenInput.Where(input => input.KeyDown(Keys.P)).Subscribe(input =>
            {
                var frustum = new Frustum(OrbitCamera, Intrinsics.ImageSize);

                var plane = new Plane(Vector3.UnitZ, 0);

                var p0 = frustum.IntersectWithPlane(ProjectorQuadCorners[0].X, ProjectorQuadCorners[0].Y, plane).ToPointF();
                var p1 = frustum.IntersectWithPlane(ProjectorQuadCorners[1].X, ProjectorQuadCorners[1].Y, plane).ToPointF();
                var p2 = frustum.IntersectWithPlane(ProjectorQuadCorners[2].X, ProjectorQuadCorners[2].Y, plane).ToPointF();
                var p3 = frustum.IntersectWithPlane(ProjectorQuadCorners[3].X, ProjectorQuadCorners[3].Y, plane).ToPointF();

                var quadCorners = new[] { p0, p1, p2, p3, };

                // Chessboard.HomographTo(quadCorners);
            });
        }

        public System.Drawing.PointF[] ComputeDepthFrameToCameraSpaceTable(int tableWidth = depthImageWidth, int tableHeight = depthImageHeight)
        {
            float fx = (float)depthCameraMatrix[0, 0];
            float fy = (float)depthCameraMatrix[1, 1];
            float cx = (float)depthCameraMatrix[0, 2];
            float cy = (float)depthCameraMatrix[1, 2];
            float[] kappa = new float[] { (float)depthLensDistortion[0], (float)depthLensDistortion[1] };

            var table = new System.Drawing.PointF[tableWidth * tableHeight];

            for (int y = 0; y < tableHeight; y++)
                for (int x = 0; x < tableWidth; x++)
                {
                    double xout, yout;
                    double framex = (double)x / (double)tableWidth * depthImageWidth;   // in depth camera image coordinates
                    double framey = (double)y / (double)tableHeight * depthImageHeight;

                    CameraMath.Undistort(fx, fy, cx, cy, kappa, framex, (depthImageHeight - framey), out xout, out yout);

                    var point = new System.Drawing.PointF();
                    point.X = (float)xout;
                    point.Y = (float)yout;
                    table[tableWidth * y + x] = point;
                }
            return table;
        }

 /// <summary>
 /// Method to render the arrow
 /// </summary>
 /// <param name="map">The map</param>
 /// <param name="graphics">The graphics object</param>
 /// <param name="arrow">The arrow</param>
 private void RenderArrow(SharpMap.Map map, System.Drawing.Graphics graphics, GeoAPI.Geometries.ILineString arrow)
 {
     var pts = new System.Drawing.PointF[arrow.Coordinates.Length];
     for (var i = 0; i < pts.Length; i++)
         pts[i] = map.WorldToImage(arrow.GetCoordinateN(i));
     graphics.DrawLines(ArrowPen, pts);
 }

 public override void Draw(System.Drawing.Graphics g)
 {
     System.Drawing.SolidBrush solidBrush = new System.Drawing.SolidBrush(Color);
     System.Drawing.PointF upperLeftPoint = new System.Drawing.PointF((float)(Center.X - Width / 2), (float)(Center.Y - Height / 2));
     System.Drawing.SizeF rectSize = new System.Drawing.SizeF((float)Width, (float)Height);
     System.Drawing.RectangleF rect = new System.Drawing.RectangleF(upperLeftPoint, rectSize);
     g.FillRectangle(solidBrush, rect);
     solidBrush.Dispose();
 }

 public override void Draw(System.Drawing.Graphics g)
 {
     System.Drawing.SolidBrush solidBrush = new System.Drawing.SolidBrush(Color);
     System.Drawing.PointF upperLeftPoint = new System.Drawing.PointF((float)(Center.X - RadiusX), (float)(Center.Y - RadiusY));
     System.Drawing.SizeF rectSize = new System.Drawing.SizeF((float)(2 * RadiusX), (float)(2 * RadiusY));
     System.Drawing.RectangleF rect = new System.Drawing.RectangleF(upperLeftPoint, rectSize);
     g.FillEllipse(solidBrush, rect);
     solidBrush.Dispose();
 }

		private void PopulateRotationCorrectedTranslationIncrements(Angle headingChange)
		{
			double s = Math.Sin(headingChange.Rads);
			double c = Math.Cos(headingChange.Rads);

			m_TranslationIncrements.Clear();
			System.Drawing.PointF[] featurePointPair = new System.Drawing.PointF[2];

			List<TrackedFeature> trackedFeatures = m_VisualOdometer.TrackedFeatures;
			m_GroundFeatures.Clear();
			for (int i = 0; i < trackedFeatures.Count; i++)
			{
				TrackedFeature trackedFeature = trackedFeatures[i];
				if (trackedFeature.Count < 2)
				{
					continue;
				}

				// previous and current feature points need to be in the ground region
				if (!(trackedFeature[-1].Y > m_VisualOdometer.GroundRegionTop && trackedFeature[0].Y > m_VisualOdometer.GroundRegionTop))
				{
					continue;
				}

				featurePointPair[0] = trackedFeature[-1]; // previous feature location
				featurePointPair[1] = trackedFeature[0];  // current featue location
				//Debug.WriteLine("Raw:");
				//Debug.WriteLine("\tPrevious dx_r: {0:0.000}  dy_r: {1:0.000}", featurePointPair[0].X, featurePointPair[0].Y);
				//Debug.WriteLine("\tCurrent  dx_r: {0:0.000}  dy_r: {1:0.000}", featurePointPair[1].X, featurePointPair[1].Y);

				ProjectOnFloor(featurePointPair);
				//Debug.WriteLine("Ground:");
				//Debug.WriteLine("\tPrevious dx_r: {0:0.000}  dy_r: {1:0.000}", featurePointPair[0].X, featurePointPair[0].Y);
				//Debug.WriteLine("\tCurrent  dx_r: {0:0.000}  dy_r: {1:0.000}", featurePointPair[1].X, featurePointPair[1].Y);


				// Remove rotation effect on current feature location. The center of the rotation is the previous feature location
				Point rotationCorrectedEndPoint = new Point(
					c * featurePointPair[1].X - s * featurePointPair[1].Y,
					s * featurePointPair[1].X + c * featurePointPair[1].Y);

				Point translationIncrement = new Point(
					featurePointPair[0].X - rotationCorrectedEndPoint.X,
					featurePointPair[0].Y - rotationCorrectedEndPoint.Y);

				//double translationAngle = Math.Abs(Math.Atan2(translationIncrement.X, translationIncrement.Y));
				////Debug.WriteLine(translationAngle * 180 / Math.PI);
				//if (translationAngle > acceptedDirectionMisaligment)
				//{
				//    continue;
				//}

				//m_UsedGroundFeatures.Add(trackedFeature);
				m_TranslationIncrements.Add(translationIncrement);
				m_GroundFeatures.Add(trackedFeature);
			}
		}

 public static System.Drawing.PointF[] ToPointFArray(DataP3[] data)
 {
     int n = data.Length;
     System.Drawing.PointF[] newData = new System.Drawing.PointF[n];
     for (int i = 0; i < n; i++)
     {
         newData[i] = new System.Drawing.PointF((float)data[i].X, (float)data[i].Y);
     }
     return newData;
 }

 public void TestDashedLineStartEnd()
 {
     System.Drawing.PointF start = new System.Drawing.PointF();
     System.Drawing.PointF end = new System.Drawing.PointF();
     string expectedString = null;
     string resultString = null;
     resultString = SVGUtil.DashedLine(start, end);
     Assert.AreEqual(expectedString, resultString, "DashedLine method returned unexpected result.");
     Assert.Fail("Create or modify test(s).");
 }

 /// <summary>
 /// Initializes a new LabelStyle
 /// </summary>
 public LabelStyle()
 {
     _Font = new System.Drawing.Font("Times New Roman", 12f);
     _Offset = new System.Drawing.PointF(0, 0);
     _CollisionDetection = false;
     _CollisionBuffer = new System.Drawing.Size(0, 0);
     _ForeColor = System.Drawing.Color.Black;
     _HorisontalAlignment = HorizontalAlignmentEnum.Center;
     _VerticalAlignment = VerticalAlignmentEnum.Middle;
 }

 public override void Draw(System.Drawing.Graphics g)
 {
     System.Drawing.SolidBrush solidBrush = new System.Drawing.SolidBrush(Color);
     System.Drawing.PointF[] points = new System.Drawing.PointF[3];
     points[0] = new System.Drawing.PointF((float)Vertex1.X, (float)Vertex1.Y);
     points[1] = new System.Drawing.PointF((float)Vertex2.X, (float)Vertex2.Y);
     points[2] = new System.Drawing.PointF((float)Vertex3.X, (float)Vertex3.Y);
     g.FillPolygon(solidBrush, points);
     solidBrush.Dispose();
 }

        public RealProjector(string name, string uuid, Size imageSize, PointF principal, double focalLength, Screen screen)
            : base(name, uuid, imageSize, principal, focalLength)
        {
            Window = new Window("Pentacorn Projector")
            {
                LocatedOnScreen = screen,
                FullScreen = true,
            };

            Color = Color.DarkBlue;
            Window.Scene = new Scene(new ScreenCamera(Window)) { new Clear(Color.White), };
        }

 public InvoiceTableView()
     : base(MonoTouch.UIKit.UITableViewStyle.Plain)
 {
     CellIdentifier = InvoiceLineCell.Key;
     SectionHeaderHeight = 30;
     RowHeight = 60;
     ContentOffset = new System.Drawing.PointF (0, -100);
     BackgroundView = null;
     BackgroundColor = UIColor.Clear;
     AutoScroll = true;
     this.ItemTapped = (i) => {
         (i as InvoiceLine).ToggleSelected();
     };
 }

        public static void Init(TestContext context)
        {
            dp1 = new System.Drawing.Point(10, 10);
            dp2 = new System.Drawing.Point(100, 100);
            drect = new System.Drawing.Rectangle(5, 5, 15, 15);

            wp1 = new System.Windows.Point(10, 10);
            wp2 = new System.Windows.Point(100, 100);
            wrect = new System.Windows.Rect(5, 5, 15, 15);

            fp1 = new System.Drawing.PointF(10, 10);
            fp2 = new System.Drawing.PointF(100, 100);
            frect = new System.Drawing.RectangleF(5, 5, 15, 15);
        }

        public override void Start()
        {
            time = 20;
            win = 10;
            startingTime = 3;

            state = State.Starting;

            x = 0;
            y = 0;

            recPos = new System.Drawing.PointF(50, 50);

            timer.Start();
        }

        private ITriangle FindTriangleAt(float x, float y)
        {
            // Get mesh coordinates
            var p = new System.Drawing.PointF(x, y);
            renderControl.Zoom.ScreenToWorld(ref p);

            topoControlView.SetPosition(p);

            if (tree == null)
            {
                tree = new TriangleQuadTree(mesh, 5, 2);
            }

            return tree.Query(p.X, p.Y);
        }

        //public PolygonShape2D(string containerName, List<Point> points)
        //{
        //    this.ContainerName = containerName;
        //    this.Points = points;
        //}
        public PolygonShape2D(string containerName, Shape sh, Matrix m)
        {
            this.ContainerName = containerName;
            List<IShapeData> sd = sh.ShapeData;
            EnsureClockwise(sd);

            System.Drawing.PointF[] pts = new System.Drawing.PointF[ sd.Count];
            for (int i = 0; i < sd.Count; i++)
            {
                pts[i] = new System.Drawing.PointF(sd[i].StartPoint.X, sd[i].StartPoint.Y);
            }
            System.Drawing.Drawing2D.Matrix m2 = m.GetDrawing2DMatrix();
            m2.TransformPoints(pts);
            for (int i = 0; i < pts.Length; i++)
            {
                Points.Add(new Point(pts[i].X, pts[i].Y));
            }
        }

 public virtual bool IsPointInside(Point p)
 {
     bool result = false;
     System.Drawing.Drawing2D.Matrix m = this.Transforms[0].Matrix.GetDrawing2DMatrix();
     m.Invert();
     System.Drawing.PointF[] p2 = new System.Drawing.PointF[] { new System.Drawing.PointF(p.X, p.Y) };
     m.TransformPoints(p2);
     Point tp = new Point(p2[0].X, p2[0].Y);
     for (int i = 0; i < this.Definition.Shapes.Count; i++)
     {
         if (this.Definition.Shapes[i].IsPointInside(tp))
         {
             result = true;
             break;
         }
     }
     return result;
 }

      /// <summary>
      /// Calculates optical flow for a sparse feature set using iterative Lucas-Kanade method in pyramids
      /// </summary>
      /// <param name="prev">First frame, at time t</param>
      /// <param name="curr">Second frame, at time t + dt </param>
      /// <param name="prevPyrBuffer">Buffer for the pyramid for the first frame. If it is not NULL, the buffer must have a sufficient size to store the pyramid from level 1 to level #level ; the total size of (image_width+8)*image_height/3 bytes is sufficient</param>
      /// <param name="currPyrBuffer">Similar to prev_pyr, used for the second frame</param>
      /// <param name="prevFeatures">Array of points for which the flow needs to be found</param>
      /// <param name="winSize">Size of the search window of each pyramid level</param>
      /// <param name="level">Maximal pyramid level number. If 0 , pyramids are not used (single level), if 1 , two levels are used, etc</param>
      /// <param name="criteria">Specifies when the iteration process of finding the flow for each point on each pyramid level should be stopped</param>
      /// <param name="flags">Flags</param>
      /// <param name="currFeatures">Array of 2D points containing calculated new positions of input features in the second image</param>
      /// <param name="status">Array. Every element of the array is set to 1 if the flow for the corresponding feature has been found, 0 otherwise</param>
      /// <param name="trackError">Array of double numbers containing difference between patches around the original and moved points</param>
      public static void PyrLK(
         Image<Gray, Byte> prev,
         Image<Gray, Byte> curr,
         Image<Gray, Byte> prevPyrBuffer,
         Image<Gray, Byte> currPyrBuffer,
         System.Drawing.PointF[] prevFeatures,
         System.Drawing.Size winSize,
         int level,
         MCvTermCriteria criteria,
         Emgu.CV.CvEnum.LKFLOW_TYPE flags,
         out System.Drawing.PointF[] currFeatures,
         out Byte[] status,
         out float[] trackError)
      {
         if (prevPyrBuffer == null)
         {
            prevPyrBuffer = new Image<Gray, byte>(prev.Width + 8, prev.Height / 3);
         }
         if (currPyrBuffer == null)
         {
            currPyrBuffer = prevPyrBuffer.CopyBlank();
         }

         status = new Byte[prevFeatures.Length];
         trackError = new float[prevFeatures.Length];

         currFeatures = new System.Drawing.PointF[prevFeatures.Length];

         CvInvoke.cvCalcOpticalFlowPyrLK(
            prev,
            curr,
            prevPyrBuffer,
            currPyrBuffer,
            prevFeatures,
            currFeatures,
            prevFeatures.Length,
            winSize,
            level,
            status,
            trackError,
            criteria,
            flags);
      }