Example #1
0
        private byte[] generateMapMessage(string roadwayid, int startIndex, int linkCount)
        {
            if (srInfloDbContext == null)
            {
                return(new byte[0]);
            }

            Configuration_Roadway roadway = srInfloDbContext.Configuration_Roadway.Where(r => r.RoadwayId.Equals(roadwayid)).FirstOrDefault();

            if (roadway == null)
            {
                return(new byte[0]);
            }

            IEnumerable <Configuration_RoadwayMileMarkers> dbMileMarkers = srInfloDbContext.Configuration_RoadwayMileMarkers
                                                                           .Where(r => r.RoadwayId.Equals(roadway.RoadwayId));

            var dbLinks = srInfloDbContext.Configuration_RoadwayLinks
                          .Where(l => l.RoadwayId.Equals(roadway.RoadwayId)).ToList()
                          .Where(l => Between(l.BeginMM, roadway.BeginMM, roadway.EndMM, true) && Between(l.EndMM, roadway.BeginMM, roadway.EndMM, true))
                          .ToArray();
            //.Where(l => roadway.BeginMM <= l.BeginMM && l.EndMM <= roadway.EndMM).OrderBy(l => l.BeginMM);

            List <ExtractedMapIntersection> asnIntersections = new List <ExtractedMapIntersection>();

            for (int linkIndex = startIndex; (linkIndex < dbLinks.Length) && (linkIndex < startIndex + linkCount); linkIndex++)
            {
                var link = dbLinks[linkIndex];

                List <Extracted3DOffset> increasingNodes = new List <Extracted3DOffset>();
                List <Extracted3DOffset> decreasingNodes = new List <Extracted3DOffset>();

                var dbLinkMileMarkers = dbMileMarkers.ToList()
                                        .Where(m => Between(m.MMNumber, link.BeginMM, link.EndMM, true))
                                        //.Where(m => link.BeginMM <= m.MMNumber && m.MMNumber <= link.EndMM)
                                        .OrderBy(m => m.MMNumber).ToArray();

                for (int i = 0; i < dbLinkMileMarkers.Length; i++)
                {
                    var mileMarker = dbLinkMileMarkers[i];
                    increasingNodes.Insert(i, new Extracted3DOffset(mileMarker.Latitude1, mileMarker.Longitude1, mileMarker.MMNumber));
                    decreasingNodes.Insert(0, new Extracted3DOffset(mileMarker.Latitude2, mileMarker.Longitude2, mileMarker.MMNumber));
                }
                ExtractedNodeList increasingApproach = new ExtractedNodeList(increasingNodes.ToArray());
                increasingApproach.setName(link.LinkId + "_inc");
                ExtractedNodeList decreasingApproach = new ExtractedNodeList(decreasingNodes.ToArray());
                decreasingApproach.setName(link.LinkId + "_dec");

                asnIntersections.Add(new ExtractedMapIntersection(link.LinkId, new ExtractedNodeList[] { increasingApproach, decreasingApproach }));
            }

            ExtractedMap results = new ExtractedMap(roadway.RoadwayId + "\n" + roadway.Name);

            results.setIntersections(asnIntersections.ToArray());

            return(results.generateASN());
        }
Example #2
0
        ExtractedTimFrame BuildAlertFrame(string roadwayid, string text, DateTime startTime, int duration, double startMM, double endMM)
        {
            bool reversed = startMM > endMM;

            if (reversed)
            {
                double swap = startMM;
                startMM = endMM;
                endMM   = swap;
            }

            ExtractedTimFrame results = new ExtractedTimFrame(text, startTime, duration);

            var dbAlertMileMarkers = srInfloDbContext.Configuration_RoadwayMileMarkers
                                     .Where(r => r.RoadwayId.Equals(roadwayid));

            //Snap to closest milemarkers by widening the alert.
            try
            {
                startMM = dbAlertMileMarkers.Where(m => m.MMNumber <= startMM).OrderByDescending(m => m.MMNumber).First().MMNumber;
            }
            catch { }
            try
            {
                endMM = dbAlertMileMarkers.Where(m => m.MMNumber >= endMM).OrderBy(m => m.MMNumber).First().MMNumber;
            }
            catch { }

            dbAlertMileMarkers = dbAlertMileMarkers.Where(m => startMM <= m.MMNumber && m.MMNumber <= endMM);

            if (reversed)
            {
                dbAlertMileMarkers = dbAlertMileMarkers.OrderByDescending(m => m.MMNumber);
            }
            else
            {
                dbAlertMileMarkers = dbAlertMileMarkers.OrderBy(m => m.MMNumber);
            }

            var dbAlertMileMarkersList = dbAlertMileMarkers.ToList();

            List <ExtractedNodeList> alertPaths = new List <ExtractedNodeList>();

            while (dbAlertMileMarkersList.Count() > 1)
            {
                var mmarkers = dbAlertMileMarkersList.GetRange(0, Math.Min(MileMarkersPerValidRegion, dbAlertMileMarkersList.Count()));
                List <Extracted3DOffset> nodes = new List <Extracted3DOffset>();

                if (reversed)
                {
                    mmarkers.OrderByDescending(m => m.MMNumber).ToList().ForEach(m => nodes.Add(new Extracted3DOffset(m.Latitude2, m.Longitude2, m.MMNumber)));
                }
                else
                {
                    mmarkers.OrderBy(m => m.MMNumber).ToList().ForEach(m => nodes.Add(new Extracted3DOffset(m.Latitude1, m.Longitude1, m.MMNumber)));
                }

                if (nodes.Count > 1)
                {
                    ExtractedNodeList alertPath = new ExtractedNodeList(nodes.ToArray());
                    alertPaths.Add(alertPath);
                }

                dbAlertMileMarkersList.RemoveRange(0, mmarkers.Count() - 1);
            }

            results.setAlertPaths(alertPaths.ToArray());

            return(results);
        }