/// <summary>
/// Returns true if the given direction is a turn.
/// </summary>
/// <param name="direction"></param>
/// <returns></returns>
public static bool IsTurn(RelativeDirectionEnum direction)
{
switch (direction)
{
case RelativeDirectionEnum.StraightOn:
return false;
}
return true;
}
public static bool IsTurn(RelativeDirectionEnum direction, IRoutingInterpreter interpreter)
{
switch (direction)
{
case RelativeDirectionEnum.StraightOn:
return(false);
}
return(true);
}
/// <summary>
/// Direct turn instruction.
/// </summary>
/// <param name="instruction"></param>
/// <param name="streetCountBeforeTurn"></param>
/// <param name="streetTo"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateDirectTurn(Instruction instruction,
int streetCountBeforeTurn,
List<KeyValuePair<string, string>> streetTo,
RelativeDirectionEnum direction,
List<PointPoi> list)
{
instruction.Text = string.Format("GenerateDirectTurn:{0}_{1}_{2}",
streetCountBeforeTurn, direction.ToString(), list.Count);
return instruction;
}
/// <summary>
/// Returns true if the given direction is left.
/// </summary>
/// <param name="direction"></param>
/// <returns></returns>
public static bool IsLeft(RelativeDirectionEnum direction)
{
switch (direction)
{
case RelativeDirectionEnum.Left:
case RelativeDirectionEnum.SharpLeft:
case RelativeDirectionEnum.SlightlyLeft:
return(true);
}
return(false);
}
/// <summary>
/// Generates an instruction for an indirect turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="street_count_turn"></param>
/// <param name="street_count_before_turn"></param>
/// <param name="street_to"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateIndirectTurn(Instruction instruction, int street_count_turn, int street_count_before_turn,
TagsCollection street_to, RelativeDirectionEnum direction, List <PointPoi> list)
{
instruction.Text = string.Format("Neem de {0}de afslag {1}, de {2} op.",
street_count_before_turn,
TurnDirection(direction),
this.GetName("nl", street_to));
// returns the instruction with text.
return(instruction);
}
/// <summary>
/// Returns true if the given direction is right.
/// </summary>
/// <param name="direction"></param>
/// <returns></returns>
public static bool IsRight(RelativeDirectionEnum direction)
{
switch (direction)
{
case RelativeDirectionEnum.Right:
case RelativeDirectionEnum.SharpRight:
case RelativeDirectionEnum.SlightlyRight:
return true;
}
return false;
}
/// <summary>
/// Generates a simple turn instruction.
/// </summary>
/// <param name="instruction"></param>
/// <param name="direction"></param>
/// <returns></returns>
public Instruction GenerateSimpleTurn(Instruction instruction,
RelativeDirectionEnum direction)
{
instruction.Text = string.Format("GenerateSimpleTurn:{0}",
direction.ToString());
instruction.Extras = new Dictionary <string, object>();
instruction.Extras.Add("direction", direction);
return(instruction);
}
/// <summary>
/// Returns true if the given direction is left.
/// </summary>
/// <param name="direction"></param>
/// <returns></returns>
public static bool IsLeft(RelativeDirectionEnum direction)
{
switch (direction)
{
case RelativeDirectionEnum.Left:
case RelativeDirectionEnum.SharpLeft:
case RelativeDirectionEnum.SlightlyLeft:
return true;
}
return false;
}
public static bool IsRight(RelativeDirectionEnum direction, IRoutingInterpreter interpreter)
{
switch (direction)
{
case RelativeDirectionEnum.Right:
case RelativeDirectionEnum.SharpRight:
case RelativeDirectionEnum.SlightlyRight:
return(true);
}
return(false);
}
/// <summary>
/// Generates an instruction for an indirect turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="street_count_turn"></param>
/// <param name="streetCountBeforeTurn"></param>
/// <param name="street_to"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateIndirectTurn(Instruction instruction, int street_count_turn,
int streetCountBeforeTurn, TagsCollectionBase street_to,
RelativeDirectionEnum direction, List <PointPoi> list)
{
instruction.Text = string.Format("Take the {0}d turn {1}, on {2}.",
streetCountBeforeTurn,
TurnDirection(direction),
this.GetName("en", street_to));
// returns the instruction with text.
return(instruction);
}
/// <summary>
/// Direct turn instruction.
/// </summary>
/// <param name="instruction"></param>
/// <param name="streetCountBeforeTurn"></param>
/// <param name="streetTo"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateDirectTurn(Instruction instruction,
int streetCountBeforeTurn,
TagsCollection streetTo,
RelativeDirectionEnum direction,
List<PointPoi> list)
{
instruction.Text = string.Format("GenerateDirectTurn:{0}_{1}_{2}",
streetCountBeforeTurn, direction.ToString(), list.Count);
instruction.Extras = new Dictionary<string, object>();
instruction.Extras.Add("streetCountBeforeTurn", streetCountBeforeTurn);
instruction.Extras.Add("streetTo", streetTo);
instruction.Extras.Add("direction", direction);
instruction.Extras.Add("list", list);
return instruction;
}
/// <summary>
/// Direct turn instruction.
/// </summary>
/// <param name="instruction"></param>
/// <param name="streetCountBeforeTurn"></param>
/// <param name="streetTo"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateDirectTurn(Instruction instruction,
int streetCountBeforeTurn,
TagsCollection streetTo,
RelativeDirectionEnum direction,
List <PointPoi> list)
{
instruction.Text = string.Format("GenerateDirectTurn:{0}_{1}_{2}",
streetCountBeforeTurn, direction.ToString(), list.Count);
instruction.Extras = new Dictionary <string, object>();
instruction.Extras.Add("streetCountBeforeTurn", streetCountBeforeTurn);
instruction.Extras.Add("streetTo", streetTo);
instruction.Extras.Add("direction", direction);
instruction.Extras.Add("list", list);
return(instruction);
}
private string TurnDirection(RelativeDirectionEnum direction)
{
switch (direction)
{
case RelativeDirectionEnum.Right:
case RelativeDirectionEnum.SharpRight:
case RelativeDirectionEnum.SlightlyRight:
return("rechts");
case RelativeDirectionEnum.Left:
case RelativeDirectionEnum.SharpLeft:
case RelativeDirectionEnum.SlightlyLeft:
return("links");
case RelativeDirectionEnum.TurnBack:
return("terug");
}
return(string.Empty);
}
/// <summary>
/// Generates an instruction for a direct turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="streetCountBeforeTurn"></param>
/// <param name="streetTo"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateDirectTurn(Instruction instruction, int streetCountBeforeTurn,
List<KeyValuePair<string, string>> streetTo, RelativeDirectionEnum direction, List<PointPoi> list)
{
if (streetCountBeforeTurn == 1)
{
instruction.Text = string.Format("Take the first turn {0}, on {1}.",
TurnDirection(direction),
this.GetName("en",streetTo));
}
else
{
instruction.Text = string.Format("Take the {0}th turn {1}, on {2}.",
streetCountBeforeTurn,
TurnDirection(direction),
this.GetName("en",streetTo));
}
// returns the instruction with text.
return instruction;
}
/// <summary>
/// Generates an instruction for a turn followed by another turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="street_count_before_turn"></param>
/// <param name="street_to"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateDirectFollowTurn(Instruction instruction, int street_count_before_turn, List<KeyValuePair<string, string>> street_to,
RelativeDirectionEnum direction, List<PointPoi> list)
{
if (street_count_before_turn == 1)
{
instruction.Text = string.Format("Turn {1} to stay on {0}.",
this.GetName("en", street_to),
this.TurnDirection(direction));
}
else
{
instruction.Text = string.Format("Turn {1} street {2} to stay on {0}.",
this.GetName("en", street_to),
AddOrdinal(street_count_before_turn),
this.TurnDirection(direction));
}
// returns the instruction with text.
return instruction;
}
/// <summary>
/// Generates an instruction for a turn followed by another turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="street_count_before_turn"></param>
/// <param name="street_to"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateDirectFollowTurn(Instruction instruction, int street_count_before_turn, TagsCollection street_to,
RelativeDirectionEnum direction, List<PointPoi> list)
{
if (street_count_before_turn == 1)
{
instruction.Text = string.Format("Turn {1} to stay on {0}.",
this.GetName("en",street_to),
TurnDirection(direction));
}
else
{
instruction.Text = string.Format("Turn {1}d street {2} to stay on {0}.",
this.GetName("en",street_to),
street_count_before_turn,
TurnDirection(direction));
}
// returns the instruction with text.
return instruction;
}
/// <summary>
/// Generates an instruction for a direct turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="street_count_before_turn"></param>
/// <param name="street_to"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateDirectTurn(Instruction instruction, int street_count_before_turn,
TagsCollection street_to, RelativeDirectionEnum direction, List<PointPoi> list)
{
if (street_count_before_turn == 1)
{
instruction.Text = string.Format("Take the first turn {0}, on {1}.",
TurnDirection(direction),
this.GetName("en",street_to));
}
else
{
instruction.Text = string.Format("Take the {0}th turn {1}, on {2}.",
street_count_before_turn,
TurnDirection(direction),
this.GetName("en",street_to));
}
// returns the instruction with text.
return instruction;
}
/// <summary>
/// Generates an instruction for a direct turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="street_count_before_turn"></param>
/// <param name="street_to"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateDirectTurn(Instruction instruction, int street_count_before_turn,
TagsCollection street_to, RelativeDirectionEnum direction, List<PointPoi> list)
{
if (street_count_before_turn == 1)
{
instruction.Text = string.Format("Neem de 1ste afslag {0}, de {1} op.",
TurnDirection(direction),
this.GetName("nl", street_to));
}
else
{
instruction.Text = string.Format("Neem de {0}de afslag {1}, de {2} op.",
street_count_before_turn,
TurnDirection(direction),
this.GetName("nl", street_to));
}
// returns the instruction with text.
return instruction;
}
/// <summary>
/// Generates an instruction for a turn followed by another turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="street_count_before_turn"></param>
/// <param name="street_to"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateDirectFollowTurn(Instruction instruction, int street_count_before_turn, TagsCollection street_to,
RelativeDirectionEnum direction, List <PointPoi> list)
{
if (street_count_before_turn == 1)
{
instruction.Text = string.Format("Turn {1} to stay on {0}.",
this.GetName("en", street_to),
TurnDirection(direction));
}
else
{
instruction.Text = string.Format("Turn {1}d street {2} to stay on {0}.",
this.GetName("en", street_to),
street_count_before_turn,
TurnDirection(direction));
}
// returns the instruction with text.
return(instruction);
}
/// <summary>
/// Generates an instruction for a turn followed by another turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="streetCountBeforeTurn"></param>
/// <param name="streetTo"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateDirectFollowTurn(Instruction instruction, int streetCountBeforeTurn, List<KeyValuePair<string, string>> streetTo,
RelativeDirectionEnum direction, List<PointPoi> list)
{
if (streetCountBeforeTurn == 1)
{
instruction.Text = string.Format("Sla {1}af om op {0} te blijven.",
this.GetName("nl", streetTo),
TurnDirection(direction));
}
else
{
instruction.Text = string.Format("Neem de {1}de straat {2} om op {0} te blijven.",
this.GetName("nl", streetTo),
streetCountBeforeTurn,
TurnDirection(direction));
}
// returns the instruction with text.
return instruction;
}
/// <summary>
/// Generates an instruction for a direct turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="street_count_before_turn"></param>
/// <param name="street_to"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateDirectTurn(Instruction instruction, int street_count_before_turn,
TagsCollection street_to, RelativeDirectionEnum direction, List <PointPoi> list)
{
if (street_count_before_turn == 1)
{
instruction.Text = string.Format("Take the first turn {0}, on {1}.",
TurnDirection(direction),
this.GetName("en", street_to));
}
else
{
instruction.Text = string.Format("Take the {0}th turn {1}, on {2}.",
street_count_before_turn,
TurnDirection(direction),
this.GetName("en", street_to));
}
// returns the instruction with text.
return(instruction);
}
/// <summary>
/// Generates an instruction for a direct turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="streetCountBeforeTurn"></param>
/// <param name="streetTo"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateDirectTurn(Instruction instruction, int streetCountBeforeTurn,
List<KeyValuePair<string, string>> streetTo, RelativeDirectionEnum direction, List<PointPoi> list)
{
if (streetCountBeforeTurn == 1)
{
instruction.Text = string.Format("Neem de 1ste afslag {0}, de {1} op.",
TurnDirection(direction),
this.GetName("nl", streetTo));
}
else
{
instruction.Text = string.Format("Neem de {0}de afslag {1}, de {2} op.",
streetCountBeforeTurn,
TurnDirection(direction),
this.GetName("nl", streetTo));
}
// returns the instruction with text.
return instruction;
}
/// <summary>
/// Generates an instruction for an indirect turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="street_count_turn"></param>
/// <param name="street_count_before_turn"></param>
/// <param name="street_to"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateIndirectFollowTurn(Instruction instruction, int street_count_turn, int street_count_before_turn, TagsCollection street_to,
RelativeDirectionEnum direction, List <PointPoi> list)
{
if (street_count_before_turn == 1)
{
instruction.Text = string.Format("Sla {1}af om op {0} te blijven.",
this.GetName("nl", street_to),
TurnDirection(direction));
}
else
{
instruction.Text = string.Format("Neem de {1}de straat {2} om op {0} te blijven.",
this.GetName("nl", street_to),
street_count_before_turn,
TurnDirection(direction));
}
// returns the instruction with text.
return(instruction);
}
/// <summary>
/// Generates an instruction for an indirect turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="street_count_turn"></param>
/// <param name="street_count_before_turn"></param>
/// <param name="street_to"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateIndirectFollowTurn(Instruction instruction, int street_count_turn, int street_count_before_turn, List <KeyValuePair <string, string> > street_to,
RelativeDirectionEnum direction, List <PointPoi> list)
{
if (street_count_before_turn == 1)
{
instruction.Text = string.Format("Turn {1} to stay on {0}.",
this.GetName("en", street_to),
this.TurnDirection(direction));
}
else
{
instruction.Text = string.Format("Take the {1} street {2} to stay on {0}.",
this.GetName("en", street_to),
AddOrdinal(street_count_before_turn),
this.TurnDirection(direction));
}
// returns the instruction with text.
return(instruction);
}
/// <summary>
/// Generates an instruction for a direct turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="street_count_before_turn"></param>
/// <param name="street_to"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateDirectTurn(Instruction instruction, int street_count_before_turn,
TagsCollection street_to, RelativeDirectionEnum direction, List <PointPoi> list)
{
// if (street_count_before_turn == 1)
// {
// instruction.Text = string.Format("Neem de 1ste afslag {0}, de {1} op.",
// TurnDirection(direction),
// this.GetName("nl", street_to));
// }
// else
// {
// instruction.Text = string.Format("Neem de {0}de afslag {1}, de {2} op.",
// street_count_before_turn,
// TurnDirection(direction),
// this.GetName("nl", street_to));
// }
instruction.Text = string.Format("Draai {0}", TurnDirection(direction));
// returns the instruction with text.
return(instruction);
}
/// <summary>
/// Generates an instruction for a turn followed by another turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="street_count_before_turn"></param>
/// <param name="street_to"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateDirectFollowTurn(Instruction instruction, int street_count_before_turn,
TagsCollectionBase street_to,
RelativeDirectionEnum direction, List <PointPoi> list)
{
// if (street_count_before_turn == 1)
// {
// instruction.Text = string.Format("Sla {1}af om op {0} te blijven.",
// this.GetName("nl", street_to),
// TurnDirection(direction));
// }
// else
// {
// instruction.Text = string.Format("Neem de {1}de straat {2} om op {0} te blijven.",
// this.GetName("nl", street_to),
// street_count_before_turn,
// TurnDirection(direction));
// }
instruction.Text = string.Format("Draai {0}", TurnDirection(direction));
// returns the instruction with text.
return(instruction);
}
/// <summary>
/// Generates an instruction for a turn followed by another turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="street_count_before_turn"></param>
/// <param name="street_to"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateDirectFollowTurn(Instruction instruction, int street_count_before_turn,
TagsCollectionBase street_to,
RelativeDirectionEnum direction, List<PointPoi> list)
{
// if (street_count_before_turn == 1)
// {
// instruction.Text = string.Format("Sla {1}af om op {0} te blijven.",
// this.GetName("nl", street_to),
// TurnDirection(direction));
// }
// else
// {
// instruction.Text = string.Format("Neem de {1}de straat {2} om op {0} te blijven.",
// this.GetName("nl", street_to),
// street_count_before_turn,
// TurnDirection(direction));
// }
instruction.Text = string.Format ("Draai {0}", TurnDirection (direction));
// returns the instruction with text.
return instruction;
}
/// <summary>
/// Generates an instruction for an indirect turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="street_count_turn"></param>
/// <param name="street_count_before_turn"></param>
/// <param name="street_to"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateIndirectFollowTurn(Instruction instruction, int street_count_turn, int street_count_before_turn, TagsCollection street_to,
RelativeDirectionEnum direction, List<PointPoi> list)
{
if (street_count_before_turn == 1)
{
instruction.Text = string.Format("Sla {1}af om op {0} te blijven.",
this.GetName("nl", street_to),
TurnDirection(direction));
}
else
{
instruction.Text = string.Format("Neem de {1}de straat {2} om op {0} te blijven.",
this.GetName("nl", street_to),
street_count_before_turn,
TurnDirection(direction));
}
// returns the instruction with text.
return instruction;
}
/// <summary>
/// Generates an instruction for an indirect turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="street_count_turn"></param>
/// <param name="street_count_before_turn"></param>
/// <param name="street_to"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateIndirectTurn(Instruction instruction, int street_count_turn, int street_count_before_turn,
TagsCollectionBase street_to, RelativeDirectionEnum direction, List<PointPoi> list)
{
// instruction.Text = string.Format("Neem de {0}de afslag {1}, de {2} op.",
// street_count_before_turn,
// TurnDirection(direction),
// this.GetName("nl", street_to));
instruction.Text = string.Format ("Draai {0}", TurnDirection (direction));
// returns the instruction with text.
return instruction;
}
/// <summary>
/// Generates an instruction for a POI.
/// </summary>
/// <param name="instruction"></param>
/// <param name="list"></param>
/// <param name="direction"></param>
/// <returns></returns>
public Instruction GeneratePoi(Instruction instruction, List<PointPoi> list, RelativeDirectionEnum? direction)
{
// if (direction == null)
// {
// instruction.Text = string.Format("Poi");
// }
// else
// {
// instruction.Text = string.Format("Poi:{0}", direction);
// }
instruction.Text = "Aangekomst";
// returns the instruction with text.
return instruction;
}
/// <summary>
/// Generates a simple turn instruction.
/// </summary>
/// <param name="instruction"></param>
/// <param name="direction"></param>
/// <returns></returns>
public Instruction GenerateSimpleTurn(Instruction instruction,
RelativeDirectionEnum direction)
{
instruction.Text = string.Format("GenerateSimpleTurn:{0}",
direction.ToString());
return instruction;
}
/// <summary>
/// Generates poi instruction.
/// </summary>
/// <param name="instruction"></param>
/// <param name="list"></param>
/// <param name="direction"></param>
/// <returns></returns>
public Instruction GeneratePoi(Instruction instruction, List<PointPoi> list,
RelativeDirectionEnum? direction)
{
if (direction.HasValue)
{
instruction.Text = string.Format("GeneratePoi:{0}_{1}",
list.Count, direction.Value.ToString());
}
else
{
instruction.Text = string.Format("GeneratePoi:{0}",
list.Count);
}
return instruction;
}
/// <summary>
/// Generates poi instruction.
/// </summary>
/// <param name="instruction"></param>
/// <param name="list"></param>
/// <param name="direction"></param>
/// <returns></returns>
public Instruction GeneratePoi(Instruction instruction, List<PointPoi> list,
RelativeDirectionEnum? direction)
{
if (direction.HasValue)
{
instruction.Text = string.Format("GeneratePoi:{0}_{1}",
list.Count, direction.Value.ToString());
}
else
{
instruction.Text = string.Format("GeneratePoi:{0}",
list.Count);
}
instruction.Extras = new Dictionary<string, object>();
instruction.Extras.Add("direction", direction);
instruction.Extras.Add("list", list);
return instruction;
}
/// <summary>
/// Generates an instruction for an indirect turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="street_count_turn"></param>
/// <param name="street_count_before_turn"></param>
/// <param name="street_to"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateIndirectTurn(Instruction instruction, int street_count_turn, int street_count_before_turn,
List<KeyValuePair<string, string>> street_to, RelativeDirectionEnum direction, List<PointPoi> list)
{
instruction.Text = string.Format("Take the {0} turn {1}, on {2}.",
AddOrdinal(street_count_before_turn),
this.TurnDirection(direction),
this.GetName("en", street_to));
// returns the instruction with text.
return instruction;
}
/// <summary>
/// Generates an instruction for an indirect turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="street_count_turn"></param>
/// <param name="streetCountBeforeTurn"></param>
/// <param name="street_to"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateIndirectTurn(Instruction instruction, int street_count_turn,
int streetCountBeforeTurn, TagsCollectionBase street_to,
RelativeDirectionEnum direction, List<PointPoi> list)
{
instruction.Text = string.Format("Take the {0}d turn {1}, on {2}.",
streetCountBeforeTurn,
TurnDirection(direction),
this.GetName("en",street_to));
// returns the instruction with text.
return instruction;
}
/// <summary>
/// Generates an instruction for an indirect turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="streetCountTurn"></param>
/// <param name="streetCountBeforeTurn"></param>
/// <param name="streetTo"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateIndirectFollowTurn(Instruction instruction, int streetCountTurn, int streetCountBeforeTurn, List<KeyValuePair<string, string>> streetTo,
RelativeDirectionEnum direction, List<PointPoi> list)
{
if (streetCountBeforeTurn == 1)
{
instruction.Text = string.Format("Turn {1} to stay on {0}.",
this.GetName("en",streetTo),
TurnDirection(direction));
}
else
{
instruction.Text = string.Format("Take the {1}d street {2} to stay on {0}.",
this.GetName("en",streetTo),
streetCountBeforeTurn,
TurnDirection(direction));
}
// returns the instruction with text.
return instruction;
}
/// <summary>
/// Generates an instruction for a simple turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="direction"></param>
/// <returns></returns>
public Instruction GenerateSimpleTurn(Instruction instruction, RelativeDirectionEnum direction)
{
instruction.Text = string.Format("Draai {0}", this.TurnDirection(direction));
return(instruction);
}
/// <summary>
/// Generates an instruction for a POI.
/// </summary>
/// <param name="instruction"></param>
/// <param name="list"></param>
/// <param name="direction"></param>
/// <returns></returns>
public Instruction GeneratePoi(Instruction instruction, List<PointPoi> list,
RelativeDirectionEnum? direction)
{
if (direction == null)
{
instruction.Text = string.Format("Poi");
}
else
{
instruction.Text = string.Format("Poi:{0}", direction);
}
// returns the instruction with text.
return instruction;
}
private string TurnDirection(RelativeDirectionEnum direction)
{
switch (direction)
{
case RelativeDirectionEnum.Right:
case RelativeDirectionEnum.SharpRight:
case RelativeDirectionEnum.SlightlyRight:
return "right";
case RelativeDirectionEnum.Left:
case RelativeDirectionEnum.SharpLeft:
case RelativeDirectionEnum.SlightlyLeft:
return "left";
case RelativeDirectionEnum.TurnBack:
return "back";
}
return string.Empty;
}
/// <summary>
/// Generates an instruction for a simple turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="direction"></param>
/// <returns></returns>
public Instruction GenerateSimpleTurn(Instruction instruction, RelativeDirectionEnum direction)
{
instruction.Text = string.Format("Turn {0}", this.TurnDirection(direction));
return instruction;
}
/// <summary>
/// Generates a simple turn instruction.
/// </summary>
/// <param name="instruction"></param>
/// <param name="direction"></param>
/// <returns></returns>
public Instruction GenerateSimpleTurn(Instruction instruction,
RelativeDirectionEnum direction)
{
instruction.Text = string.Format("GenerateSimpleTurn:{0}",
direction.ToString());
instruction.Extras = new Dictionary<string, object>();
instruction.Extras.Add("direction", direction);
return instruction;
}
/// <summary>
/// Generates an instruction for an indirect turn.
/// </summary>
/// <param name="instruction"></param>
/// <param name="street_count_turn"></param>
/// <param name="street_count_before_turn"></param>
/// <param name="street_to"></param>
/// <param name="direction"></param>
/// <param name="list"></param>
/// <returns></returns>
public Instruction GenerateIndirectTurn(Instruction instruction, int street_count_turn, int street_count_before_turn,
List <KeyValuePair <string, string> > street_to, RelativeDirectionEnum direction, List <PointPoi> list)
{
instruction.Text = string.Format("Take the {0} turn {1}, on {2}.",
AddOrdinal(street_count_before_turn),
this.TurnDirection(direction),
this.GetName("en", street_to));
// returns the instruction with text.
return(instruction);
}
