public void CanExecuteContainerLineNearTileBoundary()
{
IFeatureClass featureClass =
CreatePolylineFeatureClass("CanExecuteContainerLineNearTileBoundary", 0.01);
// Create error Feature
const double x = 2600000;
const double y = 1200000;
IFeature row1 = featureClass.CreateFeature();
row1.Shape = GeometryFactory.CreateLine(
GeometryFactory.CreatePoint(x, y),
GeometryFactory.CreatePoint(x, y + 800));
row1.Store();
IFeature row2 = featureClass.CreateFeature();
row2.Shape = GeometryFactory.CreateLine(
GeometryFactory.CreatePoint(x + 1000, y),
GeometryFactory.CreatePoint(x + 1000, y + 800));
row2.Store();
// row3 is within tile[0,0], but within the search tolerance from tile[0,1]
IFeature row3 = featureClass.CreateFeature();
row3.Shape = GeometryFactory.CreateLine(
GeometryFactory.CreatePoint(x + 300, y),
GeometryFactory.CreatePoint(x + 300, y + 599.000));
row3.Store();
var helper = new CanExecuteContainerHelper();
helper.ExpectedMaximumRowCountPerTile = 2;
var test = new VerifyingContainerTest((ITable)featureClass)
{
OnExecuteCore = helper.ExecuteRow,
OnCompleteTile = helper.CompleteTile,
OnCachedRow = helper.CachedRow
};
test.SetSearchDistance(2);
var container = new TestContainer.TestContainer {
TileSize = 600
};
container.AddTest(test);
container.MaxCachedPointCount = 1; // disable caching
container.Execute();
Assert.AreEqual(4 + 1, helper.CompleteTileCount); // + 1 : wegen initialem Tile
Assert.AreEqual(
5, helper.ExecuteRowCount); // row1,row in 2 Tiles, row3 only executed in first Tile
Assert.AreEqual(6, helper.CachedRowCount); // 3 features x 2 intersected tiles
}
public void CanExecuteContainerTwoVerticalLines()
{
IFeatureClass featureClass =
CreatePolylineFeatureClass("CanExecuteContainerTwoVerticalLines", 0.01);
// Create error Feature
const double x = 2600000;
const double y = 1200000;
IFeature row1 = featureClass.CreateFeature();
row1.Shape = GeometryFactory.CreateLine(
GeometryFactory.CreatePoint(x, y),
GeometryFactory.CreatePoint(x, y + 800));
row1.Store();
IFeature row2 = featureClass.CreateFeature();
row2.Shape = GeometryFactory.CreateLine(
GeometryFactory.CreatePoint(x + 1000, y),
GeometryFactory.CreatePoint(x + 1000, y + 800));
row2.Store();
var helper = new CanExecuteContainerHelper();
helper.ExpectedMaximumRowCountPerTile = 1;
var test = new VerifyingContainerTest((ITable)featureClass)
{
OnExecuteCore = helper.ExecuteRow,
OnCompleteTile = helper.CompleteTile
};
test.SetSearchDistance(10);
var container = new TestContainer.TestContainer {
TileSize = 600
};
container.AddTest(test);
container.Execute();
Assert.AreEqual(4 + 1, helper.CompleteTileCount); // + 1 : wegen initialem Tile
Assert.AreEqual(4, helper.ExecuteRowCount); // 2 features x 2 intersected tiles
}
public void CanExecuteContainePointFeatures()
{
IFeatureClass featureClass =
CreatePointFeatureClass("CanExecuteContainePointFeatures", 0.01);
// Create error Feature
const double x = 2600000;
const double y = 1200000;
AddPointFeature(featureClass, x, y);
AddPointFeature(featureClass, x + 1000, y + 1000);
// create a point 1m south of the upper tile boundary, in the second tile of the first row
AddPointFeature(featureClass, x + 599, y + 900);
var helper = new CanExecuteContainerHelper();
helper.ExpectedMaximumRowCountPerTile = 1;
var test = new VerifyingContainerTest((ITable)featureClass)
{
OnExecuteCore = helper.ExecuteRow,
OnCompleteTile = helper.CompleteTile
};
test.SetSearchDistance(0.5);
var container = new TestContainer.TestContainer {
TileSize = 600
};
container.AddTest(test);
container.Execute();
Assert.AreEqual(4 + 1, helper.CompleteTileCount); // + 1 : wegen initialem Tile
Assert.AreEqual(3, helper.ExecuteRowCount);
}
public void CheckWasAlreadyTested()
{
var overlaps = new OverlappingFeatures();
var fc = new FeatureClassMock(1, "", esriGeometryType.esriGeometryPolyline);
IFeature f1 = fc.CreateFeature(new Pt(100, 0), new Pt(109.95, 9.95));
IFeature f2 = fc.CreateFeature(new Pt(100, 0), new Pt(109.8, 9.8));
IFeature fx = fc.CreateFeature(new Pt(100, 0), new Pt(109.95, 9.8));
IFeature fy = fc.CreateFeature(new Pt(100, 0), new Pt(109.8, 9.95));
var c1 = new CachedRow(f1);
var test = new VerifyingContainerTest(fc);
var t2 = new VerifyingContainerTest(fc);
var t3 = new VerifyingContainerTest(fc);
overlaps.RegisterTestedFeature(c1, new ContainerTest[] { test });
Assert.IsTrue(overlaps.WasAlreadyTested(f1, test));
Assert.IsFalse(overlaps.WasAlreadyTested(f2, test));
overlaps.RegisterTestedFeature(new CachedRow(f2), new ContainerTest[] { test });
Assert.IsTrue(overlaps.WasAlreadyTested(f2, test));
overlaps.RegisterTestedFeature(new CachedRow(f2),
new ContainerTest[] { test, t2 });
Assert.IsTrue(overlaps.WasAlreadyTested(f2, test));
Assert.IsTrue(overlaps.WasAlreadyTested(f2, t2));
Assert.IsFalse(overlaps.WasAlreadyTested(f2, t3));
overlaps.RegisterTestedFeature(new CachedRow(fx), new ContainerTest[] { test });
overlaps.RegisterTestedFeature(new CachedRow(fy), new ContainerTest[] { test });
overlaps.SetCurrentTile(CreateBox(100, 0, 105, 5));
Assert.IsTrue(overlaps.WasAlreadyTested(f1, test));
Assert.IsTrue(overlaps.WasAlreadyTested(f2, test));
Assert.IsTrue(overlaps.WasAlreadyTested(fx, test));
Assert.IsTrue(overlaps.WasAlreadyTested(fy, test));
overlaps.AdaptSearchTolerance(fc, 0.1);
overlaps.SetCurrentTile(CreateBox(110, 0, 120, 10));
Assert.IsTrue(overlaps.WasAlreadyTested(f1, test));
Assert.IsFalse(overlaps.WasAlreadyTested(f2, test));
Assert.IsTrue(overlaps.WasAlreadyTested(fx, test));
Assert.IsTrue(overlaps.WasAlreadyTested(fy, test));
overlaps.SetCurrentTile(CreateBox(100, 10, 110, 20));
Assert.IsTrue(overlaps.WasAlreadyTested(f1, test));
Assert.IsFalse(overlaps.WasAlreadyTested(f2, test));
Assert.IsFalse(overlaps.WasAlreadyTested(fx, test));
Assert.IsTrue(overlaps.WasAlreadyTested(fy, test));
overlaps.SetCurrentTile(CreateBox(110, 10, 120, 20));
Assert.IsTrue(overlaps.WasAlreadyTested(f1, test));
Assert.IsFalse(overlaps.WasAlreadyTested(f2, test));
Assert.IsFalse(overlaps.WasAlreadyTested(fx, test));
Assert.IsFalse(overlaps.WasAlreadyTested(fy, test));
overlaps.SetCurrentTile(CreateBox(110.1, 10, 120, 20));
Assert.IsFalse(overlaps.WasAlreadyTested(f1, test));
Assert.IsFalse(overlaps.WasAlreadyTested(f2, test));
Assert.IsFalse(overlaps.WasAlreadyTested(fx, test));
Assert.IsFalse(overlaps.WasAlreadyTested(fy, test));
}
public void CanHandleCachedPointCount()
{
IFeatureClass featureClass = CreatePolylineFeatureClass(
"CanHandleCachedPointCount", 0.01);
const double x = 2600000;
const double y = 1200000;
// Create features
IFeature in4Tiles = featureClass.CreateFeature();
in4Tiles.Shape =
GeometryFactory.CreateLine(
GeometryFactory.CreatePoint(x, y),
GeometryFactory.CreatePoint(x + 1000, y + 800));
in4Tiles.Store();
IFeature inTiles_00_01 = featureClass.CreateFeature();
inTiles_00_01.Shape =
GeometryFactory.CreateLine(
GeometryFactory.CreatePoint(x + 100, y + 100),
GeometryFactory.CreatePoint(x + 800, y + 200));
inTiles_00_01.Store();
IFeature inTiles_00_10 = featureClass.CreateFeature();
inTiles_00_10.Shape =
GeometryFactory.CreateLine(
GeometryFactory.CreatePoint(x + 100, y + 100),
GeometryFactory.CreatePoint(x + 200, y + 200),
GeometryFactory.CreatePoint(x + 200, y + 300),
GeometryFactory.CreatePoint(x + 100, y + 400),
GeometryFactory.CreatePoint(x + 100, y + 500),
GeometryFactory.CreatePoint(x + 200, y + 600),
GeometryFactory.CreatePoint(x + 200, y + 700),
GeometryFactory.CreatePoint(x + 300, y + 800));
inTiles_00_10.Store();
IFeature inTiles_01_11 = featureClass.CreateFeature();
inTiles_01_11.Shape =
GeometryFactory.CreateLine(
GeometryFactory.CreatePoint(x + 800, y + 100),
GeometryFactory.CreatePoint(x + 800, y + 500),
GeometryFactory.CreatePoint(x + 900, y + 1400));
inTiles_01_11.Store();
var helper = new CanHandleCachedPointCountHelper();
var test = new VerifyingContainerTest((ITable)featureClass)
{
OnExecuteCore = helper.HandleRows,
OnCompleteTile = helper.HandleTiles
};
test.SetSearchDistance(10);
// Unlimited Cache
var container1 = new TestContainer.TestContainer
{
TileSize = 600,
MaxCachedPointCount = -1
};
// Assert.IsTrue(container1.MaxCachedPointCount < 0);
helper.Reset();
helper.Container = container1;
helper.ExpectedCacheCount = new[] { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
container1.AddTest(test);
container1.Execute(GeometryFactory.CreateEnvelope(x, y, x + 1500, y + 1500));
// Very large Cache
var container2 = new TestContainer.TestContainer
{
MaxCachedPointCount = int.MaxValue,
TileSize = 600
};
helper.Reset();
helper.Container = container2;
helper.ExpectedCacheCount = new[] { 0, 0, 8, 13, 3, 0, 3, 3, 0, 0 };
container2.AddTest(test);
container2.Execute(GeometryFactory.CreateEnvelope(x, y, x + 1500, y + 1500));
// small feature Cache
var container3 = new TestContainer.TestContainer
{
MaxCachedPointCount = 10,
TileSize = 600
};
helper.Reset();
helper.Container = container3;
helper.ExpectedCacheCount = new[] { 0, 0, 8, 5, 3, 0, 3, 3, 0, 0 };
// in the 5. tile, feature 'inTiles_01_11' with 3 points is used and hence not part of the cache
container3.AddTest(test);
container3.Execute(GeometryFactory.CreateEnvelope(x, y, x + 1500, y + 1500));
// very small feature Cache
var container4 = new TestContainer.TestContainer
{
MaxCachedPointCount = 4,
TileSize = 600
};
helper.Reset();
helper.Container = container4;
helper.ExpectedCacheCount = new[] { 0, 0, 0, 2, 0, 0, 3, 3, 0, 0 };
// in the 3. tile, feature 'inTiles_01_11' with 3 points gets unloaded because of cache limitation
// in the 5. tile, feature 'inTiles_01_11' gets loaded again, so that in the 6. and 7. tile it is cached
container4.AddTest(test);
container4.Execute(GeometryFactory.CreateEnvelope(x, y, x + 1500, y + 1500));
// no feature Cache
var container5 = new TestContainer.TestContainer
{
MaxCachedPointCount = 0,
TileSize = 600
};
helper.Reset();
helper.Container = container5;
helper.ExpectedCacheCount = new[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
container5.AddTest(test);
container5.Execute(GeometryFactory.CreateEnvelope(x, y, x + 1500, y + 1500));
}
