Ejemplo n.º 1
0
        /// <summary>
        /// Calculates observation probability
        /// </summary>
        /// <param name="original">GPS track point</param>
        /// <param name="candidate">Candidate point</param>
        /// <returns>double representing probability that GPS track point corresponds with Candidate point</returns>
        double CalculateObservationProbability(GPXPoint original, IPointGeo candidate)
        {
            double sigma    = 30;
            double distance = Calculations.GetDistance2D(original, candidate);

            return(Math.Exp(-distance * distance / (2 * sigma * sigma)) / (sigma * Math.Sqrt(Math.PI * 2)));
        }
Ejemplo n.º 2
0
        public GPXTrackSegment Filter(TimeSpan minInterval, GPXTrackSegment track)
        {
            GPXTrackSegment result = new GPXTrackSegment();

            if (track.Nodes.Count == 0)
            {
                return(result);
            }

            GPXPoint last = track.Nodes[0];

            result.Nodes.Add(last);

            int index = 1;

            while (index < track.Nodes.Count)
            {
                if (track.Nodes[index].Time - last.Time >= minInterval)
                {
                    last = track.Nodes[index];
                    result.Nodes.Add(last);
                }
                index++;
            }

            if (last.Time != track.Nodes.Last().Time)
            {
                result.Nodes.Add(track.Nodes.Last());
            }

            return(result);
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Finds all candidates points for given GPS track point
        /// </summary>
        /// <param name="gpxPt">GPS point</param>
        /// <returns>Collection of points candidate points on road segments</returns>
        public IEnumerable <CandidatePoint> FindCandidatePoints(GPXPoint gpxPt)
        {
            List <CandidatePoint> result = new List <CandidatePoint>();
            BBox gpxBbox = new BBox(new IPointGeo[] { gpxPt });

            gpxBbox.Inflate(0.0007, 0.0011);

            foreach (var road in _trackCutout)
            {
                if (Topology.Intersects(gpxBbox, road.BBox))
                {
                    Segment <IPointGeo> roadSegment;
                    IPointGeo           projectedPoint = Topology.ProjectPoint(gpxPt, road, out roadSegment);
                    result.Add(new CandidatePoint()
                    {
                        MapPoint               = projectedPoint,
                        Road                   = road,
                        RoadSegment            = roadSegment,
                        ObservationProbability = CalculateObservationProbability(gpxPt, projectedPoint)
                    });
                }
            }

            if (result.Count == 0)
            {
                throw new Exception(string.Format("Can not find any candidate point for {0}", gpxPt));
            }

            return(result);
        }
Ejemplo n.º 4
0
        public double getTimeInRH(TrafficLight t)
        {
            double timeAvgSegments = 0;

            foreach (var segment in _segments)
            {
                GPXPoint firstPoint = segment.Nodes.First();
                GPXPoint lastPoint  = segment.Nodes.Last();
                if (segment.Nodes.Contains(t))
                {
                    if (firstPoint == t)
                    {
                        break;
                    }
                }
                var    distance       = Calculations.GetDistance2D(firstPoint, lastPoint);
                double timeAvgSegment = distance / segment.AvgSpeed;
                timeAvgSegments += timeAvgSegment;
                if (segment.Nodes.Contains(t))
                {
                    break;
                }
            }

            return(timeAvgSegments);
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Raises the WaypointRead event
        /// </summary>
        /// <param name="node">The waypoint read from the xml</param>
        protected void OnWaypointRead(GPXPoint waypoint)
        {
            GPXWaypointReadHandler temp = WaypointRead;

            if (temp != null)
            {
                temp(waypoint);
            }
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Creates a new layer in the CandidatesGraph
        /// </summary>
        /// <param name="originalPoint">GPX track point</param>
        /// <param name="candidates">Candidate points for the original point</param>
        public void CreateLayer(GPXPoint originalPoint, IEnumerable <CandidatePoint> candidates)
        {
            CandidateGraphLayer result = new CandidateGraphLayer()
            {
                TrackPoint = originalPoint
            };

            result.Candidates.AddRange(candidates);

            foreach (var candidate in candidates)
            {
                candidate.Layer = result;
            }
            _layers.Add(result);
        }
Ejemplo n.º 7
0
        static void Main(string[] args)
        {
            string gpxPath  = "";
            bool   showHelp = false;


            OptionSet parameters = new OptionSet()
            {
                { "gpx=", "path to the map file", v => gpxPath = v },
                { "h|?|help", v => showHelp = v != null },
            };

            try
            {
                parameters.Parse(args);
            }
            catch (OptionException e)
            {
                Console.Write("TRoute: ");
                Console.WriteLine(e.Message);
                Console.WriteLine("Try `TRoute --help' for more information.");
                return;
            }

            if (showHelp || string.IsNullOrEmpty(gpxPath))
            {
                ShowHelp(parameters);
                return;
            }

            HRDocument hr = new HRDocument();

            hr.Load(gpxPath);
            hr.Webster();

            GPXPoint bucketInfo = null;

            foreach (var track in hr.Tracks)
            {
                foreach (var seg in track.Segments)
                {
                    bucketInfo = seg.Nodes.ToList().Find(x => x.Id == 0);
                }
            }

            Solve(hr.getListProcessor(), hr.getJobTime(), hr.getJobId(), bucketInfo, hr.cycleTime);
        }
Ejemplo n.º 8
0
        /// <summary>
        /// Writes point data to the specific tag to the output
        /// </summary>
        /// <param name="point">The point that's data should be written</param>
        /// <param name="tag">The name of the output tag</param>
        /// <example>
        ///   //writes waypoint
        ///		WritePointData(waypoint, "wpt");
        /// </example>
        protected void WritePointData(GPXPoint point, string tag)
        {
            _xmlWriter.WriteStartElement(tag);
            // writing id
            _xmlWriter.WriteAttributeString("id", point.Id.ToString(System.Globalization.CultureInfo.InvariantCulture));

            _xmlWriter.WriteAttributeString("lat", point.Latitude.ToString(System.Globalization.CultureInfo.InvariantCulture));
            _xmlWriter.WriteAttributeString("lon", point.Longitude.ToString(System.Globalization.CultureInfo.InvariantCulture));

            if (point.Elevation != 0)
            {
                _xmlWriter.WriteElementString("ele", point.Elevation.ToString(System.Globalization.CultureInfo.InvariantCulture));
            }

            if (point.Time != DateTime.MinValue)
            {
                _xmlWriter.WriteElementString("time", point.Time.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'Z'"));
            }

            if (string.IsNullOrEmpty(point.Name) == false)
            {
                _xmlWriter.WriteElementString("name", point.Name);
            }

            if (string.IsNullOrEmpty(point.Description) == false)
            {
                _xmlWriter.WriteElementString("desc", point.Description);
            }

            if (string.IsNullOrEmpty(point.Commenet) == false)
            {
                _xmlWriter.WriteElementString("cmt", point.Commenet);
            }

            if (point.TrafficSignal != false)
            {
                _xmlWriter.WriteAttributeString("traffic_signal", point.TrafficSignal.ToString());
            }

            if (point.StartBucket >= TimeSpan.Zero && point.EndBucket != TimeSpan.Zero)
            {
                _xmlWriter.WriteAttributeString("startBucket", point.StartBucket.ToString());
                _xmlWriter.WriteAttributeString("endBucket", point.EndBucket.ToString());
            }
            _xmlWriter.WriteEndElement();
        }
Ejemplo n.º 9
0
        static void GenerateGpxFiles(List <Bucket> buckets, string file, int positionFile)
        {
            foreach (var b in buckets)
            {
                if (b.Paths.Any())
                {
                    // Saving the Map to GPX instead of OSM - START
                    var tracks = new List <GPXTrack>();

                    foreach (var p in b.Paths)
                    {
                        GPXTrack track = new GPXTrack(p.Key);
                        foreach (var t in p.Value)
                        {
                            List <GPXPoint> list = new List <GPXPoint>();

                            foreach (var s in t.Segments)
                            {
                                GPXPoint start = new GPXPoint()
                                {
                                    Latitude = s.StartPoint.Latitude, Longitude = s.StartPoint.Longitude
                                };
                                GPXPoint end = new GPXPoint()
                                {
                                    Latitude = s.EndPoint.Latitude, Longitude = s.EndPoint.Longitude
                                };

                                list.Add(start);
                                list.Add(end);
                            }

                            GPXTrackSegment gpxTrack = new GPXTrackSegment(list);
                            track.Segments.Add(gpxTrack);
                        }
                        tracks.Add(track);
                    }

                    var gpx = new GPXDocument()
                    {
                        Tracks = tracks
                    };
                    gpx.Save("mapGpx" + positionFile + ".gpx");
                    // END
                }
            }
        }
Ejemplo n.º 10
0
        public double getTotalTimeRoute()
        {
            double timeAvgSegments = 0;

            foreach (var s in _segments)
            {
                GPXPoint firstPoint = s.Nodes.First();
                GPXPoint lastPoint  = s.Nodes.Last();

                var distance = Calculations.GetDistance2D(firstPoint, lastPoint);
                if (s.AvgSpeed != 0)
                {
                    double timeAvgSegment = distance / s.AvgSpeed;
                    timeAvgSegments += timeAvgSegment;
                }
            }

            return(timeAvgSegments);
        }
Ejemplo n.º 11
0
        static void Main(string[] args)
        {
            string osmPath    = "";
            int    eps        = -1;
            int    minTraffic = -1;
            bool   showHelp   = false;

            OptionSet parameters = new OptionSet()
            {
                { "osm=", "path to the map file", v => osmPath = v },
                { "eps=", "size of the eps-neighborhood to be considered (integer)", v => eps = Convert.ToInt32(v) },
                { "minTraffic=", "minimum traffic considered (integer)", v => minTraffic = Convert.ToInt32(v) },
                { "h|?|help", v => showHelp = v != null },
            };

            try
            {
                parameters.Parse(args);
            }
            catch (OptionException e)
            {
                Console.Write("TRoute: ");
                Console.WriteLine(e.Message);
                Console.WriteLine("Try `TRoute --help' for more information.");
                return;
            }

            if (showHelp || string.IsNullOrEmpty(osmPath) || eps < 0 || minTraffic < 0)
            {
                ShowHelp(parameters);
                return;
            }

            var osmFile = new OSMDB();

            osmFile.Load(osmPath);
            var roadGraph = new RoadGraph();

            roadGraph.Build(osmFile);

            // Getting all the nodes with traffic signals
            Dictionary <double, OSMNode> tagsNodes = new Dictionary <double, OSMNode>();

            foreach (var node in osmFile.Nodes)
            {
                foreach (var tag in node.Tags)
                {
                    if (tag.Value.Equals("traffic_signals"))
                    {
                        if (!tagsNodes.Keys.Contains(node.Latitude + node.Longitude))
                        {
                            tagsNodes.Add(node.Latitude + node.Longitude, node);
                        }
                    }
                }
            }

            var hotRoutes = new FlowScan().Run(roadGraph, eps, minTraffic);

            // Saving GPX file of the Hot Route
            HashSet <GPXPoint>        listPoints;
            HashSet <GPXTrackSegment> listSegments;
            GPXTrackSegment           segTrack;

            List <GPXTrack> track = new List <GPXTrack>();
            GPXTrack        tr;

            //Console.WriteLine(hotRoutes.Count);
            foreach (var hr in hotRoutes)
            {
                //Console.WriteLine("Number segs: " + hr.Segments.Count);
                listSegments = new HashSet <GPXTrackSegment>();

                foreach (var seg in hr.Segments)
                {
                    listPoints = new HashSet <GPXPoint>();

                    foreach (var segInner in seg.Geometry.Segments)
                    {
                        GPXPoint start;
                        if (tagsNodes.Keys.Contains(segInner.StartPoint.Latitude + segInner.StartPoint.Longitude))
                        {
                            OSMNode osmNode = tagsNodes[segInner.StartPoint.Latitude + segInner.StartPoint.Longitude];
                            start = new GPXPoint()
                            {
                                Id        = osmNode.ID, Latitude = segInner.StartPoint.Latitude,
                                Longitude = segInner.StartPoint.Longitude, TrafficSignal = true
                            };
                        }
                        else
                        {
                            OSMNode osmNode = osmFile.Nodes.ToList().First(x => x.Latitude == segInner.StartPoint.Latitude &&
                                                                           x.Longitude == segInner.StartPoint.Longitude);
                            start = new GPXPoint()
                            {
                                Id        = osmNode.ID, Latitude = segInner.StartPoint.Latitude,
                                Longitude = segInner.StartPoint.Longitude, TrafficSignal = false
                            };
                        }

                        GPXPoint end;
                        if (tagsNodes.Keys.Contains(segInner.EndPoint.Latitude + segInner.EndPoint.Longitude))
                        {
                            OSMNode osmNode = tagsNodes[segInner.EndPoint.Latitude + segInner.EndPoint.Longitude];
                            end = new GPXPoint()
                            {
                                Id        = osmNode.ID, Latitude = segInner.EndPoint.Latitude,
                                Longitude = segInner.EndPoint.Longitude, TrafficSignal = true
                            };
                        }
                        else
                        {
                            OSMNode osmNode = osmFile.Nodes.ToList().First(x => x.Latitude == segInner.EndPoint.Latitude &&
                                                                           x.Longitude == segInner.EndPoint.Longitude);
                            end = new GPXPoint()
                            {
                                Id        = osmNode.ID, Latitude = segInner.EndPoint.Latitude,
                                Longitude = segInner.EndPoint.Longitude, TrafficSignal = false
                            };
                        }

                        listPoints.Add(start);
                        listPoints.Add(end);
                    }

                    segTrack = new GPXTrackSegment(listPoints, seg.AvgSpeed, seg.Speed, seg.Id);
                    // passing the traffic
                    segTrack.Traffic = seg.Traffic;
                    listSegments.Add(segTrack);
                }

                tr = new GPXTrack();
                tr.Segments.AddRange(listSegments);
                track.Add(tr);
            }

            // Bucket Information
            GPXTrack        tBucket = new GPXTrack();
            GPXPoint        pBucket = new GPXPoint(0, 0, 0, false);
            GPXTrackSegment sBucket = new GPXTrackSegment();

            var bucketInfo = osmFile.Nodes.ToList().Find(x => x.ID == 0);

            if (bucketInfo != null)
            {
                pBucket.StartBucket = TimeSpan.Parse(bucketInfo.Tags.First().Value);
                pBucket.EndBucket   = TimeSpan.Parse(bucketInfo.Tags.Last().Value);
            }

            sBucket.Nodes.Add(pBucket);
            tBucket.Segments.Add(sBucket);

            var gpx = new GPXDocument()
            {
                Tracks = track
            };

            gpx.Tracks.Add(tBucket);
            gpx.Save("mapWithHotRoutes.gpx");
        }
Ejemplo n.º 12
0
    // Constructor
    public JobShop(List <List <int> > machines, List <List <int> > processingTime, List <List <int> > jobIds, GPXPoint bucketInfo, int cycleTime)
    {
        this.machinesCount = machines.Count;
        this.jobsCount     = processingTime.Count;
        this.bucketInfo    = bucketInfo;
        this.cycleTime     = cycleTime;
        this.jobIds        = jobIds;

        Console.WriteLine("machinesCount: " + this.machinesCount);
        Console.WriteLine("jobsCount: " + jobsCount);

        this.allMachines = new List <int>();
        for (var i = 0; i < this.machinesCount; i++)
        {
            this.allMachines.Add(i);
        }

        this.allJobs = new List <int>();
        for (var i = 0; i < this.jobsCount; i++)
        {
            this.allJobs.Add(i);
        }

        // Define data.
        this.machines        = machines;
        this.processingTimes = processingTime;


        // Computes horizon
        for (var i = 0; i < allMachines.Count; i++)
        {
            this.horizon += processingTimes.ElementAt(i).Sum();
        }
        Console.WriteLine("Horizon: " + this.horizon);
    }
Ejemplo n.º 13
0
        /// <summary>
        /// Writes point data to the specific tag to the output
        /// </summary>
        /// <param name="point">The point that's data should be written</param>
        /// <param name="tag">The name of the output tag</param>
        /// <example>
        ///   //writes waypoint
        ///		WritePointData(waypoint, "wpt");
        /// </example>
        protected void WritePointData(GPXPoint point, string tag)
        {
            _xmlWriter.WriteStartElement(tag);

            _xmlWriter.WriteAttributeString("lat", point.Latitude.ToString(System.Globalization.CultureInfo.InvariantCulture));
            _xmlWriter.WriteAttributeString("lon", point.Longitude.ToString(System.Globalization.CultureInfo.InvariantCulture));

            if (point.Elevation != 0) {
                _xmlWriter.WriteElementString("ele", point.Elevation.ToString(System.Globalization.CultureInfo.InvariantCulture));
            }

            if (point.Time != DateTime.MinValue) {
                _xmlWriter.WriteElementString("time", point.Time.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'Z'"));
            }

            if (string.IsNullOrEmpty(point.Name) == false) {
                _xmlWriter.WriteElementString("name", point.Name);
            }

            if (string.IsNullOrEmpty(point.Description) == false) {
                _xmlWriter.WriteElementString("desc", point.Description);
            }

            if (string.IsNullOrEmpty(point.Commenet) == false) {
                _xmlWriter.WriteElementString("cmt", point.Commenet);
            }

            _xmlWriter.WriteEndElement();
        }
Ejemplo n.º 14
0
 /// <summary>
 /// Writes the specific waypoint to the output
 /// </summary>
 /// <param name="waypoint">The waypoint to be written</param>
 public void WriteWaypoint(GPXPoint waypoint)
 {
     WritePointData(waypoint, "wpt");
 }
Ejemplo n.º 15
0
        /// <summary>
        /// Reads a point from gpx document
        /// </summary>
        private GPXPoint ReadPoint()
        {
            // latitude attribute
            string lat = _xmlReader.GetAttribute("lat");

            if (string.IsNullOrEmpty(lat))
            {
                throw new XmlException("Attribute 'lat' is missing.");
            }
            double pointLat = double.Parse(lat, System.Globalization.CultureInfo.InvariantCulture);

            // longitude attribute
            string lon = _xmlReader.GetAttribute("lon");

            if (string.IsNullOrEmpty(lon))
            {
                throw new XmlException("Attribute 'lon' is missing.");
            }

            // longitude attribute
            string trafficSignal = _xmlReader.GetAttribute("traffic_signal");
            double pointLon      = double.Parse(lon, System.Globalization.CultureInfo.InvariantCulture);

            GPXPoint parsedPoint = new GPXPoint(pointLat, pointLon);

            // Id
            if (_xmlReader.GetAttribute("id") != null)
            {
                parsedPoint.Id = long.Parse(_xmlReader.GetAttribute("id"));
            }

            if (trafficSignal != null)
            {
                parsedPoint.TrafficSignal = bool.Parse(trafficSignal);
            }

            // Reading bucket info
            if (_xmlReader.GetAttribute("startBucket") != null &&
                _xmlReader.GetAttribute("endBucket") != null)
            {
                parsedPoint.StartBucket = TimeSpan.Parse(_xmlReader.GetAttribute("startBucket"));
                parsedPoint.EndBucket   = TimeSpan.Parse(_xmlReader.GetAttribute("endBucket"));
            }

            if (_xmlReader.IsEmptyElement == false)
            {
                _xmlReader.Read();

                while (_xmlReader.NodeType != XmlNodeType.EndElement)
                {
                    if (_xmlReader.NodeType == XmlNodeType.Element)
                    {
                        switch (_xmlReader.Name)
                        {
                        case "ele":
                            string ele = _xmlReader.ReadString();
                            parsedPoint.Elevation = double.Parse(ele, System.Globalization.CultureInfo.InvariantCulture);
                            _xmlReader.Skip();
                            break;

                        case "time":
                            string time = _xmlReader.ReadString();
                            parsedPoint.Time = DateTime.Parse(time, System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.AdjustToUniversal | System.Globalization.DateTimeStyles.AssumeUniversal);
                            //parsedPoint.Time = TimeSpan.ParseExact(time, "yyyy'-'MM'-'dd'T'HH':'mm':'ss'Z'", System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.AdjustToUniversal | System.Globalization.DateTimeStyles.AssumeUniversal);
                            _xmlReader.Skip();
                            break;

                        case "name":
                            parsedPoint.Name = _xmlReader.ReadString();
                            _xmlReader.Skip();
                            break;

                        case "desc":
                            parsedPoint.Description = _xmlReader.ReadString();
                            _xmlReader.Skip();
                            break;

                        case "cmt":
                            parsedPoint.Commenet = _xmlReader.ReadString();
                            _xmlReader.Skip();
                            break;

                        default:
                            _xmlReader.Skip();
                            break;
                        }
                    }
                    else
                    {
                        _xmlReader.Skip();
                    }
                }
            }

            _xmlReader.Skip();
            return(parsedPoint);
        }
Ejemplo n.º 16
0
        static void ProcessCSVFile(string path, string outputPath, int samplingPeriod)
        {
            double max_lat = -3.691978693, min_lat = -3.8881242275, max_lon = -38.4018707275, min_lon = -38.6374359131; //geo-bounding box for Fortaleza

            GPXDocument gpx = new GPXDocument();

            Console.Write("Parsing {0} ...", Path.GetFileName(path));

            string line;

            char[] seps = { ';', ',', '\t' };
            char   sep  = '.';

            String[] fields = { };

            long last_id = -1;

            int      id_field   = 0;
            int      lat_field  = 1;
            int      lon_field  = 2;
            int      time_field = 7;
            int      uf1_field  = 3;
            int      uf2_field  = 4;
            int      uf3_field  = 5;
            int      uf4_field  = 6;
            Boolean  header     = true;
            GPXTrack trk        = null;

            List <long> ids = new List <long>();

            if (samplingPeriod > 0)
            {
                DateTime dt = File.GetLastWriteTime(path);
                if ((DateTime.Now - dt).Days > samplingPeriod)
                {
                    Console.WriteLine("skiping");
                    return;
                }
            }

            // Read the file and display it line by line.
            System.IO.StreamReader csv = new System.IO.StreamReader(path);

            line = csv.ReadLine();
            if (line != null)
            {
                for (int i = 0; i < seps.Length; i++)
                {
                    if ((fields = line.Split(seps[i])).Length > 1)
                    {
                        sep = seps[i];
                        break;
                    }
                }
                if (sep == '.')
                {
                    throw new Exception(string.Format("Can not find any known separators.{';',',','TAB'}"));
                }

                for (int i = 0; i < fields.Length; i++)
                {
                    if (fields[i] == "id")
                    {
                        id_field = i;
                    }
                    else
                    if (fields[i] == "lat")
                    {
                        lat_field = i;
                    }
                    else
                    if (fields[i] == "lon")
                    {
                        lon_field = i;
                    }
                    else
                    if (fields[i] == "time")
                    {
                        time_field = i;
                    }
                    else
                    if (fields[i] == "uf1")
                    {
                        uf1_field = i;
                    }
                    else
                    if (fields[i] == "uf2")
                    {
                        uf2_field = i;
                    }
                    else
                    if (fields[i] == "uf3")
                    {
                        uf3_field = i;
                    }
                    else
                    if (fields[i] == "uf4")
                    {
                        uf4_field = i;
                    }
                    else
                    {
                        header = false;
                        Console.WriteLine(string.Format("Can not find header line.(id, lat, lon, time)"));
                        csv.Close();
                        csv = new System.IO.StreamReader(path);
                        break;
                    }
                }
            }
            if (!header)
            {
                line = csv.ReadLine();
            }
            while ((line = csv.ReadLine()) != null)
            {
                fields = line.Split(sep);
                long id = Convert.ToInt64(fields[id_field]);
                if (id != last_id)
                {
                    if (ids.Find(item => item == id) == 0)
                    {
                        ids.Add(id);
                    }
                    last_id = id;
                    //break;
                }
            }
            csv.Close();


            foreach (long next_id in ids)
            {
                Console.Write(next_id);

                int count = 0;

                csv = new System.IO.StreamReader(path);
                trk = new GPXTrack();
                GPXTrackSegment trkseg = new GPXTrackSegment();
                gpx.Tracks.Add(trk);
                trk.Name = "trk_" + next_id;
                line     = csv.ReadLine();

                while ((line = csv.ReadLine()) != null)
                {
                    fields = line.Split(sep);
                    long id = Convert.ToInt64(fields[id_field]);
                    if (id == next_id)
                    {
                        if (!(fields[lat_field] == "null" && fields[lon_field] == "null"))
                        {
                            var lat = Double.Parse(fields[lat_field], System.Globalization.CultureInfo.InvariantCulture);
                            var lon = Double.Parse(fields[lon_field], System.Globalization.CultureInfo.InvariantCulture);

                            if (lat > min_lat && lat < max_lat && lon > min_lon && lon < max_lon)
                            {
                                GPXPoint p = new GPXPoint();

                                p.Latitude  = lat;
                                p.Longitude = lon;
                                p.Time      = DateTime.ParseExact(fields[time_field], "ddd MMM dd yyyy HH:mm:ss 'GMT-0300 (BRT)'", System.Globalization.CultureInfo.InvariantCulture);

                                trkseg.Nodes.Add(p);
                                count++;
                            }
                        }
                    }
                }
                trk.Segments.Add(trkseg);
                csv.Close();
                Console.WriteLine("[" + count + "]");
            }

            String fileout = Path.Combine(outputPath, Path.GetFileNameWithoutExtension(path) + ".gpx");

            Console.WriteLine(fileout);
            gpx.Save(fileout);
            Console.WriteLine("\tDone.");
        }
Ejemplo n.º 17
0
        static void Solve(List <List <int> > machines, List <List <int> > processingTimes, List <List <int> > jobIds, GPXPoint bucketInfo, int cycleTime)
        {
            Console.WriteLine("\n---- Job shop Scheduling Program ----");
            JobShop jobShop = new JobShop(machines, processingTimes, jobIds, bucketInfo, cycleTime);

            jobShop.RunJobShopScheduling("Jobshop");
        }
Ejemplo n.º 18
0
 /// <summary>
 /// Writes the specific waypoint to the output
 /// </summary>
 /// <param name="waypoint">The waypoint to be written</param>
 public void WriteWaypoint(GPXPoint waypoint)
 {
     WritePointData(waypoint, "wpt");
 }