Neural Network Racing - Part 2

    [Serializable]
    public class PathPoint
    {
        public Vector2 Point; //position in 2D space
 
        public float Width; //width of road (m)
 
        [XmlIgnore]
        public PathPoint Prev;//previous Point
        [XmlIgnore]
        public PathPoint Next;//next Point
        [XmlIgnore]
        public float DistanceFromStart;//distance from start to this point along track (m)
        [XmlIgnore]
        public Segment LeftWall; //segment of left wall
        [XmlIgnore]
        public Segment RightWall;//segment of right wall
        [XmlIgnore]
        public Vector2 Normal;//normal to direction of road
        [XmlIgnore]
        public Vector2 Dir; //direction of road
        [XmlIgnore]
        public float Length; //length of this part of track (m)
    }

        public static void GetDistances(Car car, Track track, float[] sensors, int startIndex)
        {
            //get segments of walls
            {
                segments.Clear();
                var p = car.CapturedPoint;
                segments.Add(p.LeftWall);
                segments.Add(p.RightWall);
                while (track.DistanceBetweenPoints(car.CapturedPoint, p) <= 130)
                {
                    p = p.Next;
                    segments.Add(p.LeftWall);
                    segments.Add(p.RightWall);
                }
            }
            //enumarate sensors of car
            var angle = car.LookAt.Angle();
            for (int i = 0; i < Rays.Length; i++)
            {
                var p = Rays[i];
                p = p.Rotate(angle);//rotate sensor by car orientation
                var ray = new Segment(car.Pos, car.Pos + p);
                sensors[startIndex + i] = GetDistance(ray, segments);//calc distance to nearest wall segment
            }
        }
 
        public static float GetDistance(Segment seg, List<Segment> segments)
        {
            var minDist = seg.From.DistanceTo(seg.To);
 
            for (int i = 0; i < segments.Count; i++)
            {
                var s = segments[i];
                var p = SegmentIntersection.FindIntersection(seg.From, seg.To, s.From, s.To);
                if (p != null)
                {
                    var dist = p.Value.DistanceTo(seg.From);
                    if (dist < minDist)
                        minDist = dist;
                    return minDist;
                }
            }
 
            return minDist;
        }
 
        // Find the point of intersection between
        // the lines p1 --> p2 and p3 --> p4.
        public static PointF? FindIntersection(PointF p1, PointF p2, PointF p3, PointF p4)
        {
            // Get the segments' parameters.
            float dx12 = p2.X - p1.X;
            float dy12 = p2.Y - p1.Y;
            float dx34 = p4.X - p3.X;
            float dy34 = p4.Y - p3.Y;
 
            // Solve for t1 and t2
            float denominator = (dy12 * dx34 - dx12 * dy34);
 
            float t1 = ((p1.X - p3.X) * dy34 + (p3.Y - p1.Y) * dx34) / denominator;
            if (float.IsInfinity(t1))
            {
                // The lines are parallel (or close enough to it).
                return null;
            }
 
            float t2 = ((p3.X - p1.X) * dy12 + (p1.Y - p3.Y) * dx12) / -denominator;
 
            // The segments intersect if t1 and t2 are between 0 and 1.
            var segments_intersect =
                ((t1 >= 0) && (t1 <= 1) &&
                 (t2 >= 0) && (t2 <= 1));
 
            // Find the point of intersection.
            if(segments_intersect)
                return new PointF(p1.X + dx12 * t1, p1.Y + dy12 * t1);
 
            return null;
        }