Esempio n. 1
0
        public void TestSideOfRoadFrcFow()
        {
            var data = new byte[1];

            data[0] = 0;

            // sideofroad-frc-fow.
            SideOfRoadConverter.Encode(SideOfRoad.Left, data, 0, 0);
            FunctionalRoadClassConvertor.Encode(FunctionalRoadClass.Frc3, data, 0, 2);
            FormOfWayConvertor.Encode(FormOfWay.Roundabout, data, 0, 5);
            Assert.AreEqual(156, data[0]);

            // frc-sideofroad-fow.
            data[0] = 0;
            FunctionalRoadClassConvertor.Encode(FunctionalRoadClass.Frc3, data, 0, 2);
            SideOfRoadConverter.Encode(SideOfRoad.Left, data, 0, 0);
            FormOfWayConvertor.Encode(FormOfWay.Roundabout, data, 0, 5);
            Assert.AreEqual(156, data[0]);

            // frc-fow-sideofroad.
            data[0] = 0;
            FunctionalRoadClassConvertor.Encode(FunctionalRoadClass.Frc3, data, 0, 2);
            FormOfWayConvertor.Encode(FormOfWay.Roundabout, data, 0, 5);
            SideOfRoadConverter.Encode(SideOfRoad.Left, data, 0, 0);
            Assert.AreEqual(156, data[0]);
        }
Esempio n. 2
0
        /// <summary>
        /// Encodes a point along line location.
        /// </summary>
        public static byte[] Encode(PointAlongLineLocation location)
        {
            var data = new byte[17];

            var header = new Header();

            header.Version       = 3;
            header.HasAttributes = true;
            header.ArF0          = false;
            header.IsPoint       = true;
            header.ArF1          = false;
            HeaderConvertor.Encode(data, 0, header);
            CoordinateConverter.Encode(location.First.Coordinate, data, 1);
            FunctionalRoadClassConvertor.Encode(location.First.FuntionalRoadClass.Value, data, 7, 2);
            FormOfWayConvertor.Encode(location.First.FormOfWay.Value, data, 7, 5);
            FunctionalRoadClassConvertor.Encode(location.First.LowestFunctionalRoadClassToNext.Value, data, 8, 0);
            BearingConvertor.Encode(BearingConvertor.EncodeAngleToBearing(location.First.Bearing.Value), data, 8, 3);
            data[9] = DistanceToNextConvertor.Encode(location.First.DistanceToNext);

            CoordinateConverter.EncodeRelative(location.First.Coordinate, location.Last.Coordinate, data, 10);
            FunctionalRoadClassConvertor.Encode(location.Last.FuntionalRoadClass.Value, data, 14, 2);
            FormOfWayConvertor.Encode(location.Last.FormOfWay.Value, data, 14, 5);
            BearingConvertor.Encode(BearingConvertor.EncodeAngleToBearing(location.Last.Bearing.Value), data, 15, 3);

            OrientationConverter.Encode(location.Orientation.Value, data, 7, 0);
            SideOfRoadConverter.Encode(location.SideOfRoad.Value, data, 14, 0);
            if (location.PositiveOffsetPercentage.HasValue)
            { // positive offset percentage is present.
                OffsetConvertor.Encode(location.PositiveOffsetPercentage.Value, data, 16);
            }

            return(data);
        }
Esempio n. 3
0
        /// <summary>
        /// Decodes the given data into a location reference.
        /// </summary>
        public static PointAlongLineLocation Decode(byte[] data)
        {
            var pointAlongLine = new PointAlongLineLocation();

            // decode first location reference point.
            var first = new LocationReferencePoint();

            first.Coordinate         = CoordinateConverter.Decode(data, 1);
            first.FuntionalRoadClass = FunctionalRoadClassConvertor.Decode(data, 7, 2);
            first.FormOfWay          = FormOfWayConvertor.Decode(data, 7, 5);
            first.LowestFunctionalRoadClassToNext = FunctionalRoadClassConvertor.Decode(data, 8, 0);
            first.Bearing        = BearingConvertor.DecodeAngleFromBearing(BearingConvertor.Decode(data, 8, 3));
            first.DistanceToNext = DistanceToNextConvertor.Decode(data[9]);

            // decode second location reference point.
            var last = new LocationReferencePoint();

            last.Coordinate         = CoordinateConverter.DecodeRelative(first.Coordinate, data, 10);
            last.FuntionalRoadClass = FunctionalRoadClassConvertor.Decode(data, 14, 2);
            last.FormOfWay          = FormOfWayConvertor.Decode(data, 14, 5);
            last.Bearing            = BearingConvertor.DecodeAngleFromBearing(BearingConvertor.Decode(data, 15, 3));

            pointAlongLine.First       = first;
            pointAlongLine.Orientation = OrientationConverter.Decode(data, 7, 0);
            pointAlongLine.SideOfRoad  = SideOfRoadConverter.Decode(data, 14, 0);
            pointAlongLine.PositiveOffsetPercentage = OffsetConvertor.Decode(data, 16);
            pointAlongLine.Last = last;

            return(pointAlongLine);
        }
Esempio n. 4
0
        public void TestDecoding1()
        {
            Assert.Catch <ArgumentOutOfRangeException>(() =>
            {
                SideOfRoadConverter.Decode(new byte[] { 0 }, 10);
            });

            Assert.AreEqual(SideOfRoad.OnOrAbove, SideOfRoadConverter.Decode(new byte[] { 0 }, 0, 0));
            Assert.AreEqual(SideOfRoad.Right, SideOfRoadConverter.Decode(new byte[] { 1 }, 0, 6));
            Assert.AreEqual(SideOfRoad.Left, SideOfRoadConverter.Decode(new byte[] { 2 }, 0, 6));
            Assert.AreEqual(SideOfRoad.Both, SideOfRoadConverter.Decode(new byte[] { 3 }, 0, 6));
        }
Esempio n. 5
0
        public void TestEncoding1()
        {
            var data = new byte[1];

            Assert.Catch <ArgumentOutOfRangeException>(() =>
            {
                SideOfRoadConverter.Encode(SideOfRoad.OnOrAbove, data, 0, 10);
            });

            SideOfRoadConverter.Encode(SideOfRoad.OnOrAbove, data, 0, 6);
            Assert.AreEqual(0, data[0]);
            SideOfRoadConverter.Encode(SideOfRoad.Right, data, 0, 6);
            Assert.AreEqual(1, data[0]);
            SideOfRoadConverter.Encode(SideOfRoad.Left, data, 0, 6);
            Assert.AreEqual(2, data[0]);
            SideOfRoadConverter.Encode(SideOfRoad.Both, data, 0, 6);
            Assert.AreEqual(3, data[0]);
        }
Esempio n. 6
0
        /// <summary>
        /// Decodes the given data into a location reference.
        /// </summary>
        public static PoiWithAccessPointLocation Decode(byte[] data)
        {
            // decode first location reference point.
            var first = new LocationReferencePoint();

            first.Coordinate = CoordinateConverter.Decode(data, 1);
            var orientation = OrientationConverter.Decode(data, 7, 0);

            first.FuntionalRoadClass = FunctionalRoadClassConvertor.Decode(data, 7, 2);
            first.FormOfWay          = FormOfWayConvertor.Decode(data, 7, 5);
            first.LowestFunctionalRoadClassToNext = FunctionalRoadClassConvertor.Decode(data, 8, 0);
            first.Bearing        = BearingConvertor.DecodeAngleFromBearing(BearingConvertor.Decode(data, 8, 3));
            first.DistanceToNext = DistanceToNextConvertor.Decode(data[9]);

            // decode last location reference point.
            var last = new LocationReferencePoint();

            // no last coordinates, identical to the first.
            last.Coordinate = CoordinateConverter.DecodeRelative(first.Coordinate, data, 10);
            var sideOfRoad = SideOfRoadConverter.Decode(data, 14, 0);

            last.FuntionalRoadClass = FunctionalRoadClassConvertor.Decode(data, 14, 2);
            last.FormOfWay          = FormOfWayConvertor.Decode(data, 14, 5);
            last.Bearing            = BearingConvertor.DecodeAngleFromBearing(BearingConvertor.Decode(data, 15, 3));

            // poi details.
            var coordinate = CoordinateConverter.DecodeRelative(first.Coordinate, data, 17);

            // create line location.
            var poiWithAccessPointLocation = new PoiWithAccessPointLocation();

            poiWithAccessPointLocation.First          = first;
            poiWithAccessPointLocation.Last           = last;
            poiWithAccessPointLocation.Coordinate     = coordinate;
            poiWithAccessPointLocation.Orientation    = orientation;
            poiWithAccessPointLocation.PositiveOffset = null;
            poiWithAccessPointLocation.SideOfRoad     = sideOfRoad;
            return(poiWithAccessPointLocation);
        }