//-------------------------------------------------------------------------
/// <returns>True if at least one island is found, false otherwise.</returns>
protected bool CalculateIslandStartingPoints(bool[] binaryImage, int binaryImageWidth, int binaryImageHeight, ref int[] reusedIslandClassificationImage, ref List <IslandDetector.Region> islands, ref List <IslandDetector.Region> seaRegions)
{
mIslandDetector = new IslandDetector();
mIslandDetector.DetectIslandsFromBinaryImage(binaryImage, binaryImageWidth, binaryImageHeight, ref reusedIslandClassificationImage, ref islands, ref seaRegions);
return(islands.Count > 0);
}
public void TestTwoDistinctEdges()
{
// build routerdb.
var routerDb = new RouterDb();
routerDb.Network.AddVertex(0, 0, 0);
routerDb.Network.AddVertex(1, 1, 1);
routerDb.Network.AddEdge(0, 1, new Itinero.Data.Network.Edges.EdgeData()
{
Distance = 100,
Profile = 1
}, null);
routerDb.Network.AddVertex(2, 0, 0);
routerDb.Network.AddVertex(3, 1, 1);
routerDb.Network.AddEdge(2, 3, new Itinero.Data.Network.Edges.EdgeData()
{
Distance = 100,
Profile = 1
}, null);
// build speed profile function.
var speed = 100f / 3.6f;
Func <ushort, Itinero.Profiles.Factor> getFactor = (x) =>
{
return(new Itinero.Profiles.Factor()
{
Direction = 0,
Value = 1.0f / speed
});
};
// start island detector.
var islandDetector = new IslandDetector(routerDb, new Func <ushort, Itinero.Profiles.Factor>[] { getFactor });
islandDetector.Run();
// verify the islands.
var islands = islandDetector.Islands;
Assert.IsNotNull(islands);
Assert.AreEqual(4, islands.Length);
Assert.AreEqual(0, islands[0]);
Assert.AreEqual(0, islands[1]);
Assert.AreEqual(1, islands[2]);
Assert.AreEqual(1, islands[3]);
var islandSizes = islandDetector.IslandSizes;
Assert.AreEqual(2, islandSizes.Count);
uint size;
Assert.IsTrue(islandSizes.TryGetValue(0, out size));
Assert.AreEqual(2, size);
Assert.IsTrue(islandSizes.TryGetValue(1, out size));
Assert.AreEqual(2, size);
}
//-------------------------------------------------------------------------
/// <returns>True if at least one island is found, false otherwise.</returns>
protected bool CalculateIslandStartingPoints(bool[,] binaryImage, out IslandDetector.Region[] islands, out IslandDetector.Region[] seaRegions)
{
int[,] islandClassificationImage = null;
islands = null;
seaRegions = null;
mIslandDetector = new IslandDetector();
mIslandDetector.DetectIslandsFromBinaryImage(binaryImage, out islandClassificationImage, out islands, out seaRegions);
return(islands.Length > 0);
}
public void TestSingleVertexRestrictionHandling()
{
// build and load network.
var routerDb = new RouterDb();
routerDb.LoadTestNetwork(
System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream(
"Itinero.Test.test_data.networks.network18.geojson"));
var profile = Itinero.Osm.Vehicles.Vehicle.Car.Fastest();
Func <ushort, Itinero.Profiles.Factor> getFactor = (x) =>
{
var attributes = routerDb.EdgeProfiles.Get(x);
var factorAndSpeed = profile.FactorAndSpeed(attributes);
return(new Itinero.Profiles.Factor()
{
Direction = factorAndSpeed.Direction,
Value = factorAndSpeed.Value
});
};
// start island detector.
var islandDetector = new IslandDetector(routerDb, new Func <ushort, Itinero.Profiles.Factor>[] { getFactor },
routerDb.GetRestrictions(Itinero.Osm.Vehicles.Vehicle.Car.Fastest()));
islandDetector.Run();
// verify the islands.
var islands = islandDetector.Islands;
Assert.IsNotNull(islands);
Assert.AreEqual(10, islands.Length);
Assert.AreEqual(0, islands[0]);
Assert.AreEqual(1, islands[1]);
Assert.AreEqual(0, islands[2]);
Assert.AreEqual(IslandDetector.RESTRICTED, islands[3]);
Assert.AreEqual(0, islands[4]);
Assert.AreEqual(0, islands[5]);
Assert.AreEqual(0, islands[6]);
Assert.AreEqual(0, islands[7]);
Assert.AreEqual(1, islands[8]);
Assert.AreEqual(1, islands[9]);
}
//-------------------------------------------------------------------------
public static void SetupColliderRegionParameters(ref ColliderRegionParameters[] colliderRegionParameters, int defaultMaxPointCount,
IslandDetector.Region[] islands, IslandDetector.Region[] seaRegions) {
int numColliderRegions = islands.Length + seaRegions.Length;
bool shallResetRegionParameters = (colliderRegionParameters == null || numColliderRegions != colliderRegionParameters.Length); // TODO!! check when to throw parameters away!
if (shallResetRegionParameters) {
colliderRegionParameters = new ColliderRegionParameters[numColliderRegions];
int colliderRegionIndex = 0;
// Note: We enable the first island region only. All other island- and all sea-regions are initially disabled.
for (int islandIndex = 0; islandIndex < islands.Length; ++islandIndex) {
ColliderRegionParameters newParameters = new ColliderRegionParameters();
if (islandIndex == 0) {
newParameters.EnableRegion = true;
}
else {
newParameters.EnableRegion = false;
}
newParameters.MaxPointCount = defaultMaxPointCount;
colliderRegionParameters[colliderRegionIndex++] = newParameters;
}
for (int seaRegionIndex = 0; seaRegionIndex < seaRegions.Length; ++seaRegionIndex) {
ColliderRegionParameters newParameters = new ColliderRegionParameters();
newParameters.EnableRegion = false;
newParameters.MaxPointCount = defaultMaxPointCount;
colliderRegionParameters[colliderRegionIndex++] = newParameters;
}
}
else {
for (int count = 0; count < colliderRegionParameters.Length; ++count) {
colliderRegionParameters[count].RegionUpdateCalculationNeeded = true;
}
}
}
//-------------------------------------------------------------------------
public static void SetupColliderRegions(out ColliderRegionData[] colliderRegions, IslandDetector.Region[] islands, IslandDetector.Region[] seaRegions) {
int numColliderRegions = islands.Length + seaRegions.Length;
colliderRegions = new ColliderRegionData[numColliderRegions];
int colliderRegionIndex = 0;
foreach (IslandDetector.Region islandRegion in islands) {
ColliderRegionData newRegion = new ColliderRegionData();
newRegion.mDetectedRegion = islandRegion;
newRegion.mRegionIsIsland = true;
colliderRegions[colliderRegionIndex++] = newRegion;
}
foreach (IslandDetector.Region seaRegion in seaRegions) {
ColliderRegionData newRegion = new ColliderRegionData();
newRegion.mDetectedRegion = seaRegion;
newRegion.mRegionIsIsland = false;
colliderRegions[colliderRegionIndex++] = newRegion;
}
}
//-------------------------------------------------------------------------
/// <returns>True if at least one island is found, false otherwise.</returns>
bool CalculateIslandStartingPoints(bool [,] binaryImage, out IslandDetector.Region[] islands, out IslandDetector.Region[] seaRegions) {
int[,] islandClassificationImage = null;
islands = null;
seaRegions = null;
mIslandDetector = new IslandDetector();
mIslandDetector.DetectIslandsFromBinaryImage(binaryImage, out islandClassificationImage, out islands, out seaRegions);
return (islands.Length > 0);
}
//-------------------------------------------------------------------------
bool CalculateOutlineForColliderIslands(out List<List<Vector2> > outlineVerticesAtIsland, IslandDetector.Region[] islands, bool [,] binaryImage) {
outlineVerticesAtIsland = new List<List<Vector2> >();
for (int islandIndex = 0; islandIndex < islands.Length; ++islandIndex) {
IslandDetector.Region island = islands[islandIndex];
if (islandIndex >= mMaxNumberOfIslands || island.mPointCount < mMinPixelCountToIncludeIsland) {
break; // islands are sorted by size already, only smaller islands follow.
}
else {
List<Vector2> unreducedOutlineVertices;
mOutlineAlgorithm.UnreducedOutlineFromBinaryImage(out unreducedOutlineVertices, binaryImage, island.mPointAtBorder, true, mOutputColliderInNormalizedSpace, true);
List<Vector2> reducedVertices = mOutlineAlgorithm.ReduceOutline(unreducedOutlineVertices, true);
outlineVerticesAtIsland.Add(reducedVertices);
}
}
return outlineVerticesAtIsland.Count > 0;
}
public void TestOnewayDeadend()
{
// build routerdb.
var routerDb = new RouterDb();
routerDb.Network.AddVertex(0, 0, 0);
routerDb.Network.AddVertex(1, 1, 1);
routerDb.Network.AddVertex(2, 2, 2);
routerDb.Network.AddEdge(0, 1, new Itinero.Data.Network.Edges.EdgeData()
{
Distance = 100,
Profile = 1
}, null);
routerDb.Network.AddEdge(1, 2, new Itinero.Data.Network.Edges.EdgeData()
{
Distance = 100,
Profile = 2
}, null);
// build speed profile function.
var speed = 100f / 3.6f;
Func <ushort, Itinero.Profiles.Factor> getFactor = (x) =>
{
if (x == 1)
{
return(new Itinero.Profiles.Factor()
{
Direction = 0,
Value = 1.0f / speed
});
}
else
{
return(new Itinero.Profiles.Factor()
{
Direction = 1,
Value = 1.0f / speed
});
}
};
// start island detector.
var islandDetector = new IslandDetector(routerDb, new Func <ushort, Itinero.Profiles.Factor>[] { getFactor });
islandDetector.Run();
// verify the islands.
var islands = islandDetector.Islands;
Assert.IsNotNull(islands);
Assert.AreEqual(3, islands.Length);
Assert.AreEqual(0, islands[0]);
Assert.AreEqual(0, islands[1]);
Assert.AreEqual(IslandDetector.SINGLETON_ISLAND, islands[2]);
var islandSizes = islandDetector.IslandSizes;
Assert.AreEqual(1, islandSizes.Count);
uint size;
Assert.IsTrue(islandSizes.TryGetValue(0, out size));
Assert.AreEqual(2, size);
// make oneway go the other direction.
getFactor = (x) =>
{
if (x == 1)
{
return(new Itinero.Profiles.Factor()
{
Direction = 0,
Value = 1.0f / speed
});
}
else
{
return(new Itinero.Profiles.Factor()
{
Direction = 2,
Value = 1.0f / speed
});
}
};
// start island detector.
islandDetector = new IslandDetector(routerDb, new Func <ushort, Itinero.Profiles.Factor>[] { getFactor });
islandDetector.Run();
// verify the islands.
islands = islandDetector.Islands;
Assert.IsNotNull(islands);
Assert.AreEqual(3, islands.Length);
Assert.AreEqual(0, islands[0]);
Assert.AreEqual(0, islands[1]);
Assert.AreEqual(IslandDetector.SINGLETON_ISLAND, islands[2]);
islandSizes = islandDetector.IslandSizes;
Assert.AreEqual(1, islandSizes.Count);
Assert.IsTrue(islandSizes.TryGetValue(0, out size));
Assert.AreEqual(2, size);
}
public void TestDifferentSizesAndSingletons()
{
// build routerdb.
var routerDb = new RouterDb();
// ISLAND1: 4 vertices.
routerDb.Network.AddVertex(0, 0, 0);
routerDb.Network.AddVertex(1, 0, 0);
routerDb.Network.AddVertex(2, 0, 0);
routerDb.Network.AddVertex(3, 0, 0);
routerDb.Network.AddEdge(0, 1, new Itinero.Data.Network.Edges.EdgeData()
{
Distance = 100,
Profile = 1
}, null);
routerDb.Network.AddEdge(1, 2, new Itinero.Data.Network.Edges.EdgeData()
{
Distance = 100,
Profile = 1
}, null);
routerDb.Network.AddEdge(2, 3, new Itinero.Data.Network.Edges.EdgeData()
{
Distance = 100,
Profile = 1
}, null);
// ISLAND2: 2 vertices.
routerDb.Network.AddVertex(4, 0, 0);
routerDb.Network.AddVertex(5, 0, 0);
routerDb.Network.AddEdge(4, 5, new Itinero.Data.Network.Edges.EdgeData()
{
Distance = 100,
Profile = 1
}, null);
// ISLAND3: singleton
routerDb.Network.AddVertex(6, 0, 0);
// build speed profile function.
var speed = 100f / 3.6f;
Func <ushort, Itinero.Profiles.Factor> getFactor = (x) =>
{
return(new Itinero.Profiles.Factor()
{
Direction = 0,
Value = 1.0f / speed
});
};
// start island detector.
var islandDetector = new IslandDetector(routerDb, new Func <ushort, Itinero.Profiles.Factor>[] { getFactor });
islandDetector.Run();
// verify the islands.
var islands = islandDetector.Islands;
Assert.IsNotNull(islands);
Assert.AreEqual(7, islands.Length);
Assert.AreEqual(0, islands[0]);
Assert.AreEqual(0, islands[1]);
Assert.AreEqual(0, islands[2]);
Assert.AreEqual(0, islands[3]);
Assert.AreEqual(1, islands[4]);
Assert.AreEqual(1, islands[5]);
Assert.AreEqual(IslandDetector.SINGLETON_ISLAND, islands[6]);
var islandSizes = islandDetector.IslandSizes;
Assert.AreEqual(2, islandSizes.Count);
uint size;
Assert.IsTrue(islandSizes.TryGetValue(0, out size));
Assert.AreEqual(4, size);
Assert.IsTrue(islandSizes.TryGetValue(1, out size));
Assert.AreEqual(2, size);
}
//-------------------------------------------------------------------------
public static void SetupColliderRegionParameters(ref ColliderRegionParameters[] islandRegionParameters, ref ColliderRegionParameters[] seaRegionParameters,
int defaultMaxPointCount,
IslandDetector.Region[] islands, IslandDetector.Region[] seaRegions) {
// Islands
int oldIslandRegionParametersLength = 0;
if (islandRegionParameters == null) {
islandRegionParameters = new ColliderRegionParameters[islands.Length];
}
else {
oldIslandRegionParametersLength = islandRegionParameters.Length;
if (islands.Length > oldIslandRegionParametersLength) {
System.Array.Resize(ref islandRegionParameters, islands.Length);
}
}
// set RegionUpdateCalculationNeeded at old entries
for (int existingIndex = 0; existingIndex < oldIslandRegionParametersLength; ++existingIndex) {
islandRegionParameters[existingIndex].RegionUpdateCalculationNeeded = true;
}
// add new ColliderRegionParameters at new ones
for (int newIndex = oldIslandRegionParametersLength; newIndex < islands.Length; ++newIndex) {
// Note: We enable the first island region only. All other island- and all sea-regions are initially disabled.
ColliderRegionParameters newParameters = new ColliderRegionParameters();
if (newIndex == 0) {
newParameters.EnableRegion = true;
}
else {
newParameters.EnableRegion = false;
}
newParameters.MaxPointCount = defaultMaxPointCount;
islandRegionParameters[newIndex] = newParameters;
}
// Sea regions
int oldSeaRegionParametersLength = 0;
if (seaRegionParameters == null) {
seaRegionParameters = new ColliderRegionParameters[seaRegions.Length];
}
else {
oldSeaRegionParametersLength = seaRegionParameters.Length;
if (seaRegions.Length > oldSeaRegionParametersLength) {
System.Array.Resize(ref seaRegionParameters, seaRegions.Length);
}
}
// set RegionUpdateCalculationNeeded at old entries
for (int existingIndex = 0; existingIndex < oldSeaRegionParametersLength; ++existingIndex) {
seaRegionParameters[existingIndex].RegionUpdateCalculationNeeded = true;
}
// add new ColliderRegionParameters at new ones
for (int seaRegionIndex = oldSeaRegionParametersLength; seaRegionIndex < seaRegions.Length; ++seaRegionIndex) {
ColliderRegionParameters newParameters = new ColliderRegionParameters();
newParameters.EnableRegion = false;
newParameters.MaxPointCount = defaultMaxPointCount;
seaRegionParameters[seaRegionIndex] = newParameters;
}
}
public void Initialize()
{
_sut = new IslandDetector();
}