/// <summary> /// Calculcates the metrics. /// </summary> /// <param name="vehicle"></param> /// <param name="p"></param> /// <returns></returns> public override Dictionary <string, double> Calculate(Vehicle vehicle, AggregatedPoint p) { Dictionary <string, double> result = new Dictionary <string, double>(); result.Add(DISTANCE_KEY, 0); result.Add(TIME_KEY, 0); Aggregated next = p; while (next != null) { if (next is AggregatedPoint) { AggregatedPoint point = (next as AggregatedPoint); this.CalculatePointMetrics(vehicle, result, point); } if (next is AggregatedArc) { AggregatedArc arc = (next as AggregatedArc); this.CalculateArcMetrics(vehicle, result, arc); } next = next.GetNext(); } return(result); }
public override void Succes() { // get the last arc and the last point. AggregatedArc latest_arc = (this.FinalMessages[this.FinalMessages.Count - 2] as MicroPlannerMessageArc).Arc; AggregatedPoint latest_point = (this.FinalMessages[this.FinalMessages.Count - 1] as MicroPlannerMessagePoint).Point; // count the number of streets in the same turning direction as the turn // that was found. int count = 0; if (MicroPlannerHelper.IsLeft(latest_point.Angle.Direction, this.Planner.Interpreter)) { count = MicroPlannerHelper.GetLeft(this.FinalMessages, this.Planner.Interpreter); } else if (MicroPlannerHelper.IsRight(latest_point.Angle.Direction, this.Planner.Interpreter)) { count = MicroPlannerHelper.GetRight(this.FinalMessages, this.Planner.Interpreter); } // construct the box indicating the location of the resulting find by this machine. GeoCoordinate point1 = latest_point.Location; GeoCoordinateBox box = new GeoCoordinateBox( new GeoCoordinate(point1.Latitude - 0.001f, point1.Longitude - 0.001f), new GeoCoordinate(point1.Latitude + 0.001f, point1.Longitude + 0.001f)); //string next_street = latest_point.Next.Name; // let the scentence planner generate the correct information. this.Planner.SentencePlanner.GenerateRoundabout(box, count - 1, latest_point.Next.Tags); }
/// <summary> /// Called when this machine is succesfull. /// </summary> public override void Succes() { // get first point. AggregatedPoint firstPoint = null; if (this.FinalMessages[0] is MicroPlannerMessagePoint) { // machine started on a point. firstPoint = (this.FinalMessages[0] as MicroPlannerMessagePoint).Point; } else { // get the previous point. firstPoint = (this.FinalMessages[0] as MicroPlannerMessageArc).Arc.Previous; } var poisPoint = (this.FinalMessages[this.FinalMessages.Count - 1] as MicroPlannerMessagePoint).Point; var pois = (this.FinalMessages[this.FinalMessages.Count - 1] as MicroPlannerMessagePoint).Point.Points; // construct the box indicating the location of the resulting find by this machine. var point1 = pois[0].Location; var box = new GeoCoordinateBox( new GeoCoordinate(point1.Latitude - 0.001f, point1.Longitude - 0.001f), new GeoCoordinate(point1.Latitude + 0.001f, point1.Longitude + 0.001f)); // let the scentence planner generate the correct information. var metaData = new Dictionary <string, object>(); metaData["direction"] = null; metaData["pois"] = pois; metaData["type"] = "poi"; this.Planner.SentencePlanner.GenerateInstruction(metaData, firstPoint.SegmentIdx, poisPoint.SegmentIdx, box, pois); }
/// <summary> /// Generates instructions. /// </summary> /// <param name="route"></param> /// <param name="interpreter"></param> /// <param name="languageGenerator"></param> /// <returns></returns> public static List <Instruction> Generate(Route route, IRoutingInterpreter interpreter, ILanguageGenerator languageGenerator) { if (route == null) { throw new ArgumentNullException("route"); } if (route.Vehicle == null) { throw new InvalidOperationException("Vehicle not set on route: Cannot generate instruction for a route without a vehicle!"); } if (interpreter == null) { throw new ArgumentNullException("interpreter"); } if (languageGenerator == null) { throw new ArgumentNullException("languageGenerator"); } OsmSharp.Routing.ArcAggregation.ArcAggregator aggregator = new OsmSharp.Routing.ArcAggregation.ArcAggregator(interpreter); AggregatedPoint point = aggregator.Aggregate(route); return(InstructionGenerator.Generate(point, interpreter, languageGenerator)); }
/// <summary> /// Aggregates a route by remove information useless to the generation of routing instructions. /// </summary> /// <param name="route"></param> /// <returns></returns> public AggregatedPoint Aggregate(Route route) { // create the enumerator. var enumerator = new AggregatedPointEnumerator(route); AggregatedRoutePoint previous = null; AggregatedRoutePoint current = null; AggregatedRoutePoint next = null; AggregatedPoint previousPoint = null; AggregatedArc previousArc = null; AggregatedPoint p = null; // loop over all aggregated points. while (enumerator.MoveNext()) { // get the next point. next = enumerator.Current; // process this.Process(route, previous, current, next, ref p, ref previousArc, ref previousPoint); // make the next, current and the current previous. previous = current; current = next; next = null; } // process once more, the current current has not been processed. this.Process(route, previous, current, next, ref p, ref previousArc, ref previousPoint); return(p); }
/// <summary> /// Calculates metrics for the given route. /// </summary> /// <param name="route"></param> /// <returns></returns> public Dictionary <string, double> Calculate(OsmSharpRoute route) { OsmSharp.Routing.ArcAggregation.ArcAggregator aggregator = new OsmSharp.Routing.ArcAggregation.ArcAggregator(_interpreter); AggregatedPoint p = aggregator.Aggregate(route); return(this.Calculate(route.Vehicle, p)); }
/// <summary> /// Generates instructions. /// </summary> /// <param name="route"></param> /// <param name="interpreter"></param> /// <param name="languageGenerator"></param> /// <returns></returns> public static List <Instruction> Generate(Route route, IRoutingInterpreter interpreter, ILanguageGenerator languageGenerator) { OsmSharp.Routing.ArcAggregation.ArcAggregator aggregator = new OsmSharp.Routing.ArcAggregation.ArcAggregator(interpreter); AggregatedPoint point = aggregator.Aggregate(route); return(InstructionGenerator.Generate(point, interpreter, languageGenerator)); }
/// <summary> /// Generates instructions. /// </summary> /// <param name="planner"></param> /// <param name="route"></param> /// <param name="point"></param> /// <returns></returns> public static List <Instruction> Generate(MicroPlanner planner, Route route, AggregatedPoint point) { if (point == null) { throw new ArgumentNullException("route"); } if (planner == null) { throw new ArgumentNullException("planner"); } return(planner.Plan(route, point)); }
/// <summary> /// Generates instructions. /// </summary> /// <param name="route"></param> /// <param name="point"></param> /// <param name="interpreter"></param> /// <param name="languageGenerator"></param> /// <returns></returns> public static List <Instruction> Generate(Route route, AggregatedPoint point, IRoutingInterpreter interpreter, ILanguageGenerator languageGenerator) { if (point == null) { throw new ArgumentNullException("route"); } if (interpreter == null) { throw new ArgumentNullException("interpreter"); } if (languageGenerator == null) { throw new ArgumentNullException("languageGenerator"); } return(InstructionGenerator.Generate(new MicroPlanner(languageGenerator, interpreter), route, point)); }
/// <summary> /// Called when this machine is succesfull. /// </summary> public override void Succes() { // get first point. AggregatedPoint firstPoint = null; if (this.FinalMessages[0] is MicroPlannerMessagePoint) { // machine started on a point. firstPoint = (this.FinalMessages[0] as MicroPlannerMessagePoint).Point; } else { // get the previous point. firstPoint = (this.FinalMessages[0] as MicroPlannerMessageArc).Arc.Previous; } // get the last arc and the last point. var latestArc = (this.FinalMessages[this.FinalMessages.Count - 2] as MicroPlannerMessageArc).Arc; var latestPoint = (this.FinalMessages[this.FinalMessages.Count - 1] as MicroPlannerMessagePoint).Point; // count the number of streets in the same turning direction as the turn // that was found. int count = 0; if (MicroPlannerHelper.IsLeft(latestPoint.Angle.Direction, this.Planner.Interpreter)) { count = MicroPlannerHelper.GetLeft(this.FinalMessages, this.Planner.Interpreter); } else if (MicroPlannerHelper.IsRight(latestPoint.Angle.Direction, this.Planner.Interpreter)) { count = MicroPlannerHelper.GetRight(this.FinalMessages, this.Planner.Interpreter); } // construct the box indicating the location of the resulting find by this machine. var point1 = latestPoint.Location; var box = new GeoCoordinateBox( new GeoCoordinate(point1.Latitude - 0.001f, point1.Longitude - 0.001f), new GeoCoordinate(point1.Latitude + 0.001f, point1.Longitude + 0.001f)); // let the scentence planner generate the correct information. var metaData = new Dictionary <string, object>(); metaData["count"] = count + 1; metaData["street"] = latestPoint.Next.Tags; metaData["pois"] = latestPoint.Points; metaData["type"] = "roundabout"; this.Planner.SentencePlanner.GenerateInstruction(metaData, firstPoint.SegmentIdx, latestPoint.SegmentIdx, box, latestPoint.Points); }
/// <summary> /// Plans all the messages in the aggregated /// </summary> /// <param name="p"></param> public List <Instruction> Plan(AggregatedPoint p) { // set the current aggregated object. _current = p; // loop until the current object is null. while (_current != null) { while (_current != null) { if (_current is AggregatedPoint) { if ((_current as AggregatedPoint).Location.Latitude == 51.254875183105469) { Console.WriteLine("BINGO!"); } } // plan the current message. this.PlanNewMessage(_current); // get the next object. _current = _current.GetNext(); } // show the latest success anyway. if (_latest_final >= 0) { // do the latest succes. this.Success(_latest_machine); // get the next object. if (_current != null) { _current = _current.GetNext(); } } else if (_messages_stack.Count > 0) { // no machine matches everything until the end of the route. throw new MicroPlannerException("No machine could be found matching the current stack of messages!", _messages_stack); } } // return the instructions list accumulated in the scentence planner. return(this.SentencePlanner.Instructions); }
public override void Succes() { // get the last arc and the last point. AggregatedArc latestArc = (this.FinalMessages[this.FinalMessages.Count - 2] as MicroPlannerMessageArc).Arc; AggregatedPoint latestPoint = (this.FinalMessages[this.FinalMessages.Count - 1] as MicroPlannerMessagePoint).Point; AggregatedArc secondLatestArc = (this.FinalMessages[this.FinalMessages.Count - 4] as MicroPlannerMessageArc).Arc; AggregatedPoint secondLatestPoint = (this.FinalMessages[this.FinalMessages.Count - 3] as MicroPlannerMessagePoint).Point; // count the number of streets in the same turning direction as the turn // that was found. int count = 0; if (MicroPlannerHelper.IsLeft(latestPoint.Angle.Direction, this.Planner.Interpreter)) { count = MicroPlannerHelper.GetLeft(this.FinalMessages, this.Planner.Interpreter); } else if (MicroPlannerHelper.IsRight(latestPoint.Angle.Direction, this.Planner.Interpreter)) { count = MicroPlannerHelper.GetRight(this.FinalMessages, this.Planner.Interpreter); } // construct the box indicating the location of the resulting find by this machine. GeoCoordinate point1 = latestPoint.Location; GeoCoordinateBox box = new GeoCoordinateBox( new GeoCoordinate(point1.Latitude - 0.001f, point1.Longitude - 0.001f), new GeoCoordinate(point1.Latitude + 0.001f, point1.Longitude + 0.001f)); // get all the names/direction/counts. TagsCollectionBase nextName = latestPoint.Next.Tags; TagsCollectionBase betweenName = latestArc.Tags; TagsCollectionBase beforeName = secondLatestArc.Tags; int firstCount = count; RelativeDirection firstTurn = secondLatestPoint.Angle; RelativeDirection secondTurn = latestPoint.Angle; // let the scentence planner generate the correct information. this.Planner.SentencePlanner.GenerateImmidiateTurn(latestPoint.EntryIdx, box, beforeName, firstTurn, firstCount, secondTurn, betweenName, nextName, latestPoint.Points); }
/// <summary> /// Called when this machine is succesfull. /// </summary> public override void Succes() { // get first point. AggregatedPoint firstPoint = null; if (this.FinalMessages[0] is MicroPlannerMessagePoint) { // machine started on a point. firstPoint = (this.FinalMessages[0] as MicroPlannerMessagePoint).Point; } else { // get the previous point. firstPoint = (this.FinalMessages[0] as MicroPlannerMessageArc).Arc.Previous; } var poisPoint = (this.FinalMessages[this.FinalMessages.Count - 1] as MicroPlannerMessagePoint).Point; var previousArc = (this.FinalMessages[this.FinalMessages.Count - 2] as MicroPlannerMessageArc).Arc; // get the pois list. var pois = (this.FinalMessages[this.FinalMessages.Count - 1] as MicroPlannerMessagePoint).Point.Points; // get the angle from the pois point. var direction = poisPoint.Angle; // calculate the box. var coordinates = new List <GeoCoordinate>(); foreach (ArcAggregation.Output.PointPoi poi in pois) { coordinates.Add(poi.Location); } coordinates.Add(poisPoint.Location); var box = new GeoCoordinateBox(coordinates.ToArray()); // let the scentence planner generate the correct information. var metaData = new Dictionary <string, object>(); metaData["direction"] = direction; metaData["pois"] = pois; metaData["type"] = "poi"; this.Planner.SentencePlanner.GenerateInstruction(metaData, firstPoint.SegmentIdx, poisPoint.SegmentIdx, box, pois); }
/// <summary> /// Returns the boundingbox for the current message consumed in this machine. /// </summary> /// <returns></returns> protected GeoCoordinateBox GetBoxForCurrentMessages() { if (this.FinalMessages.Count == 0) { return(null); } var route = this.FinalMessages[0].Route; // get first and last point. AggregatedPoint firstPoint = null; if (this.FinalMessages[0] is MicroPlannerMessagePoint) { // machine started on a point. firstPoint = (this.FinalMessages[0] as MicroPlannerMessagePoint).Point; } else { // get the previous point. firstPoint = (this.FinalMessages[0] as MicroPlannerMessageArc).Arc.Previous; } AggregatedPoint lastPoint = null; if (this.FinalMessages[this.FinalMessages.Count - 1] is MicroPlannerMessagePoint) { // machine ended on a point. lastPoint = (this.FinalMessages[this.FinalMessages.Count - 1] as MicroPlannerMessagePoint).Point; } else { // machine ended on an arc. lastPoint = (this.FinalMessages[this.FinalMessages.Count - 1] as MicroPlannerMessageArc).Arc.Next; } // build the boundingbox. var points = new List <GeoCoordinate>(); for (int segmentIdx = firstPoint.SegmentIdx; segmentIdx <= lastPoint.SegmentIdx; segmentIdx++) { var segment = route.Segments[segmentIdx]; points.Add(new GeoCoordinate(segment.Latitude, segment.Longitude)); } return(new GeoCoordinateBox(points.ToArray())); }
/// <summary> /// Plans all the messages in the aggregated /// </summary> /// <param name="route"></param> /// <param name="p"></param> public List <Instruction> Plan(Route route, AggregatedPoint p) { // set the current aggregated object. _current = p; // loop until the current object is null. while (_current != null) { while (_current != null) { // plan the current message. this.PlanNewMessage(route, _current); // get the next object. _current = _current.GetNext(); } // show the latest success anyway. if (_latestFinal >= 0) { // do the latest succes. this.Success(_latestMachine); // get the next object. if (_current != null) { _current = _current.GetNext(); } } else if (_messagesStack.Count > 0) { // no machine matches everything until the end of the route. throw new MicroPlannerException("No machine could be found matching the current stack of messages!", _messagesStack); } } // return the instructions list accumulated in the scentence planner. return(this.SentencePlanner.Instructions); }
/// <summary> /// Processes a part of the route. /// </summary> private void Process(Route route, AggregatedRoutePoint previous, AggregatedRoutePoint current, AggregatedRoutePoint next, ref AggregatedPoint p, ref AggregatedArc previousArc, ref AggregatedPoint previousPoint) { // process the current point. if (current != null) { if (previous == null) { // point is always significant, it is the starting point! // create point. p = new AggregatedPoint(); p.Angle = null; p.ArcsNotTaken = null; p.Location = new GeoCoordinate(current.Segment.Latitude, current.Segment.Longitude); p.Points = new List <PointPoi>(); p.SegmentIdx = current.SegmentIndex; if (current.Segment.Points != null) { foreach (var routePoint in current.Segment.Points) { var poi = new PointPoi(); poi.Name = routePoint.Name; poi.Tags = routePoint.Tags.ConvertTo(); poi.Location = new GeoCoordinate(routePoint.Latitude, routePoint.Longitude); poi.Angle = null; // there is no previous point; no angle is specified. p.Points.Add(poi); } } previousPoint = p; } else { // test if point is significant. var nextArc = this.CreateArcAndPoint(route, previous, current, next); // test if the next point is significant. if (previousArc == null) { // this arc is always significant; it is the first arc. previousPoint.Next = nextArc; previousArc = nextArc; } else { // there is a previous arc; a test can be done if the current point is significant. if (this.IsSignificant(previousArc, nextArc)) { // the arc is significant; append it to the previous arc. previousArc.Next.Next = nextArc; previousArc = nextArc; previousPoint = nextArc.Next; } else { // if the arc is not significant compared to the previous one, the previous one can extend until the next point. // THIS IS THE AGGREGATION STEP! // add distance. var distanceToNext = previousArc.Next.Location.DistanceReal(nextArc.Next.Location); previousArc.Distance = previousArc.Distance + distanceToNext; // set point. previousArc.Next = nextArc.Next; } } } } }
/// <summary> /// Generates instructions. /// </summary> /// <param name="point"></param> /// <param name="interpreter"></param> /// <param name="language_generator"></param> /// <returns></returns> public static List <Instruction> Generate(AggregatedPoint point, IRoutingInterpreter interpreter, ILanguageGenerator language_generator) { MicroPlanning.MicroPlanner planner = new MicroPlanning.MicroPlanner(language_generator, interpreter); return(planner.Plan(point)); }
/// <summary> /// Generates an arc and it's next point from the current aggregated point. /// </summary> /// <param name="route"></param> /// <param name="previous"></param> /// <param name="current"></param> /// <param name="next"></param> /// <returns></returns> internal AggregatedArc CreateArcAndPoint(Route route, AggregatedRoutePoint previous, AggregatedRoutePoint current, AggregatedRoutePoint next) { // create the arc. var a = new AggregatedArc(); a.Name = current.Segment.Name; a.Names = current.Segment.Names.ConvertTo(); a.Tags = current.Segment.Tags.ConvertToTagsCollection(); a.Vehicle = string.IsNullOrWhiteSpace(route.Vehicle) ? current.Segment.Vehicle : route.Vehicle; if (previous != null) { var previousCoordinate = new GeoCoordinate(previous.Segment.Latitude, previous.Segment.Longitude); var currentCoordinate = new GeoCoordinate(current.Segment.Latitude, current.Segment.Longitude); var distance = previousCoordinate.DistanceReal(currentCoordinate); a.Distance = distance; } // create the point. var p = new AggregatedPoint(); p.Location = new GeoCoordinate(current.Segment.Latitude, current.Segment.Longitude); p.Points = new List <PointPoi>(); p.SegmentIdx = current.SegmentIndex; if (previous != null && next != null && next.Segment != null) { var previousCoordinate = new GeoCoordinate(previous.Segment.Latitude, previous.Segment.Longitude); var nextCoordinate = new GeoCoordinate(next.Segment.Latitude, next.Segment.Longitude); p.Angle = RelativeDirectionCalculator.Calculate(previousCoordinate, p.Location, nextCoordinate); } if (current.Segment.SideStreets != null && current.Segment.SideStreets.Length > 0) { p.ArcsNotTaken = new List <KeyValuePair <RelativeDirection, AggregatedArc> >(); foreach (var sideStreet in current.Segment.SideStreets) { var side = new AggregatedArc(); side.Name = sideStreet.Name; side.Names = sideStreet.Names.ConvertTo(); side.Tags = sideStreet.Tags.ConvertToTagsCollection(); RelativeDirection sideDirection = null; if (previous != null) { var previousCoordinate = new GeoCoordinate(previous.Segment.Latitude, previous.Segment.Longitude); var nextCoordinate = new GeoCoordinate(sideStreet.Latitude, sideStreet.Longitude); sideDirection = RelativeDirectionCalculator.Calculate(previousCoordinate, p.Location, nextCoordinate); } p.ArcsNotTaken.Add(new KeyValuePair <RelativeDirection, AggregatedArc>(sideDirection, side)); } } if (current.Segment.Points != null) { foreach (var routePoint in current.Segment.Points) { var poi = new PointPoi(); poi.Name = routePoint.Name; poi.Tags = routePoint.Tags.ConvertTo(); poi.Location = new GeoCoordinate(routePoint.Latitude, routePoint.Longitude); var previousCoordinate = new GeoCoordinate(previous.Segment.Latitude, previous.Segment.Longitude); var currentCoordinate = new GeoCoordinate(current.Segment.Latitude, current.Segment.Longitude); poi.Angle = RelativeDirectionCalculator.Calculate(previousCoordinate, currentCoordinate, poi.Location); p.Points.Add(poi); } } // link the arc to the point. a.Next = p; return(a); }
/// <summary> /// Generates instructions. /// </summary> /// <param name="aggregatePoint"></param> /// <param name="interpreter"></param> /// <returns></returns> public static List <Instruction> Generate(AggregatedPoint aggregatePoint, IRoutingInterpreter interpreter) { return(InstructionGenerator.Generate(aggregatePoint, interpreter, new OsmSharp.Routing.Instructions.LanguageGeneration.Defaults.SimpleEnglishLanguageGenerator())); }
/// <summary> /// Called when this machine is succesfull. /// </summary> public override void Succes() { // get first point. AggregatedPoint firstPoint = null; if (this.FinalMessages[0] is MicroPlannerMessagePoint) { // machine started on a point. firstPoint = (this.FinalMessages[0] as MicroPlannerMessagePoint).Point; } else { // get the previous point. firstPoint = (this.FinalMessages[0] as MicroPlannerMessageArc).Arc.Previous; } // get the last arc and the last point. var latestArc = (this.FinalMessages[this.FinalMessages.Count - 2] as MicroPlannerMessageArc).Arc; var latestPoint = (this.FinalMessages[this.FinalMessages.Count - 1] as MicroPlannerMessagePoint).Point; // count the number of streets in the same turning direction as the turn // that was found. int count = 0; if (MicroPlannerHelper.IsLeft(latestPoint.Angle.Direction, this.Planner.Interpreter)) { count = MicroPlannerHelper.GetLeft(this.FinalMessages, this.Planner.Interpreter); } else if (MicroPlannerHelper.IsRight(latestPoint.Angle.Direction, this.Planner.Interpreter)) { count = MicroPlannerHelper.GetRight(this.FinalMessages, this.Planner.Interpreter); } // construct the box indicating the location of the resulting find by this machine. var point1 = latestPoint.Location; var box = new GeoCoordinateBox( new GeoCoordinate(point1.Latitude - 0.001f, point1.Longitude - 0.001f), new GeoCoordinate(point1.Latitude + 0.001f, point1.Longitude + 0.001f)); // descide what type of instruction to request be generated. var metaData = new Dictionary <string, object>(); var streetFrom = latestArc.Tags; var streetTo = latestPoint.Next.Tags; var streetCountTurn = 0; var streetCountBeforeTurn = count; var direction = latestPoint.Angle; metaData["count_before"] = streetCountBeforeTurn; metaData["direction"] = direction; if (streetFrom == streetTo) { if (streetCountTurn == 0) {// there are no other streets between the one being turned into and the street coming from in the same // direction as the turn. metaData["type"] = "direct_follow_turn"; } else { // there is another street; this is tricky to explain. metaData["type"] = "indirect_follow_turn"; } } else { if (streetCountTurn == 0) { // there are no other streets between the one being turned into and the street coming from in the same // direction as the turn. metaData["type"] = "direct_turn"; } else { // there is another street; this is tricky to explain. metaData["type"] = "indirect_turn"; } } // let the scentence planner generate the correct information. metaData["street"] = streetTo; metaData["pois"] = latestPoint.Points; this.Planner.SentencePlanner.GenerateInstruction(metaData, firstPoint.SegmentIdx, latestPoint.SegmentIdx, box, latestPoint.Points); }
/// <summary> /// Generates an arc and it's next point from the current aggregated point. /// </summary> /// <param name="previous"></param> /// <param name="current"></param> /// <param name="next"></param> /// <returns></returns> internal AggregatedArc CreateArcAndPoint(AggregatedRoutePoint previous, AggregatedRoutePoint current, AggregatedRoutePoint next) { // create the arc. AggregatedArc a = new AggregatedArc(); a.Name = current.Entry.WayFromName; a.Names = current.Entry.WayFromNames.ConvertTo(); a.Tags = current.Entry.Tags.ConvertToTagsCollection(); if (previous != null) { GeoCoordinate previous_coordinate = new GeoCoordinate(previous.Entry.Latitude, previous.Entry.Longitude); GeoCoordinate current_coordinate = new GeoCoordinate(current.Entry.Latitude, current.Entry.Longitude); Meter distance = previous_coordinate.DistanceReal(current_coordinate); a.Distance = distance; } // create the point. AggregatedPoint p = new AggregatedPoint(); p.Location = new GeoCoordinate(current.Entry.Latitude, current.Entry.Longitude); p.Points = new List <PointPoi>(); if (previous != null && next != null && next.Entry != null) { GeoCoordinate previous_coordinate = new GeoCoordinate(previous.Entry.Latitude, previous.Entry.Longitude); GeoCoordinate next_coordinate = new GeoCoordinate(next.Entry.Latitude, next.Entry.Longitude); p.Angle = RelativeDirectionCalculator.Calculate(previous_coordinate, p.Location, next_coordinate); } if (current.Entry.SideStreets != null && current.Entry.SideStreets.Length > 0) { p.ArcsNotTaken = new List <KeyValuePair <RelativeDirection, AggregatedArc> >(); foreach (RoutePointEntrySideStreet side_street in current.Entry.SideStreets) { AggregatedArc side = new AggregatedArc(); side.Name = side_street.WayName; side.Names = side_street.WayNames.ConvertTo(); side.Tags = side_street.Tags.ConvertToTagsCollection(); RelativeDirection side_direction = null; if (previous != null) { GeoCoordinate previous_coordinate = new GeoCoordinate(previous.Entry.Latitude, previous.Entry.Longitude); GeoCoordinate next_coordinate = new GeoCoordinate(side_street.Latitude, side_street.Longitude); side_direction = RelativeDirectionCalculator.Calculate(previous_coordinate, p.Location, next_coordinate); } p.ArcsNotTaken.Add(new KeyValuePair <RelativeDirection, AggregatedArc>(side_direction, side)); } } if (current.Entry.Points != null) { foreach (RoutePoint route_point in current.Entry.Points) { PointPoi poi = new PointPoi(); poi.Name = route_point.Name; poi.Tags = route_point.Tags.ConvertTo(); poi.Location = new GeoCoordinate(route_point.Latitude, route_point.Longitude); GeoCoordinate previous_coordinate = new GeoCoordinate(previous.Entry.Latitude, previous.Entry.Longitude); GeoCoordinate current_coordinate = new GeoCoordinate(current.Entry.Latitude, current.Entry.Longitude); poi.Angle = RelativeDirectionCalculator.Calculate(previous_coordinate, current_coordinate, poi.Location); p.Points.Add(poi); } } // link the arc to the point. a.Next = p; return(a); }
/// <summary> /// Does the metric calculations. /// </summary> /// <param name="vehicle"></param> /// <param name="p"></param> /// <returns></returns> public abstract Dictionary <string, double> Calculate(Vehicle vehicle, AggregatedPoint p);
/// <summary> /// Calculate metrics for a given turn. /// </summary> /// <param name="vehicle"></param> /// <param name="result"></param> /// <param name="point"></param> private void CalculatePointMetrics(Vehicle vehicle, Dictionary <string, double> result, AggregatedPoint point) { if (point.Angle != null) { if (AggregatedHelper.IsTurn(point.Angle.Direction)) { // no calculations for distance. // update the time. Second second = 0; // ESTIMATE THE INCREASE IN TIME. // TODO: ASSUMED DRIVING ON THE RIGHT; UPDATE TO MAKE CONFIGURABLE. switch (point.Angle.Direction) { case OsmSharp.Math.Geo.Meta.RelativeDirectionEnum.Left: case OsmSharp.Math.Geo.Meta.RelativeDirectionEnum.SharpLeft: case OsmSharp.Math.Geo.Meta.RelativeDirectionEnum.SlightlyLeft: second = 25; break; case OsmSharp.Math.Geo.Meta.RelativeDirectionEnum.Right: case OsmSharp.Math.Geo.Meta.RelativeDirectionEnum.SharpRight: case OsmSharp.Math.Geo.Meta.RelativeDirectionEnum.SlightlyRight: second = 5; break; case OsmSharp.Math.Geo.Meta.RelativeDirectionEnum.TurnBack: second = 30; break; } result[TIME_KEY] = result[TIME_KEY] + second.Value; } else { if (point.ArcsNotTaken != null && point.ArcsNotTaken.Count > 0) { // very simple estimate. Second second = 0; second = 5; result[TIME_KEY] = result[TIME_KEY] + second.Value; } } } }