/// <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);
}
/// <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);
}
public void TestEncoding1()
{
var data = new byte[1];
data[0] = 0;
OffsetConvertor.Encode(25, data, 0);
Assert.AreEqual(64, data[0]);
data[0] = 0;
OffsetConvertor.Encode(50, data, 0);
Assert.AreEqual(128, data[0]);
data[0] = 0;
OffsetConvertor.Encode(75, data, 0);
Assert.AreEqual(192, data[0]);
// regression-tests from actual data.
// 60 [23.44% - 23.83%]
data[0] = 0;
OffsetConvertor.Encode(23.8f, data, 0);
Assert.AreEqual(60, data[0]);
data[0] = 0;
OffsetConvertor.Encode(23.5f, data, 0);
Assert.AreEqual(60, data[0]);
// 185 [72.27% - 72.66%]
data[0] = 0;
OffsetConvertor.Encode(72.2f, data, 0);
Assert.AreEqual(184, data[0]);
data[0] = 0;
OffsetConvertor.Encode(72.3f, data, 0);
Assert.AreEqual(185, data[0]);
data[0] = 0;
OffsetConvertor.Encode(72.6f, data, 0);
Assert.AreEqual(185, data[0]);
data[0] = 0;
OffsetConvertor.Encode(72.7f, data, 0);
Assert.AreEqual(186, data[0]);
data[0] = 0;
Assert.Catch <ArgumentOutOfRangeException>(() =>
{
OffsetConvertor.Encode(-1, data, 0);
});
Assert.Catch <ArgumentOutOfRangeException>(() =>
{
OffsetConvertor.Encode(101, data, 0);
});
Assert.Catch <ArgumentOutOfRangeException>(() =>
{
OffsetConvertor.Encode(100, data, 0);
});
}
public void TestDecodingFlag1()
{
Assert.Catch <ArgumentOutOfRangeException>(() =>
{
OffsetConvertor.DecodeFlag(new byte[] { 0 }, 0, 8);
});
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 1 }, 0, 0));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 1 }, 0, 1));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 1 }, 0, 2));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 1 }, 0, 3));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 1 }, 0, 4));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 1 }, 0, 5));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 1 }, 0, 6));
Assert.True(OffsetConvertor.DecodeFlag(new byte[] { 1 }, 0, 7));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 2 }, 0, 0));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 2 }, 0, 1));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 2 }, 0, 2));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 2 }, 0, 3));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 2 }, 0, 4));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 2 }, 0, 5));
Assert.IsTrue(OffsetConvertor.DecodeFlag(new byte[] { 2 }, 0, 6));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 2 }, 0, 7));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 4 }, 0, 0));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 4 }, 0, 1));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 4 }, 0, 2));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 4 }, 0, 3));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 4 }, 0, 4));
Assert.IsTrue(OffsetConvertor.DecodeFlag(new byte[] { 4 }, 0, 5));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 4 }, 0, 6));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 4 }, 0, 7));
Assert.IsTrue(OffsetConvertor.DecodeFlag(new byte[] { 128 }, 0, 0));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 128 }, 0, 1));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 128 }, 0, 2));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 128 }, 0, 3));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 128 }, 0, 4));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 128 }, 0, 5));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 128 }, 0, 6));
Assert.IsFalse(OffsetConvertor.DecodeFlag(new byte[] { 128 }, 0, 7));
}
public void TestEncodingFlag1()
{
var data = new byte[1];
data[0] = 0;
Assert.Catch <ArgumentOutOfRangeException>(() =>
{
OffsetConvertor.EncodeFlag(false, data, 0, 8);
});
data[0] = 0;
OffsetConvertor.EncodeFlag(true, data, 0, 0);
Assert.AreEqual(128, data[0]);
data[0] = 0;
OffsetConvertor.EncodeFlag(true, data, 0, 1);
Assert.AreEqual(64, data[0]);
data[0] = 0;
OffsetConvertor.EncodeFlag(true, data, 0, 2);
Assert.AreEqual(32, data[0]);
data[0] = 0;
OffsetConvertor.EncodeFlag(true, data, 0, 3);
Assert.AreEqual(16, data[0]);
data[0] = 0;
OffsetConvertor.EncodeFlag(true, data, 0, 4);
Assert.AreEqual(8, data[0]);
data[0] = 0;
OffsetConvertor.EncodeFlag(true, data, 0, 5);
Assert.AreEqual(4, data[0]);
data[0] = 0;
OffsetConvertor.EncodeFlag(true, data, 0, 6);
Assert.AreEqual(2, data[0]);
data[0] = 0;
OffsetConvertor.EncodeFlag(true, data, 0, 7);
Assert.AreEqual(1, data[0]);
}
public void TestPOffNOffBearing()
{
var data = new byte[1];
data[0] = 0;
// poff-noff-bearing.
OffsetConvertor.EncodeFlag(true, data, 0, 1);
OffsetConvertor.EncodeFlag(true, data, 0, 2);
BearingConvertor.Encode(17, data, 0, 3);
Assert.AreEqual(113, data[0]);
// poff-bearing-noff.
OffsetConvertor.EncodeFlag(true, data, 0, 1);
BearingConvertor.Encode(17, data, 0, 3);
OffsetConvertor.EncodeFlag(true, data, 0, 2);
Assert.AreEqual(113, data[0]);
// bearing-poff-noff.
BearingConvertor.Encode(17, data, 0, 3);
OffsetConvertor.EncodeFlag(true, data, 0, 1);
OffsetConvertor.EncodeFlag(true, data, 0, 2);
Assert.AreEqual(113, data[0]);
}
/// <summary>
/// Decodes the given data into a location reference.
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
protected override LineLocation Decode(byte[] data)
{
// 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]);
// calculate the intermediate points count.
var intermediateList = new List <LocationReferencePoint>();
int intermediates = (data.Length - 16) / 7;
int location = 10;
var reference = first.Coordinate; // the reference for the relative coordinates.
for (int idx = 0; idx < intermediates; idx++)
{
// create an intermediate point.
var intermediate = new LocationReferencePoint();
intermediate.Coordinate = CoordinateConverter.DecodeRelative(reference, data, location);
reference = intermediate.Coordinate;
location = location + 4;
intermediate.FuntionalRoadClass = FunctionalRoadClassConvertor.Decode(data, location, 2);
intermediate.FormOfWay = FormOfWayConvertor.Decode(data, location, 5);
location = location + 1;
intermediate.Bearing = BearingConvertor.DecodeAngleFromBearing(BearingConvertor.Decode(data, location, 3));
intermediate.LowestFunctionalRoadClassToNext = FunctionalRoadClassConvertor.Decode(data, location, 0);
location = location + 1;
intermediate.DistanceToNext = DistanceToNextConvertor.Decode(data[location]);
location = location + 1;
intermediateList.Add(intermediate);
}
// decode last location reference point.
var last = new LocationReferencePoint();
last.Coordinate = CoordinateConverter.DecodeRelative(reference, data, location);
location = location + 4;
last.FuntionalRoadClass = FunctionalRoadClassConvertor.Decode(data, location, 2);
last.FormOfWay = FormOfWayConvertor.Decode(data, location, 5);
location = location + 1;
last.Bearing = BearingConvertor.DecodeAngleFromBearing(BearingConvertor.Decode(data, location, 3));
location = location + 1;
// create line location.
var lineLocation = new LineLocation();
if (location < data.Length)
{ // if present.
lineLocation.PositiveOffsetPercentage = OffsetConvertor.Decode(data, location);
location = location + 1;
}
if (location < data.Length)
{ // if present.
lineLocation.NegativeOffsetPercentage = OffsetConvertor.Decode(data, location);
location = location + 1;
}
lineLocation.First = first;
lineLocation.Intermediate = intermediateList.ToArray();
lineLocation.Last = last;
return(lineLocation);
}
/// <summary>
/// Encodes a point along line location.
/// </summary>
/// <param name="location"></param>
/// <returns></returns>
protected override byte[] EncodeByteArray(LineLocation location)
{
int size = 18;
if (location.Intermediate != null)
{ // each intermediate adds 7 bytes.
size = size + (location.Intermediate.Length * 7);
}
byte[] data = new byte[size];
var header = new Header();
header.Version = 3;
header.HasAttributes = true;
header.ArF0 = false;
header.IsPoint = false;
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);
// calculate the intermediate points count.
var position = 10;
var reference = location.First.Coordinate;
if (location.Intermediate != null)
{
for (int idx = 0; idx < location.Intermediate.Length; idx++)
{ // create an intermediate point.
var intermediate = location.Intermediate[idx];
CoordinateConverter.EncodeRelative(location.First.Coordinate, intermediate.Coordinate, data, position);
reference = intermediate.Coordinate;
position = position + 4;
FunctionalRoadClassConvertor.Encode(intermediate.FuntionalRoadClass.Value, data, position, 2);
FormOfWayConvertor.Encode(intermediate.FormOfWay.Value, data, position, 5);
position = position + 1;
BearingConvertor.Encode(BearingConvertor.EncodeAngleToBearing(intermediate.Bearing.Value), data, position, 3);
FunctionalRoadClassConvertor.Encode(intermediate.LowestFunctionalRoadClassToNext.Value, data, position, 0);
position = position + 1;
data[position] = DistanceToNextConvertor.Encode(intermediate.DistanceToNext);
position = position + 1;
}
}
CoordinateConverter.EncodeRelative(reference, location.Last.Coordinate, data, position);
FunctionalRoadClassConvertor.Encode(location.Last.FuntionalRoadClass.Value, data, position + 4, 2);
FormOfWayConvertor.Encode(location.Last.FormOfWay.Value, data, position + 4, 5);
BearingConvertor.Encode(BearingConvertor.EncodeAngleToBearing(location.Last.Bearing.Value), data, position + 5, 3);
if (location.PositiveOffsetPercentage.HasValue)
{ // positive offset percentage is present.
OffsetConvertor.EncodeFlag(true, data, position + 5, 1);
OffsetConvertor.Encode(location.PositiveOffsetPercentage.Value, data, position + 6);
}
if (location.NegativeOffsetPercentage.HasValue)
{ // positive offset percentage is present.
OffsetConvertor.EncodeFlag(true, data, position + 5, 2);
OffsetConvertor.Encode(location.NegativeOffsetPercentage.Value, data, position + 7);
}
return(data);
}
