/// <summary>
        /// Calculates the relative direction.
        /// </summary>
        /// <param name="from"></param>
        /// <param name="along"></param>
        /// <param name="to"></param>
        /// <returns></returns>
        public static RelativeDirection Calculate(GeoCoordinate from, GeoCoordinate along, GeoCoordinate to)
        {
            RelativeDirection direction = new RelativeDirection();

            double margin = 65;
            double straight_on = 10;
            double turn_back = 5;

            GeoCoordinateLine line_from = new GeoCoordinateLine(from, along);
            GeoCoordinateLine line_to = new GeoCoordinateLine(along, to);

            Degree angle = line_from.Direction.Angle(line_to.Direction);

            if (angle >= new Degree(360 - straight_on)
                || angle < new Degree(straight_on))
            {
                direction.Direction = RelativeDirectionEnum.StraightOn;
            }
            else if (angle >= new Degree(straight_on)
                && angle < new Degree(90 - margin))
            {
                direction.Direction = RelativeDirectionEnum.SlightlyLeft;
            }
            else if (angle >= new Degree(90 - margin)
                && angle < new Degree(90 + margin))
            {
                direction.Direction = RelativeDirectionEnum.Left;
            }
            else if (angle >= new Degree(90 + margin)
                && angle < new Degree(180 - turn_back))
            {
                direction.Direction = RelativeDirectionEnum.SharpLeft;
            }
            else if (angle >= new Degree(180 - turn_back)
                && angle < new Degree(180 + turn_back))
            {
                direction.Direction = RelativeDirectionEnum.TurnBack;
            }
            else if (angle >= new Degree(180 + turn_back)
                && angle < new Degree(270-margin))
            {
                direction.Direction = RelativeDirectionEnum.SharpRight;
            }
            else if (angle >= new Degree(270 - margin)
                && angle < new Degree(270 + margin))
            {
                direction.Direction = RelativeDirectionEnum.Right;
            }
            else if (angle >= new Degree(270 + margin)
                && angle < new Degree(360- straight_on))
            {
                direction.Direction = RelativeDirectionEnum.SlightlyRight;
            }
            //direction.Direction = RelativeDirectionEnum.StraightOn;
            direction.Angle = angle;

            return direction;
        }
Пример #2
0
        /// <summary>
        /// Calculates the relative direction.
        /// </summary>
        /// <param name="from"></param>
        /// <param name="along"></param>
        /// <param name="to"></param>
        /// <returns></returns>
        public static RelativeDirection Calculate(GeoCoordinate from, GeoCoordinate along, GeoCoordinate to)
        {
            RelativeDirection direction = new RelativeDirection();

            double margin      = 65;
            double straight_on = 10;
            double turn_back   = 5;

            GeoCoordinateLine line_from = new GeoCoordinateLine(from, along);
            GeoCoordinateLine line_to   = new GeoCoordinateLine(along, to);

            Degree angle = line_from.Direction.Angle(line_to.Direction);

            if (angle >= new Degree(360 - straight_on) ||
                angle < new Degree(straight_on))
            {
                direction.Direction = RelativeDirectionEnum.StraightOn;
            }
            else if (angle >= new Degree(straight_on) &&
                     angle < new Degree(90 - margin))
            {
                direction.Direction = RelativeDirectionEnum.SlightlyLeft;
            }
            else if (angle >= new Degree(90 - margin) &&
                     angle < new Degree(90 + margin))
            {
                direction.Direction = RelativeDirectionEnum.Left;
            }
            else if (angle >= new Degree(90 + margin) &&
                     angle < new Degree(180 - turn_back))
            {
                direction.Direction = RelativeDirectionEnum.SharpLeft;
            }
            else if (angle >= new Degree(180 - turn_back) &&
                     angle < new Degree(180 + turn_back))
            {
                direction.Direction = RelativeDirectionEnum.TurnBack;
            }
            else if (angle >= new Degree(180 + turn_back) &&
                     angle < new Degree(270 - margin))
            {
                direction.Direction = RelativeDirectionEnum.SharpRight;
            }
            else if (angle >= new Degree(270 - margin) &&
                     angle < new Degree(270 + margin))
            {
                direction.Direction = RelativeDirectionEnum.Right;
            }
            else if (angle >= new Degree(270 + margin) &&
                     angle < new Degree(360 - straight_on))
            {
                direction.Direction = RelativeDirectionEnum.SlightlyRight;
            }
            //direction.Direction = RelativeDirectionEnum.StraightOn;
            direction.Angle = angle;

            return(direction);
        }
        /// <summary>
        /// Calculates the relative direction.
        /// </summary>
        /// <param name="from"></param>
        /// <param name="along"></param>
        /// <param name="to"></param>
        /// <returns></returns>
        public static RelativeDirection Calculate(GeoCoordinate from, GeoCoordinate along, GeoCoordinate to)
        {
            var direction = new RelativeDirection();

            var margin      = 65.0;
            var straight_on = 10.0;
            var turn_back   = 5.0;

            var lineFrom = new GeoCoordinateLine(from, along);
            var lineTo   = new GeoCoordinateLine(along, to);

            var angle = lineFrom.Direction.Angle(lineTo.Direction);

            if (angle >= new Degree(360 - straight_on) ||
                angle < new Degree(straight_on))
            {
                direction.Direction = RelativeDirectionEnum.StraightOn;
            }
            else if (angle >= new Degree(straight_on) &&
                     angle < new Degree(90 - margin))
            {
                direction.Direction = RelativeDirectionEnum.SlightlyLeft;
            }
            else if (angle >= new Degree(90 - margin) &&
                     angle < new Degree(90 + margin))
            {
                direction.Direction = RelativeDirectionEnum.Left;
            }
            else if (angle >= new Degree(90 + margin) &&
                     angle < new Degree(180 - turn_back))
            {
                direction.Direction = RelativeDirectionEnum.SharpLeft;
            }
            else if (angle >= new Degree(180 - turn_back) &&
                     angle < new Degree(180 + turn_back))
            {
                direction.Direction = RelativeDirectionEnum.TurnBack;
            }
            else if (angle >= new Degree(180 + turn_back) &&
                     angle < new Degree(270 - margin))
            {
                direction.Direction = RelativeDirectionEnum.SharpRight;
            }
            else if (angle >= new Degree(270 - margin) &&
                     angle < new Degree(270 + margin))
            {
                direction.Direction = RelativeDirectionEnum.Right;
            }
            else if (angle >= new Degree(270 + margin) &&
                     angle < new Degree(360 - straight_on))
            {
                direction.Direction = RelativeDirectionEnum.SlightlyRight;
            }
            direction.Angle = angle;

            return(direction);
        }
        /// <summary>
        /// Calculates the relative direction.
        /// </summary>
        /// <param name="from"></param>
        /// <param name="along"></param>
        /// <param name="to"></param>
        /// <returns></returns>
        public static RelativeDirection Calculate(GeoCoordinate from, GeoCoordinate along, GeoCoordinate to)
        {
            var direction = new RelativeDirection();

            var margin = 65.0;
            var straight_on = 10.0;
            var turn_back = 5.0;

            var lineFrom = new GeoCoordinateLine(from, along);
            var lineTo = new GeoCoordinateLine(along, to);

            var angle = lineFrom.Direction.Angle(lineTo.Direction);

            if (angle >= new Degree(360 - straight_on)
                || angle < new Degree(straight_on))
            {
                direction.Direction = RelativeDirectionEnum.StraightOn;
            }
            else if (angle >= new Degree(straight_on)
                && angle < new Degree(90 - margin))
            {
                direction.Direction = RelativeDirectionEnum.SlightlyLeft;
            }
            else if (angle >= new Degree(90 - margin)
                && angle < new Degree(90 + margin))
            {
                direction.Direction = RelativeDirectionEnum.Left;
            }
            else if (angle >= new Degree(90 + margin)
                && angle < new Degree(180 - turn_back))
            {
                direction.Direction = RelativeDirectionEnum.SharpLeft;
            }
            else if (angle >= new Degree(180 - turn_back)
                && angle < new Degree(180 + turn_back))
            {
                direction.Direction = RelativeDirectionEnum.TurnBack;
            }
            else if (angle >= new Degree(180 + turn_back)
                && angle < new Degree(270-margin))
            {
                direction.Direction = RelativeDirectionEnum.SharpRight;
            }
            else if (angle >= new Degree(270 - margin)
                && angle < new Degree(270 + margin))
            {
                direction.Direction = RelativeDirectionEnum.Right;
            }
            else if (angle >= new Degree(270 + margin)
                && angle < new Degree(360- straight_on))
            {
                direction.Direction = RelativeDirectionEnum.SlightlyRight;
            }
            direction.Angle = angle;

            return direction;
        }
Пример #5
0
 /// <summary>
 /// Generates POI instruction.
 /// </summary>
 /// <param name="direction"></param>
 /// <param name="pois"></param>
 /// <returns></returns>
 protected override string GeneratePOI(RelativeDirection direction, List<PointPoi> pois)
 {
     if (direction != null)
     {
         return string.Format("GeneratePoi:{0}_{1}", pois.Count, direction.Direction.ToString());
     }
     else
     {
         return string.Format("GeneratePoi:{0}", pois.Count);
     }
 }
Пример #6
0
 /// <summary>
 /// Generates an instruction for a direct turn.
 /// </summary>
 /// <param name="countBefore"></param>
 /// <param name="street"></param>
 /// <param name="direction"></param>
 /// <param name="pois"></param>
 /// <returns></returns>
 protected override string GenerateDirectTurn(int countBefore, TagsCollectionBase street, RelativeDirection direction, List<PointPoi> pois)
 {
     countBefore++;
     if (countBefore == 1)
     {
         return string.Format("Neem de 1ste afslag {0}, de {1} op.", TurnDirection(direction), this.GetName("nl", street));
     }
     else
     {
         return string.Format("Neem de {0}de afslag {1}, de {2} op.", countBefore, TurnDirection(direction), this.GetName("nl", street));
     }
 }
Пример #7
0
 /// <summary>
 /// Generates an instruction for a direct turn.
 /// </summary>
 /// <param name="countBefore"></param>
 /// <param name="street"></param>
 /// <param name="direction"></param>
 /// <param name="pois"></param>
 /// <returns></returns>
 protected override string GenerateDirectTurn(int countBefore, TagsCollectionBase street, RelativeDirection direction, List<PointPoi> pois)
 {
     countBefore++;
     if (countBefore == 1)
     {
         return string.Format("Nimm die erste Abzweigung {0}, auf die {1}", TurnDirection(direction), this.GetName("de", street));
     }
     else
     {
         return string.Format("Nimm die {0}te Abzweigung {1}, auf die {2}.", countBefore, TurnDirection(direction), this.GetName("de", street));
     }
 }
Пример #8
0
 /// <summary>
 /// Generates an instruction for a direct turn.
 /// </summary>
 /// <param name="countBefore"></param>
 /// <param name="street"></param>
 /// <param name="direction"></param>
 /// <param name="pois"></param>
 /// <returns></returns>
 protected override string GenerateDirectTurn(int countBefore, TagsCollectionBase street, RelativeDirection direction, List<PointPoi> pois)
 {
     countBefore++;
     if (countBefore == 1)
     {
         return string.Format("Take the first turn {0}, on {1}.", TurnDirection(direction), this.GetName("en", street));
     }
     else
     {
         return string.Format("Take the {0}th turn {1}, on {2}.", countBefore, TurnDirection(direction), this.GetName("en", street));
     }
 }
Пример #9
0
        public static RelativeDirection Calculate(GeoCoordinate from, GeoCoordinate along, GeoCoordinate to)
        {
            RelativeDirection relativeDirection = new RelativeDirection();
            double            num1   = 65.0;
            double            num2   = 10.0;
            double            num3   = 5.0;
            Radian            radian = new GeoCoordinateLine(from, along).Direction.Angle(new GeoCoordinateLine(along, to).Direction);

            if ((Degree)radian >= new Degree(360.0 - num2) || (Degree)radian < new Degree(num2))
            {
                relativeDirection.Direction = RelativeDirectionEnum.StraightOn;
            }
            else if ((Degree)radian >= new Degree(num2) && (Degree)radian < new Degree(90.0 - num1))
            {
                relativeDirection.Direction = RelativeDirectionEnum.SlightlyLeft;
            }
            else if ((Degree)radian >= new Degree(90.0 - num1) && (Degree)radian < new Degree(90.0 + num1))
            {
                relativeDirection.Direction = RelativeDirectionEnum.Left;
            }
            else if ((Degree)radian >= new Degree(90.0 + num1) && (Degree)radian < new Degree(180.0 - num3))
            {
                relativeDirection.Direction = RelativeDirectionEnum.SharpLeft;
            }
            else if ((Degree)radian >= new Degree(180.0 - num3) && (Degree)radian < new Degree(180.0 + num3))
            {
                relativeDirection.Direction = RelativeDirectionEnum.TurnBack;
            }
            else if ((Degree)radian >= new Degree(180.0 + num3) && (Degree)radian < new Degree(270.0 - num1))
            {
                relativeDirection.Direction = RelativeDirectionEnum.SharpRight;
            }
            else if ((Degree)radian >= new Degree(270.0 - num1) && (Degree)radian < new Degree(270.0 + num1))
            {
                relativeDirection.Direction = RelativeDirectionEnum.Right;
            }
            else if ((Degree)radian >= new Degree(270.0 + num1) && (Degree)radian < new Degree(360.0 - num2))
            {
                relativeDirection.Direction = RelativeDirectionEnum.SlightlyRight;
            }
            relativeDirection.Angle = (Degree)radian;
            return(relativeDirection);
        }
Пример #10
0
 /// <summary>
 /// Generates a word for the the given direction.
 /// </summary>
 /// <param name="direction"></param>
 /// <returns></returns>
 private string TurnDirection(RelativeDirection direction)
 {
     if (direction != null)
     {
         switch (direction.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;
 }
Пример #11
0
        /// <summary>
        /// Generates an immidiate turn.
        /// </summary>
        /// <param name="instruction"></param>
        /// <param name="firstStreetCountTo"></param>
        /// <param name="firstStreetTo"></param>
        /// <param name="firstDirection"></param>
        /// <param name="secondStreetTo"></param>
        /// <param name="secondDirection"></param>
        /// <returns></returns>
        public Instruction GenerateImmidiateTurn(Instruction instruction,
                                                 int firstStreetCountTo,
                                                 TagsCollection firstStreetTo,
                                                 OsmSharp.Math.Geo.Meta.RelativeDirection firstDirection,
                                                 TagsCollection secondStreetTo,
                                                 RelativeDirection secondDirection)
        {
            instruction.Text = string.Format("GenerateImmidiateTurn:{0}_{1}_{2}_{3}",
                                             firstStreetCountTo, firstDirection,
                                             firstDirection.ToString(),
                                             secondDirection.ToString());

            instruction.Extras = new Dictionary <string, object>();
            instruction.Extras.Add("firstStreetCountTo", firstStreetCountTo);
            instruction.Extras.Add("firstStreetTo", firstStreetTo);
            instruction.Extras.Add("firstDirection", firstDirection);
            instruction.Extras.Add("secondStreetTo", secondStreetTo);
            instruction.Extras.Add("secondDirection", secondDirection);

            return(instruction);
        }
Пример #12
0
 /// <summary>
 /// Generates an instruction for an immidiate turn.
 /// </summary>
 /// <param name="countBefore"></param>
 /// <param name="firstStreet"></param>
 /// <param name="firstDirection"></param>
 /// <param name="secondStreet"></param>
 /// <param name="secondDirection"></param>
 /// <param name="pois"></param>
 /// <returns></returns>
 protected override string GenerateImmidiateTurn(int countBefore, TagsCollectionBase firstStreet, RelativeDirection firstDirection, TagsCollectionBase secondStreet, RelativeDirection secondDirection, List<PointPoi> pois)
 {
     countBefore++;
     if (countBefore == 1)
     {
         return string.Format("Neem de eerste afslag {0}, op de {1}, en draai onmiddellijk {2} op de {3}.",
             TurnDirection(firstDirection),
             this.GetName("nl", firstStreet),
             TurnDirection(secondDirection),
             this.GetName("nl", secondStreet));
     }
     else
     {
         return string.Format("Neem de {4}de afslag {0}, op de {1}, en draai onmiddellijk {2} op de {3}.",
             TurnDirection(firstDirection),
             this.GetName("nl", firstStreet),
             TurnDirection(secondDirection),
             this.GetName("nl", secondStreet),
             countBefore);
     }
 }
Пример #13
0
 /// <summary>
 /// Generates an instruction for an immidiate turn.
 /// </summary>
 /// <param name="countBefore"></param>
 /// <param name="firstStreet"></param>
 /// <param name="firstDirection"></param>
 /// <param name="secondStreet"></param>
 /// <param name="secondDirection"></param>
 /// <param name="pois"></param>
 /// <returns></returns>
 protected override string GenerateImmidiateTurn(int countBefore, TagsCollectionBase firstStreet, RelativeDirection firstDirection, TagsCollectionBase secondStreet, RelativeDirection secondDirection, List<PointPoi> pois)
 {
     countBefore++;
     if (countBefore == 1)
     {
         return string.Format("Nimm die erste Abzweigung {0}, auf die {1}, und fahre sofort {2} auf die {3}.",
             TurnDirection(firstDirection),
             this.GetName("de", firstStreet),
             TurnDirection(secondDirection),
             this.GetName("de", secondStreet));
     }
     else
     {
         return string.Format("Nimm die {4}te Abzweigung {0}, auf die {1}, und fahre sofort {2} auf die {3}.",
             TurnDirection(firstDirection),
             this.GetName("de", firstStreet),
             TurnDirection(secondDirection),
             this.GetName("de", secondStreet),
             countBefore);
     }
 }
Пример #14
0
 /// <summary>
 /// Generates an instruction for an immidiate turn.
 /// </summary>
 /// <param name="countBefore"></param>
 /// <param name="firstStreet"></param>
 /// <param name="firstDirection"></param>
 /// <param name="secondStreet"></param>
 /// <param name="secondDirection"></param>
 /// <param name="pois"></param>
 /// <returns></returns>
 protected override string GenerateImmidiateTurn(int countBefore, TagsCollectionBase firstStreet, RelativeDirection firstDirection, TagsCollectionBase secondStreet, RelativeDirection secondDirection, List<PointPoi> pois)
 {
     countBefore++;
     if (countBefore == 1)
     {
         return string.Format("Take the first turn {0}, on the {1}, and turn immidiately {2} on the {3}.",
             TurnDirection(firstDirection),
             this.GetName("en", firstStreet),
             TurnDirection(secondDirection),
             this.GetName("en", secondStreet));
     }
     else
     {
         return string.Format("Take the {4}d turn {0}, on the {1}, and turn immidiately {2} on the {3}.",
             TurnDirection(firstDirection),
             this.GetName("en", firstStreet),
             TurnDirection(secondDirection),
             this.GetName("en", secondStreet),
             countBefore);
     }
 }
Пример #15
0
 /// <summary>
 /// Generates an instruction for a simple turn.
 /// </summary>
 /// <param name="count"></param>
 /// <param name="direction"></param>
 /// <returns></returns>
 protected override string GenerateTurn(RelativeDirection direction)
 {
     return string.Format("Fahre {0}", this.TurnDirection(direction));
 }
Пример #16
0
 /// <summary>
 /// Generates an instruction for a POI.
 /// </summary>
 /// <param name="direction"></param>
 /// <param name="pois"></param>
 /// <returns></returns>
 protected override string GeneratePOI(RelativeDirection direction, List<PointPoi> pois)
 {
     if (direction == null)
     {
         return string.Format("Poi");
     }
     else
     {
         return string.Format("Poi:{0}", direction.Direction);
     }
 }
Пример #17
0
 /// <summary>
 /// Generates an instruction for an indirect turn.
 /// </summary>
 /// <param name="countBefore"></param>
 /// <param name="street"></param>
 /// <param name="direction"></param>
 /// <param name="list"></param>
 /// <returns></returns>
 protected override string GenerateIndirectFollowTurn(int countBefore, TagsCollectionBase street, RelativeDirection direction, List<PointPoi> list)
 {
     countBefore++;
     if (countBefore == 1)
     {
         return string.Format("Fahre {1} und bleibe auf der {0}.", this.GetName("de", street), TurnDirection(direction));
     }
     else
     {
         return string.Format("Nimm {1}te Straße {2} und bleib auf der {0}.", this.GetName("de", street), countBefore, TurnDirection(direction));
     }
 }
        /// <summary>
        /// Generates an immidiate turn.
        /// </summary>
        /// <param name="instruction"></param>
        /// <param name="firstStreetCountTo"></param>
        /// <param name="firstStreetTo"></param>
        /// <param name="firstDirection"></param>
        /// <param name="secondStreetTo"></param>
        /// <param name="secondDirection"></param>
        /// <returns></returns>
        public Instruction GenerateImmidiateTurn(Instruction instruction,
            int firstStreetCountTo,
            TagsCollection firstStreetTo,
            OsmSharp.Math.Geo.Meta.RelativeDirection firstDirection,
            TagsCollection secondStreetTo,
            RelativeDirection secondDirection)
        {
            instruction.Text = string.Format("GenerateImmidiateTurn:{0}_{1}_{2}_{3}",
                                             firstStreetCountTo, firstDirection,
                                             firstDirection.ToString(),
                                             secondDirection.ToString());

            instruction.Extras = new Dictionary<string, object>();
            instruction.Extras.Add("firstStreetCountTo", firstStreetCountTo);
            instruction.Extras.Add("firstStreetTo", firstStreetTo);
            instruction.Extras.Add("firstDirection", firstDirection);
            instruction.Extras.Add("secondStreetTo", secondStreetTo);
            instruction.Extras.Add("secondDirection", secondDirection);

            return instruction;
        }
Пример #19
0
 /// <summary>
 /// Generates an indirect follow turn.
 /// </summary>
 /// <param name="countBefore"></param>
 /// <param name="street"></param>
 /// <param name="direction"></param>
 /// <param name="list"></param>
 /// <returns></returns>
 protected override string GenerateIndirectFollowTurn(int countBefore, TagsCollectionBase street, RelativeDirection direction, List<PointPoi> list)
 {
     return string.Format("GenerateDirectFollowTurn:{0}_{1}_{2}",
                                      countBefore, direction.Direction.ToString(), list.Count);
 }
Пример #20
0
 /// <summary>
 /// Generates a simple turn instruction.
 /// </summary>
 /// <param name="direction"></param>
 /// <returns></returns>
 protected override string GenerateTurn(RelativeDirection direction)
 {
     return string.Format("GenerateSimpleTurn:{0}", direction.ToString());
 }
Пример #21
0
 /// <summary>
 /// Generates an instruction for an immidiate turn.
 /// </summary>
 /// <param name="countBefore"></param>
 /// <param name="firstStreet"></param>
 /// <param name="firstDirection"></param>
 /// <param name="secondStreet"></param>
 /// <param name="secondDirection"></param>
 /// <param name="pois"></param>
 /// <returns></returns>
 protected abstract string GenerateImmidiateTurn(int countBefore, TagsCollectionBase firstStreet, RelativeDirection firstDirection, TagsCollectionBase secondStreet, RelativeDirection secondDirection, List<PointPoi> pois);
        /// <summary>
        /// Generates an instruction for an immidiate turn.
        /// </summary>
        /// <param name="instruction"></param>
        /// <param name="first_street_count_to"></param>
        /// <param name="first_street_to"></param>
        /// <param name="first_direction"></param>
        /// <param name="second_street_to"></param>
        /// <param name="second_direction"></param>
        /// <returns></returns>
        public Instruction GenerateImmidiateTurn(Instruction instruction, int first_street_count_to, TagsCollection first_street_to,
            RelativeDirection first_direction, TagsCollection second_street_to, RelativeDirection second_direction)
        {
            if (first_street_count_to == 1)
            {
                instruction.Text = string.Format("Neem de 1ste afslag {0}, de {1} op, en ga onmiddellijk {2} op de {3}.",
                    TurnDirection(first_direction.Direction),
                    this.GetName("nl", first_street_to),
                    TurnDirection(second_direction.Direction),
                    this.GetName("nl", second_street_to));
            }
            else
            {
                instruction.Text = string.Format("Neem de {4}de afslag {0}, de {1} op, en ga onmiddellijk {2} op de {3}.",
                    TurnDirection(first_direction.Direction),
                    this.GetName("nl", first_street_to),
                    TurnDirection(second_direction.Direction),
                    this.GetName("nl", second_street_to),
                    first_street_count_to);
            }

            // returns the instruction with text.
            return instruction;
        }
Пример #23
0
        /// <summary>
        /// Generates an immidiate turn instruction.
        /// </summary>
        /// <param name="entryIdx"></param>
        /// <param name="box"></param>
        /// <param name="before_name"></param>
        /// <param name="first_direction"></param>
        /// <param name="first_street_count_to"></param>
        /// <param name="second_direction"></param>
        /// <param name="first_street_to"></param>
        /// <param name="second_street_to"></param>
        /// <param name="list"></param>
        internal void GenerateImmidiateTurn(int entryIdx, GeoCoordinateBox box,
            TagsCollection before_name, RelativeDirection first_direction, int first_street_count_to,
            RelativeDirection second_direction, TagsCollection first_street_to, TagsCollection second_street_to, List<PointPoi> list)
        {
            // create a new instruction first.
            Instruction instruction = new Instruction(entryIdx, box);

            // pass the instruction to the language generator.
            instruction = _generator.GenerateImmidiateTurn(
                instruction, first_street_count_to, first_street_to, first_direction, second_street_to, second_direction);

            // add the instruction to the instructions list.
            _instructions.Add(instruction);
        }
Пример #24
0
 /// <summary>
 /// Generates an instruction for an indirect turn.
 /// </summary>
 /// <param name="instruction"></param>
 /// <param name="streetCountTurn"></param>
 /// <param name="streetCountBeforeTurn"></param>
 /// <param name="street_to"></param>
 /// <param name="direction"></param>
 /// <param name="list"></param>
 /// <returns></returns>
 protected override string GenerateIndirectFollowTurn(int countBefore, TagsCollectionBase street, RelativeDirection direction, List<PointPoi> list)
 {
     countBefore++;
     if (countBefore == 1)
     {
         return string.Format("Draai {1} en blijf op de {0}.", this.GetName("nl", street), TurnDirection(direction));
     }
     else
     {
         return string.Format("Neem de {1}ste straat {2} en blijf op de {0}.", this.GetName("nl", street), countBefore, TurnDirection(direction));
     }
 }
Пример #25
0
 /// <summary>
 /// Generates an instruction for a turn followed by another turn.
 /// </summary>
 /// <param name="countBefore"></param>
 /// <param name="street"></param>
 /// <param name="direction"></param>
 /// <param name="pois"></param>
 /// <returns></returns>
 protected override string GenerateDirectFollowTurn(int countBefore, TagsCollectionBase street, RelativeDirection direction, List<PointPoi> pois)
 {
     return string.Format("Fahre {1}.", countBefore, TurnDirection(direction), this.GetName("de", street));
 }
Пример #26
0
 /// <summary>
 /// Generates an instruction for an indirect turn.
 /// </summary>
 /// <param name="countBefore"></param>
 /// <param name="street"></param>
 /// <param name="direction"></param>
 /// <param name="pois"></param>
 /// <returns></returns>
 protected abstract string GenerateIndirectTurn(int countBefore, TagsCollectionBase street, RelativeDirection direction, List<PointPoi> pois);
Пример #27
0
        /// <summary>
        /// Generates a poi instruction.
        /// </summary>
        /// <param name="entryIdx"></param>
        /// <param name="box"></param>
        /// <param name="list"></param>
        /// <param name="direction"></param>
        internal void GeneratePoi(int entryIdx, GeoCoordinateBox box, 
            List<PointPoi> list, RelativeDirection direction)
        {
            // create a new instruction first.
            Instruction instruction = new Instruction(entryIdx, box, list);
            Instruction direction_instruction = null;

            // pass the instruction to the languate generator.
            if (direction == null)
            {
                instruction = _generator.GeneratePoi(instruction, list, null);
            }
            else
            {
                // create a direction instruction.
                if (direction.Direction == RelativeDirectionEnum.TurnBack)
                {
                    direction_instruction = new Instruction(entryIdx, box, list);
                    direction_instruction = _generator.GenerateSimpleTurn(direction_instruction, direction.Direction);
                }

                // generates the instructions.
                instruction = _generator.GeneratePoi(instruction, list, null);
            }

            // add the instruction to the instructions list.
            _instructions.Add(instruction);

            // add the direction instruction.
            if (direction_instruction != null)
            {
                _instructions.Add(direction_instruction);
            }
        }
Пример #28
0
 /// <summary>
 /// Generates an instruction for a POI.
 /// </summary>
 /// <param name="direction"></param>
 /// <param name="pois"></param>
 /// <returns></returns>
 protected abstract string GeneratePOI(RelativeDirection direction, List<PointPoi> pois);
Пример #29
0
 /// <summary>
 /// Generates an immidiate turn.
 /// </summary>
 /// <param name="countBefore"></param>
 /// <param name="firstStreet"></param>
 /// <param name="firstDirection"></param>
 /// <param name="secondStreet"></param>
 /// <param name="secondDirection"></param>
 /// <param name="pois"></param>
 /// <returns></returns>
 protected override string GenerateImmidiateTurn(int countBefore, TagsCollectionBase firstStreet, RelativeDirection firstDirection, TagsCollectionBase secondStreet, RelativeDirection secondDirection, List<PointPoi> pois)
 {
     return string.Format("GenerateImmidiateTurn:{0}_{1}_{2}_{3}", countBefore, firstDirection, firstDirection.Direction.ToString(), secondDirection.Direction.ToString());
 }
Пример #30
0
 /// <summary>
 /// Generates an instruction for a simple turn.
 /// </summary>
 /// <param name="count"></param>
 /// <param name="direction"></param>
 /// <returns></returns>
 protected abstract string GenerateTurn(RelativeDirection direction);
Пример #31
0
 /// <summary>
 /// Generates an instruction for an indirect turn.
 /// </summary>
 /// <param name="instruction"></param>
 /// <param name="streetCountTurn"></param>
 /// <param name="streetCountBeforeTurn"></param>
 /// <param name="street_to"></param>
 /// <param name="direction"></param>
 /// <param name="list"></param>
 /// <returns></returns>
 protected override string GenerateIndirectFollowTurn(int countBefore, TagsCollectionBase street, RelativeDirection direction, List<PointPoi> list)
 {
     countBefore++;
     if (countBefore == 1)
     {
         return string.Format("Turn {1} to stay on {0}.", this.GetName("en", street), TurnDirection(direction));
     }
     else
     {
         return string.Format("Take the {1}d street {2} to stay on {0}.", this.GetName("en", street), countBefore, TurnDirection(direction));
     }
 }
Пример #32
0
        /// <summary>
        /// Generates a turn instruction.
        /// </summary>
        /// <param name="entryIdx"></param>
        /// <param name="box"></param>
        /// <param name="direction"></param>
        /// <param name="streetCountTurn"></param>
        /// <param name="streetCountBeforeTurn"></param>
        /// <param name="streetFrom"></param>
        /// <param name="streetTo"></param>
        /// <param name="list"></param>
        internal void GenerateTurn(int entryIdx, GeoCoordinateBox box,
            RelativeDirection direction, int streetCountTurn, int streetCountBeforeTurn,
            TagsCollection streetFrom, TagsCollection streetTo, List<PointPoi> list)
        {
            // create a new instruction first.
            Instruction instruction = new Instruction(entryIdx, box, list);

            // pass the instruction to the languate generator.
            // test if the street is the same but a turn needs to be taken anyway.
            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.
                    instruction = _generator.GenerateDirectFollowTurn(
                        instruction, streetCountBeforeTurn, streetTo, direction.Direction, list);
                }
                else
                { // there is another street; this is tricky to explain.
                    instruction = _generator.GenerateIndirectFollowTurn(
                        instruction, streetCountTurn, streetCountBeforeTurn, streetTo, direction.Direction, list);
                }
            }
            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.
                    instruction = _generator.GenerateDirectTurn(
                        instruction, streetCountBeforeTurn, streetTo, direction.Direction, list);
                }
                else
                { // there is another street; this is tricky to explain.
                    instruction = _generator.GenerateIndirectTurn(
                        instruction, streetCountTurn, streetCountBeforeTurn, streetTo, direction.Direction, list);
                }
            }

            // add the instruction to the instructions list.
            _instructions.Add(instruction);
        }
        /// <summary>
        /// Generates an instruction for an immidiate turn.
        /// </summary>
        /// <param name="instruction"></param>
        /// <param name="firstStreetCountTo"></param>
        /// <param name="first_street_to"></param>
        /// <param name="first_direction"></param>
        /// <param name="second_street_to"></param>
        /// <param name="second_direction"></param>
        /// <returns></returns>
        public Instruction GenerateImmidiateTurn(Instruction instruction, int firstStreetCountTo, 
            TagsCollectionBase first_street_to, RelativeDirection first_direction, 
            TagsCollectionBase second_street_to, RelativeDirection second_direction)
        {
            firstStreetCountTo++;
            if (firstStreetCountTo == 1)
            {
                instruction.Text = string.Format("Take the first turn {0}, on the {1}, and turn immidiately {2} on the {3}.",
                    TurnDirection(first_direction.Direction),
                    this.GetName("en",first_street_to),
                    TurnDirection(second_direction.Direction),
                    this.GetName("en",second_street_to));
            }
            else
            {
                instruction.Text = string.Format("Take the {4}d turn {0}, on the {1}, and turn immidiately {2} on the {3}.",
                    TurnDirection(first_direction.Direction),
                    this.GetName("en",first_street_to),
                    TurnDirection(second_direction.Direction),
                    this.GetName("en",second_street_to),
                    firstStreetCountTo);
            }

            // returns the instruction with text.
            return instruction;
        }
        /// <summary>
        /// Generates an instruction for an immidiate turn.
        /// </summary>
        /// <param name="instruction"></param>
        /// <param name="first_street_count_to"></param>
        /// <param name="first_street_to"></param>
        /// <param name="first_direction"></param>
        /// <param name="second_street_to"></param>
        /// <param name="second_direction"></param>
        /// <returns></returns>
        public Instruction GenerateImmidiateTurn(Instruction instruction, int first_street_count_to, TagsCollectionBase first_street_to,
            RelativeDirection first_direction, TagsCollectionBase second_street_to, RelativeDirection second_direction)
        {
            //            if (first_street_count_to == 1)
            //            {
            //                instruction.Text = string.Format("Neem de 1ste afslag {0}, de {1} op, en ga onmiddellijk {2} op de {3}.",
            //                    TurnDirection(first_direction.Direction),
            //                    this.GetName("nl", first_street_to),
            //                    TurnDirection(second_direction.Direction),
            //                    this.GetName("nl", second_street_to));
            //            }
            //            else
            //            {
            //                instruction.Text = string.Format("Neem de {4}de afslag {0}, de {1} op, en ga onmiddellijk {2} op de {3}.",
            //                    TurnDirection(first_direction.Direction),
            //                    this.GetName("nl", first_street_to),
            //                    TurnDirection(second_direction.Direction),
            //                    this.GetName("nl", second_street_to),
            //                    first_street_count_to);
            //            }
            instruction.Text = string.Format ("Draai {0} en daarna direct {1}",
                                              TurnDirection(first_direction.Direction),
                                              TurnDirection(second_direction.Direction));

            // returns the instruction with text.
            return instruction;
        }