/// <summary> /// Generates instructions for the given route. /// </summary> public static IList <Instruction> GenerateInstructions(this Route route, ILanguageReference languageReference) { if (route.IsMultimodal()) { throw new NotSupportedException("Generate instruction for multimodal routes is not supported."); } var profile = Profiles.Profile.GetRegistered(route.Profile); return(profile.InstructionGenerator.Generate(route, languageReference)); }
public InstructionCarGenerator(Route route, ILanguageReference languageReference) : this(route, languageReference, new InstructionCarGenerator.TryGetDelegateWithLanguageReference[4] { new InstructionCarGenerator.TryGetDelegateWithLanguageReference(InstructionCarGenerator.GetStartInstruction), new InstructionCarGenerator.TryGetDelegateWithLanguageReference(InstructionCarGenerator.GetStopInstruction), new InstructionCarGenerator.TryGetDelegateWithLanguageReference(InstructionCarGenerator.GetRoundaboutInstruction), new InstructionCarGenerator.TryGetDelegateWithLanguageReference(InstructionCarGenerator.GetTurnInstruction) }) { }
private Table BuildLanguageReferenceTable(ILanguageReference language) { var table = new Table(_script); table["get"] = (Func <string, string>)((key) => { return(language[key]); }); return(table); }
public static List <Instruction> Generate(Route route, ILanguageReference languageReference) { InstructionCarGenerator instructionCarGenerator = new InstructionCarGenerator(route, languageReference); instructionCarGenerator.Run(); if (instructionCarGenerator.HasSucceeded) { return(instructionCarGenerator.Instructions); } return(new List <Instruction>()); }
/// <summary> /// Generates instructions for the given route. /// </summary> public static List <Instruction> Generate(Route route, ILanguageReference languageReference) { var algorithm = new InstructionCarGenerator(route, languageReference); algorithm.Run(); if (algorithm.HasSucceeded) { return(algorithm.Instructions); } return(new List <Instruction>()); }
//gets a turn private Instruction GetTurn(RoutePosition position, ILanguageReference language) { var instruction = new Instruction { Shape = position.Shape, Type = "turn" }; var relativeDirection = position.RelativeDirection().Direction; var turnRelevant = false; var branches = position.Branches(); if (branches != null) { var traversedBranches = GetTraversable(branches).ToList(); if (relativeDirection == RelativeDirectionEnum.StraightOn && traversedBranches.Count >= 2) { turnRelevant = true;// straight on at cross road } if (relativeDirection != RelativeDirectionEnum.StraightOn && traversedBranches.Count > 0) { turnRelevant = true;// an actual normal turn } } if (turnRelevant) { var next = position.Next(); string name = null; if (next != null) { name = next.Value.GetMetaAttribute("name"); } if (!String.IsNullOrEmpty(name)) { instruction.Text = string.Format(language["Go {0} on {1}."], language[relativeDirection.ToString() .ToLower()], name); instruction.Shape = position.Shape; } else { instruction.Text = String.Format(language["Go {0}."], language[relativeDirection.ToString().ToLower()]); instruction.Shape = position.Shape; } return(instruction); } return(null); }
private Instruction GetStart(RoutePosition position, ILanguageReference language) { var instruction = new Instruction { Shape = position.Shape, Type = "start" }; var direction = position.Direction(); instruction.Text = String.Format(language ["Start {0}."], language[direction.ToString() .ToLower()]); return(instruction); }
//gets a roundabout instruction private Instruction GetRoundabout(RoutePosition position, ILanguageReference language) { position.Next(); if (String.IsNullOrEmpty(position.GetMetaAttribute("junction"))) { var instruction = new Instruction { Shape = position.Shape, Type = "roundabout" }; var exit = 1; var count = 1; var previous = position.Previous(); while (previous != null && previous.Value.GetMetaAttribute("junction") == "roundabout") { var branches = previous.Value.Branches(); if (branches != null) { branches = GetTraversable(branches); if (branches.Any()) { exit++; } } count++; previous = previous.Value.Previous(); } instruction.Text = string.Format(language["Take the {0}th exit at the next roundabout."], exit); if (exit == 1) { instruction.Text = string.Format(language["Take the first exit at the next roundabout."]); } else if (exit == 2) { instruction.Text = string.Format(language["Take the second exit at the next roundabout."]); } else if (exit == 3) { instruction.Text = string.Format(language["Take the third exit at the next roundabout."]); } instruction.Shape = position.Shape; return(instruction); } return(null); }
public static int GetStopInstruction(Route r, int i, ILanguageReference languageReference, out Instruction instruction) { instruction = (Instruction)null; if (i != r.Segments.Count - 1 || r.Segments.Count <= 0) { return(0); } instruction = new Instruction() { Text = languageReference["Arrived at destination."], Type = "stop", Segment = r.Segments.Count - 1 }; return(1); }
/// <summary> /// Gets the stop instruction. /// </summary> public static int GetStopInstruction(RoutePosition position, ILanguageReference languageReference, out Instruction instruction) { instruction = null; if (position.IsLast()) { instruction = new Instruction() { Text = languageReference["Arrived at destination."], Type = "stop", Shape = position.Shape }; return(1); } return(0); }
/// <summary> /// Gets the start instruction. /// </summary> public static int GetStartInstruction(RoutePosition position, ILanguageReference languageReference, out Instruction instruction) { instruction = null; if (position.IsFirst()) { instruction = new Instruction() { Text = string.Format(languageReference["Start {0}."], languageReference[position.Direction().ToInvariantString()]), Type = "start", Shape = 0 }; return(1); } return(0); }
public static int GetStartInstruction(Route r, int i, ILanguageReference languageReference, out Instruction instruction) { instruction = (Instruction)null; if (i != 0 || r.Segments.Count <= 0) { return(0); } DirectionEnum directionEnum = DirectionCalculator.Calculate(new GeoCoordinate((double)r.Segments[0].Latitude, (double)r.Segments[0].Longitude), new GeoCoordinate((double)r.Segments[1].Latitude, (double)r.Segments[1].Longitude)); string str = languageReference[directionEnum.ToInvariantString()]; instruction = new Instruction() { Text = string.Format(languageReference["Start {0}."], (object)str), Type = "start", Segment = 0 }; return(1); }
public IList <Instruction> Generate(Route route, ILanguageReference language) { if (route.IsMultimodal()) { throw new ArgumentException("Cannot use a unimodal instruction generator on multimodal route."); } if (_profile.FullName.ToLowerInvariant() != route.Profile) { throw new ArgumentException(string.Format("Cannot generate instructions with a generator for profile {0} for a route with profile {1}.", _profile.FullName, route.Profile)); } var instructions = new List <Instruction>(); foreach (var position in route) { if (position.IsFirst()) { instructions.Add(GetStart(position, language)); } else if (position.IsLast()) { instructions.Add(GetStop(position, language)); } else if (position.GetMetaAttribute("junction") == "roundabout") { var instruction = GetRoundabout(position, language); if (instruction != null) { instructions.Add(instruction); } } else { var instruction = GetTurn(position, language); if (instruction != null) { instructions.Add(instruction); } } } return(instructions); }
/// <summary> /// Generates instructions for the given route assuming it's using the profile in this generator. /// </summary> public IList <Instruction> Generate(Route route, ILanguageReference languageReference, CancellationToken cancellationToken) { if (route.IsMultimodal()) { throw new ArgumentException("Cannot use a unimodal instruction generator on multimodal route."); } if (_profile.FullName.ToLowerInvariant() != route.Profile) { throw new ArgumentException(string.Format("Cannot generate instructions with a generator for profile {0} for a route with profile {1}.", _profile.FullName, route.Profile)); } var instructionGenerator = new UnimodalInstructionGenerator(route, _getInstructionFunctions, languageReference); instructionGenerator.Run(cancellationToken); if (!instructionGenerator.HasSucceeded) { throw new Exception(string.Format("Failed to generate instructions: {0}", instructionGenerator.ErrorMessage)); } return(instructionGenerator.Instructions); }
public static int GetRoundaboutInstruction(Route r, int i, ILanguageReference languageReference, out Instruction instruction) { if (r.Segments[i].Tags != null) { RouteTags[] tags1 = r.Segments[i].Tags; Func <RouteTags, bool> func1 = (Func <RouteTags, bool>)(x => { if (x.Key == "junction") { return(x.Value == "roundabout"); } return(false); }); if (((IEnumerable <RouteTags>)tags1).Any <RouteTags>(func1) && i < r.Segments.Count) { if (r.Segments[i + 1].Tags != null) { RouteTags[] tags2 = r.Segments[i + 1].Tags; Func <RouteTags, bool> func2 = (Func <RouteTags, bool>)(x => { if (x.Key == "junction") { return(x.Value == "roundabout"); } return(false); }); if (((IEnumerable <RouteTags>)tags2).Any <RouteTags>(func2)) { goto label_19; } } int num1 = 1; int num2 = 1; for (int index = i - 1; index >= 0; --index) { ++num2; if (r.Segments[index].Tags != null) { RouteTags[] tags2 = r.Segments[index].Tags; Func <RouteTags, bool> func2 = (Func <RouteTags, bool>)(x => { if (x.Key == "junction") { return(x.Value == "roundabout"); } return(false); }); if (((IEnumerable <RouteTags>)tags2).Any <RouteTags>(func2)) { if (r.Segments[index].SideStreets != null) { ++num1; } } else { break; } } else { break; } } if (num1 == 1) { instruction = new Instruction() { Text = string.Format(languageReference["Take the first exit at the next roundabout."], (object)num1), Type = "roundabout", Segment = i } } ; else if (num1 == 2) { instruction = new Instruction() { Text = string.Format(languageReference["Take the second exit at the next roundabout."], (object)num1), Type = "roundabout", Segment = i } } ; else if (num1 == 3) { instruction = new Instruction() { Text = string.Format(languageReference["Take the third exit at the next roundabout."], (object)num1), Type = "roundabout", Segment = i } } ; else { instruction = new Instruction() { Text = string.Format(languageReference["Take the {0}th exit at the next roundabout."], (object)num1), Type = "roundabout", Segment = i } }; return(num2); } } label_19: instruction = (Instruction)null; return(0); }
public InstructionCarGenerator(Route route, ILanguageReference languageReference, InstructionCarGenerator.TryGetDelegateWithLanguageReference[] getInstructionDelegates) : base(route, InstructionCarGenerator.GetInstructionDelegatesFrom(getInstructionDelegates, languageReference)) { }
/// <summary> /// Gets the roundabout function. /// </summary> public static int GetRoundaboutInstruction(RoutePosition position, ILanguageReference languageReference, out Instruction instruction) { if (position.ContainsMetaAttribute("junction", "roundabout") && !position.IsLast() && !position.Next().Value.ContainsMetaAttribute("junction", "roundabout")) { // ok, it's a roundabout, if the next segment is not on the roundabout, generate an exit roundabout instruction. var exit = 1; var count = 1; while (position.MovePrevious() && position.ContainsMetaAttribute("junction", "roundabout")) { if (position.HasBranches()) { exit++; } count++; } if (exit == 1) { instruction = new Instruction() { Text = string.Format(languageReference["Take the first exit at the next roundabout."], exit), Type = "roundabout", Shape = position.Shape }; } else if (exit == 2) { instruction = new Instruction() { Text = string.Format(languageReference["Take the second exit at the next roundabout."], exit), Type = "roundabout", Shape = position.Shape }; } else if (exit == 3) { instruction = new Instruction() { Text = string.Format(languageReference["Take the third exit at the next roundabout."], exit), Type = "roundabout", Shape = position.Shape }; } else { instruction = new Instruction() { Text = string.Format(languageReference["Take the {0}th exit at the next roundabout."], exit), Type = "roundabout", Shape = position.Shape }; } return(count); } instruction = null; return(0); }
/// <summary> /// Gets the turn instruction function. /// </summary> public static int GetTurnInstruction(RoutePosition position, ILanguageReference languageReference, out Instruction instruction) { var relative = position.RelativeDirection(); var doInstruction = false; if (position.HasBranches()) { var branches = new List <Route.Branch>(position.Branches()); if (relative.Direction == RelativeDirectionEnum.StraightOn && branches.Count >= 2) { // straight-on at cross roads. doInstruction = true; } else if (relative.Direction != RelativeDirectionEnum.StraightOn && relative.Direction != RelativeDirectionEnum.SlightlyLeft && relative.Direction != RelativeDirectionEnum.SlightlyRight && branches.Count > 0) { // an actual turn and there is at least on other street around. doInstruction = true; } } if (doInstruction) { var name = position.GetMetaAttribute("name"); if (!string.IsNullOrWhiteSpace(name)) { // there is a name. if (relative.Direction == RelativeDirectionEnum.StraightOn) { instruction = new Instruction() { Text = string.Format(languageReference["Go {0} on {1}."], languageReference[relative.Direction.ToInvariantString()], name), Type = "turn", Shape = position.Shape }; return(1); } instruction = new Instruction() { Text = string.Format(languageReference["Turn {0} on {1}."], languageReference[relative.Direction.ToInvariantString()], name), Type = "turn", Shape = position.Shape }; return(1); } else { // there is no name. if (relative.Direction == RelativeDirectionEnum.StraightOn) { instruction = new Instruction() { Text = string.Format(languageReference["Go {0}."], languageReference[relative.Direction.ToInvariantString()]), Type = "turn", Shape = position.Shape }; } instruction = new Instruction() { Text = string.Format(languageReference["Turn {0}."], languageReference[relative.Direction.ToInvariantString()]), Type = "turn", Shape = position.Shape }; return(1); } } instruction = null; return(0); }
private static InstructionGenerator <Instruction> .TryGetDelegate GetInstructionDelegateFrom(InstructionCarGenerator.TryGetDelegateWithLanguageReference tryGetDelegate, ILanguageReference languageReference) { return((InstructionGenerator <Instruction> .TryGetDelegate)((Route r, int i, out Instruction instruction) => tryGetDelegate(r, i, languageReference, out instruction))); }
/// <summary> /// Generates instructions for the given route assuming it's using the profile in this generator. /// </summary> public IList <Instruction> Generate(Route route, ILanguageReference languageReference) { return(this.Generate(route, languageReference, CancellationToken.None)); }
private static InstructionGenerator <Instruction> .TryGetDelegate[] GetInstructionDelegatesFrom(InstructionCarGenerator.TryGetDelegateWithLanguageReference[] tryGetDelegates, ILanguageReference languageReference) { InstructionGenerator <Instruction> .TryGetDelegate[] tryGetDelegateArray = new InstructionGenerator <Instruction> .TryGetDelegate[tryGetDelegates.Length]; for (int index = 0; index < tryGetDelegateArray.Length; ++index) { tryGetDelegateArray[index] = InstructionCarGenerator.GetInstructionDelegateFrom(tryGetDelegates[index], languageReference); } return(tryGetDelegateArray); }
/// <summary> /// Creates a new instruction generator. /// </summary> public InstructionGenerator(Route route, TryGetDelegate[] tryGetInstructions, ILanguageReference languageReference) : this(route, tryGetInstructions, null, languageReference) { }
public static int GetTurnInstruction(Route r, int i, ILanguageReference languageReference, out Instruction instruction) { RelativeDirection relativeDirection = r.RelativeDirectionAt(i); if (relativeDirection != null) { bool flag = false; if (relativeDirection.Direction == RelativeDirectionEnum.StraightOn && r.Segments[i].SideStreets != null && r.Segments[i].SideStreets.Length >= 2) { flag = true; } else if (relativeDirection.Direction != RelativeDirectionEnum.StraightOn && relativeDirection.Direction != RelativeDirectionEnum.SlightlyLeft && (relativeDirection.Direction != RelativeDirectionEnum.SlightlyRight && r.Segments[i].SideStreets != null) && r.Segments[i].SideStreets.Length != 0) { flag = true; } if (flag) { string str = languageReference[relativeDirection.Direction.ToInvariantString()]; string name = string.Empty; if (i + 1 < r.Segments.Count && r.Segments[i + 1].Tags != null && ((IEnumerable <RouteTags>)r.Segments[i + 1].Tags).Any <RouteTags>((Func <RouteTags, bool>)(x => { if (!(x.Key == "name")) { return(false); } name = x.Value; return(true); }))) { if (relativeDirection.Direction == RelativeDirectionEnum.StraightOn) { instruction = new Instruction() { Text = string.Format(languageReference["Go {0} on {1}."], new object[2] { (object)str, (object)name }), Type = "turn", Segment = i }; return(1); } instruction = new Instruction() { Text = string.Format(languageReference["Turn {0} on {1}."], new object[2] { (object)str, (object)name }), Type = "turn", Segment = i }; return(1); } if (relativeDirection.Direction == RelativeDirectionEnum.StraightOn) { instruction = new Instruction() { Text = string.Format(languageReference["Go {0}."], (object)str), Type = "turn", Segment = i } } ; instruction = new Instruction() { Text = string.Format(languageReference["Turn {0}."], (object)str), Type = "turn", Segment = i }; return(1); } } instruction = (Instruction)null; return(0); }