public static bool CircleIntersectSegment(LineSegment<Vector2> segment, Circle circle, out Vector2 intersection)
 {
     intersection = ClosestPointOnSegment(segment, circle.Position);
     var distance2 = DistanceSquared(intersection, circle.Position);
     if (distance2 <= circle.Radius * circle.Radius) return true;
     else return false;
 }

        public bool CollidesWith(LineSegment lineSegment)
        {
            var axisA = new Line(Point1, Point2.Substract(Point1));

            if (axisA.OnOneSide(lineSegment))
            {
                return false;
            }

            var axisB = new Line(lineSegment.Point1, lineSegment.Point2.Substract(lineSegment.Point1));

            if (axisB.OnOneSide(this))
            {
                return false;
            }

            if (axisA.Direction.IsParallel(axisB.Direction))
            {
                Range rangeA = ProjectOnto(axisA.Direction);
                Range rangeB = lineSegment.ProjectOnto(axisA.Direction);

                return rangeA.Overlaps(rangeB);
            }

            return true;
        }

		public static Point ProjectOnto(this Point p, LineSegment seg, LineType type, out int? end)
		{
			end = 0;
			Vector v = seg.Vector();
			Vector w = p.Sub(seg.A);
			T c1 = w.Dot(v); // c1 == |w|*|v|*cos(angle between them)
			if (c1 <= 0) { // angle between line segment and (p-seg.A) is negative (-180..0)?
				if (v.X == 0 && v.Y == 0) {
					// seg.A == seg.B
					end = null;
					return seg.A;
				} else if (c1 < 0)
					end = -1;
				if (type != LineType.Infinite)
					return seg.A;
			}
			T c2 = v.Quadrance(); // == |v|*|v|
			if (c1 >= c2) { // quadrance from seg.A to projected point >= quadrance of seg
				if (c1 > c2)
					end = 1;
				if (type == LineType.Segment)
					return seg.B;
			}
			if (c2 == 0) {
				// seg.A and seg.B are infitessimally close together; c2 was truncated to zero
				end = null;
				return seg.A;
			}

			T frac = c1 / c2;                    // == |w|/|v|*cos(angle)
			Point projected = seg.A.Add(v.Mul(frac)); // == p0 + v/|v|*|w|*cos(angle)
			return projected;
		}

        public void Test_SetLineLength()
        {
            var line = new LineSegment ();
            line.Length = 2;

            Assert.AreEqual (2.0f, line.Length);
        }

    public void CheckPaths(LineSegment line, Vector3 slot)
    {
        var p1 = line.p1 * divisions;
        var p2 = line.p2 * divisions;
        var th = 0.01f;
        th += 0.5f;
        if (p1.x == p2.x && p1.z != p2.z && p1.y == p2.y) // travels along z, stationary in x and y
        {
            var line2d = new Vector2(p1.x, p1.y);
            var slot2d = new Vector2(slot.x, slot.y);
            if (Vector2.Distance(line2d, slot2d) <= th)
            {
                if (p1.z < p2.z && p1.z <= slot.z - th && p2.z >= slot.z + th)
                    MakeNew(slot, line);
            }
        }

        else if (p1.z == p2.z && p1.x != p2.x && p1.y == p2.y) // travels along x, stationary in z and y
        {
            var line2d = new Vector2(p1.y, p1.z);
            var slot2d = new Vector2(slot.y, slot.z);
            if (Vector2.Distance(line2d, slot2d) <= th)
                if (p1.x < p2.x && p1.x <= slot.x - th && p2.x >= slot.x + th)
                    MakeNew(slot, line);
        }
    }

	private void SetPlayShape()
	{
		play.Children.Clear ();

		Path p = new Path();
		PathGeometry geometry = new PathGeometry ();
		PathFigure f = new PathFigure ();	
		f.Segments = new PathSegmentCollection ();

		p.Data = geometry;
		p.Fill = new SolidColorBrush(Colors.Red);
		p.Stroke = new SolidColorBrush(Colors.Black);
		geometry.Figures = new PathFigureCollection ();
		geometry.Figures.Add(f);

		LineSegment m = new LineSegment();
		m.Point = new Point(3, 2);
		f.Segments.Add(m);

		m = new LineSegment();	
		m.Point = new Point(14, 8.5);
		f.Segments.Add(m);

		m = new LineSegment();	
		m.Point = new Point(3, 15);
		f.Segments.Add(m);

		m = new LineSegment();	
		m.Point = new Point(3, 2);
		f.Segments.Add(m);

		play.Children.Add(p);
	}

 public void ScanVoxels(LineSegment line, bool movesInX)
 {
     var divisions = cSectionGCD.sloxelResolution.x;
     var half = 0.5f / divisions;
     foreach (var v in cSectionGCD.voxels)
     {
         if (movesInX)
         {
             var x = v.Key.x;
             var v2d = new Vector2(v.Key.y, v.Key.z);
             var l2d = new Vector2(line.p1.y, line.p1.z);
             if (Mathf.Abs(v.Key.y - line.p1.y) <= half && Mathf.Abs(v.Key.z - line.p1.z) <= half)
             {
                 if (line.p2.x > line.p1.x && line.p1.x < x + half && line.p2.x > x - half) // p2 greater than p1, p1 < x + half,  p2 > x - half
                     MakeNew(v.Value, line);
                 else if (line.p2.x < line.p1.x && line.p1.x > x - half && line.p2.x < x + half)
                     MakeNew(v.Value, line);
             }
         }
         else // Moves In Z
         {
             var z = v.Key.z;
             var v2 = new Vector2(v.Key.x, v.Key.y);
             var l2 = new Vector2(line.p1.x, line.p1.y);
             if (Mathf.Abs(v.Key.x - line.p1.x) <= half && Mathf.Abs(v.Key.y - line.p1.y) <= half)
             {
                 if (line.p2.z > line.p1.z && line.p1.z < z + half && line.p2.z > z - half) // p2 greater than p1, p1 < x + half,  p2 > x - half
                     MakeNew(v.Value, line);
                 else if (line.p2.z < line.p1.z && line.p1.z > z - half && line.p2.z < z + half)
                     MakeNew(v.Value, line);
             }
         }
     }
 }

        public void Test_SetLineWidth()
        {
            var line = new LineSegment ();
            line.Width = 2.0f;

            Assert.AreEqual (2.0f, line.Width);
        }

        // Creates a polyline with two paths in the shape of an 'X' centered at the given point
        private Polyline CreatePolylineX(MapPoint center, double length)
        {
            var halfLen = length / 2.0;

			LineSegment segment = new LineSegment(
				new MapPoint(center.X - halfLen, center.Y + halfLen, MyMapView.SpatialReference),
				new MapPoint(center.X + halfLen, center.Y - halfLen, MyMapView.SpatialReference));

			LineSegment segment2 = new LineSegment(
				new MapPoint(center.X + halfLen, center.Y + halfLen, MyMapView.SpatialReference),
				new MapPoint(center.X - halfLen, center.Y - halfLen, MyMapView.SpatialReference));

			var segmentCollection = new SegmentCollection(MyMapView.SpatialReference)
			{
				segment
			};

			var segmentCollection2 = new SegmentCollection(MyMapView.SpatialReference)
			{
				segment2
			};

			return new Polyline(new [] { segmentCollection, segmentCollection2},
				MyMapView.SpatialReference);
        }

 public PathStatistics(PathData data)
 {
     _data = data;
     int i = 1;
     _totalLength = 0;
     ISegment newSegment;
     while (i < _data.Points.Length)
     {
         switch (_data.Types[i])
         {
             case 1:
                 newSegment = new LineSegment(_data.Points[i - 1], _data.Points[i]);
                 i++;
                 break;
             case 3:
                 newSegment = new CubicBezierSegment(_data.Points[i - 1], _data.Points[i], _data.Points[i + 1], _data.Points[i + 2]);
                 i+= 3;
                 break;
             default:
                 throw new NotSupportedException();
         }
         newSegment.StartOffset = _totalLength;
         _segments.Add(newSegment);
         _totalLength += newSegment.Length;
     }
 }

		public LLMarkerRotated LLShape(DrawStyle style, ref LineSegment<Coord> toArrow)
		{
			Coord frac = Width * Scale / toArrow.Length();
			var markerPoint = toArrow.PointAlong(1 - frac * 0.5f);
			toArrow = toArrow.A.To(toArrow.PointAlong(1 - Math.Min(frac, 1)));
			return new LLMarkerRotated(style, markerPoint, Scale, Geometry, (Coord)toArrow.Vector().AngleDeg());
		}

 /// <summary>
 /// Projects the specified line segment on the specified plane.
 /// </summary>
 /// <param name="lineSegment">A line segment.</param>
 /// <param name="plane">A plane.</param>
 /// <returns>The <paramref name="lineSegment"/> projected on the <paramref name="plane"/>.</returns>
 public static LineSegment LineSegmentOnPlane(LineSegment lineSegment, Plane plane)
 {
     return new LineSegment
     {
         End1 = Project.PointOnPlane(lineSegment.End1, plane),
         End2 = Project.PointOnPlane(lineSegment.End2, plane),
     };
 }

 /// <summary>
 /// Projects the specified line segment on the specified line segment.
 /// </summary>
 /// <param name="lineSegment1">A line segment.</param>
 /// <param name="lineSegment2">A line segment.</param>
 /// <returns>The <paramref name="lineSegment1"/> projected on the <paramref name="lineSegment2"/>.</returns>
 public static LineSegment LineSegmentOnLineSegment(LineSegment lineSegment1, LineSegment lineSegment2)
 {
     return new LineSegment
     {
         End1 = Project.PointOnLineSegment(lineSegment1.End1, lineSegment2),
         End2 = Project.PointOnLineSegment(lineSegment1.End2, lineSegment2),
     };
 }

 /// <summary>
 /// Projects the specified line segment on the specified line.
 /// </summary>
 /// <param name="lineSegment">A line segment.</param>
 /// <param name="line">A line.</param>
 /// <returns>The <paramref name="lineSegment"/> projected on the <paramref name="line"/>.</returns>
 public static LineSegment LineSegmentOnLine(LineSegment lineSegment, Line line)
 {
     return new LineSegment
     {
         End1 = Project.PointOnLine(lineSegment.End1, line),
         End2 = Project.PointOnLine(lineSegment.End2, line),
     };
 }

        public void Test_SetTexture()
        {
            var line = new LineSegment ();
            var tex = new Texture("abstract7.png");

            line.Texture = tex;
            Assert.AreEqual (tex, line.Texture);
        }

 public void LineSegmentProperties()
 {
     var line = new LineSegment(new Point(0, 1), new Point(1, 1));
     line.AssertEquals(new LineSegment(new Point(0, 1), new Point(1, 1)));
     line.Start.AssertEquals(new Point(0, 1));
     line.End.AssertEquals(new Point(1, 1));
     line.Delta.AssertEquals(new Vector(1, 0));
 }

        public void Test_New()
        {
            var line = new LineSegment ();

            Assert.AreEqual (1.0f, line.Width);
            Assert.AreEqual (10, line.Length);
            Assert.AreEqual (Color.White, line.Color);
            Assert.AreEqual (null, line.Texture);
        }

		private void TestItsc(LineSegment<float> p, LineSegment<float> q, Point<float>? expected, float expect_pFrac, LineType pt = LineType.Segment, LineType qt = LineType.Segment)
		{
			float pFrac, qFrac;
			bool intersected = p.ComputeIntersection(pt, out pFrac, q, qt, out qFrac);
			Assert.AreEqual(expected.HasValue, intersected);
			Point<float>? result = p.ComputeIntersection(pt, q, qt);
			Assert.AreEqual(expected, result);
			Assert.AreEqual(expect_pFrac, pFrac);
		}

 public static Vector2 ClosestPointOnLine(LineSegment<Vector2> line, Vector2 point)
 {
     var ap = point - line.A;
     var ab = line.B - line.A;
     var ab2 = Vector2.Dot(ab, ab);
     var apab = Vector2.Dot(ap, ab);
     var t = apab / ab2;
     return line.A + ab * t;
 }

        public void DistanceToPointTest( float x, float y, float x1, float y1, float x2, float y2, float expectedDistance )
        {
            Point pt = new Point( x, y );
            Point pt1 = new Point( x1, y1 );
            Point pt2 = new Point( x2, y2 );
            LineSegment segment = new LineSegment( pt1, pt2 );

            Assert.AreEqual( expectedDistance, segment.DistanceToPoint( pt ) );
        }