public void TestRemoveNonExistent()
{
var tree = MXCIFQuadTreeFactory.Make(0, 0, 100, 100, 20, 20);
Delete(10, 61, 1, 1, tree);
Set(10, 60, 1, 1, "R1", tree);
Delete(10, 61, 1, 1, tree);
Set(10, 80, 1, 1, "R2", tree);
Set(20, 70, 1, 1, "R3", tree);
Set(10, 80, 1, 1, "R4", tree);
AssertCollectAll(tree, "R1,R3,R4");
Assert.AreEqual(3, NavigateLeaf(tree, "").Count);
Assert.AreEqual(3, NavigateLeaf(tree, "").Count);
AssertCollectAll(tree, "R1,R3,R4");
Delete(10, 61, 1, 1, tree);
Assert.AreEqual(3, NavigateLeaf(tree, "").Count);
AssertCollectAll(tree, "R1,R3,R4");
Delete(9, 60, 1, 1, tree);
Delete(10, 80, 1, 1, tree);
Assert.AreEqual(2, NavigateLeaf(tree, "").Count);
AssertCollectAll(tree, "R1,R3");
Delete(9, 60, 1, 1, tree);
Delete(10, 80, 1, 1, tree);
Delete(10, 60, 1, 1, tree);
Assert.AreEqual(1, NavigateLeaf(tree, "").Count);
AssertCollectAll(tree, "R3");
Delete(20, 70, 1, 1, tree);
Assert.AreEqual(0, NavigateLeaf(tree, "").Count);
AssertCollectAll(tree, "");
}
public void TestFewValues()
{
tree = MXCIFQuadTreeFactory.Make(0, 0, 100, 100);
Set(73.32704983331149, 23.46990952575032, 1, 1, "R0", tree);
Set(53.09747562396894, 17.100976152185034, 1, 1, "R1", tree);
Set(56.75757294858788, 25.508506696809608, 1, 1, "R2", tree);
Set(83.66639067675291, 76.53772974832937, 1, 1, "R3", tree);
Set(51.01654641861326, 43.49009281983866, 1, 1, "R4", tree);
var beginX = 50.45945198254618;
var endX = 88.31594559038719;
var beginY = 4.577595744501329;
var endY = 22.93393078279351;
AssertCollect(tree, beginX, beginY, endX - beginX, endY - beginY, "R1");
AssertCollectAll(tree, "R0,R1,R2,R3,R4");
Assert.AreEqual("R0", Get(73.32704983331149, 23.46990952575032, 1, 1, tree));
Assert.AreEqual("R1", Get(53.09747562396894, 17.100976152185034, 1, 1, tree));
Assert.AreEqual("R2", Get(56.75757294858788, 25.508506696809608, 1, 1, tree));
Assert.AreEqual("R3", Get(83.66639067675291, 76.53772974832937, 1, 1, tree));
Assert.AreEqual("R4", Get(51.01654641861326, 43.49009281983866, 1, 1, tree));
}
public void TestAddRemoveScenario()
{
tree = MXCIFQuadTreeFactory.Make(0, 0, 100, 100);
AddUnique(tree, 85.0, 65.0, 0.999, 0.999, "P3");
AddUnique(tree, 86.0, 50.0, 0.999, 0.999, "P6");
AddUnique(tree, 17.0, 84.0, 0.999, 0.999, "P0");
AddUnique(tree, 7.0, 34.0, 0.999, 0.999, "P4");
AddUnique(tree, 7.0, 69.0, 0.999, 0.999, "P8");
AddUnique(tree, 36.0, 47.0, 0.999, 0.999, "P9");
AddUnique(tree, 62.0, 50.0, 0.999, 0.999, "P1");
AddUnique(tree, 46.0, 17.0, 0.999, 0.999, "P2");
AddUnique(tree, 43.0, 16.0, 0.999, 0.999, "P5");
AddUnique(tree, 79.0, 92.0, 0.999, 0.999, "P7");
Remove(tree, 46.0, 17.0, 0.999, 0.999, "P2");
AddUnique(tree, 47.0, 17.0, 0.999, 0.999, "P2");
Remove(tree, 43.0, 16.0, 0.999, 0.999, "P5");
AddUnique(tree, 44.0, 16.0, 0.999, 0.999, "P5");
Remove(tree, 62.0, 50.0, 0.999, 0.999, "P1");
AddUnique(tree, 62.0, 49.0, 0.999, 0.999, "P1");
Remove(tree, 17.0, 84.0, 0.999, 0.999, "P0");
AddUnique(tree, 18.0, 84.0, 0.999, 0.999, "P0");
Remove(tree, 86.0, 50.0, 0.999, 0.999, "P6");
AddUnique(tree, 86.0, 51.0, 0.999, 0.999, "P6");
AssertFound(tree, 81.0, 46.0, 10.0, 10.0, "P6");
}
public void TestPoints()
{
tree = MXCIFQuadTreeFactory.Make(0, 0, 10, 10);
AddNonUnique(tree, 8.0, 4.0, 1, 1, "R0");
AssertFound(tree, 0, 0, 10, 10, "R0");
AddNonUnique(tree, 8.0, 1.0, 1, 1, "R1");
AssertFound(tree, 0, 0, 10, 10, "R0,R1");
AddNonUnique(tree, 8.0, 2.0, 1, 1, "R2");
AssertFound(tree, 0, 0, 10, 10, "R0,R1,R2");
AddNonUnique(tree, 4.0, 4.0, 1, 1, "R3");
AssertFound(tree, 0, 0, 10, 10, "R0,R1,R2,R3");
AddNonUnique(tree, 1.0, 9.0, 1, 1, "R4");
AssertFound(tree, 0, 0, 10, 10, "R0,R1,R2,R3,R4");
AddNonUnique(tree, 8.0, 3.0, 1, 1, "R5");
AssertFound(tree, 0, 0, 10, 10, "R0,R1,R2,R3,R4,R5");
AddNonUnique(tree, 0.0, 6.0, 1, 1, "R6");
AssertFound(tree, 0, 0, 10, 10, "R0,R1,R2,R3,R4,R5,R6");
AddNonUnique(tree, 5.0, 1.0, 1, 1, "R7");
AssertFound(tree, 0, 0, 10, 10, "R0,R1,R2,R3,R4,R5,R6,R7");
AddNonUnique(tree, 5.0, 8.0, 1, 1, "R8");
AssertFound(tree, 0, 0, 10, 10, "R0,R1,R2,R3,R4,R5,R6,R7,R8");
AddNonUnique(tree, 7.0, 6.0, 1, 1, "R9");
AssertFound(tree, 0, 0, 10, 10, "R0,R1,R2,R3,R4,R5,R6,R7,R8,R9");
}
public void TestDimension()
{
var tree = MXCIFQuadTreeFactory.Make(1000, 100000, 9000, 900000);
try
{
Set(10, 90, 1, 1, "R1", tree);
Assert.Fail();
}
catch (Exception ex)
{
Assert.AreEqual(ex.Message, "Rectangle (10.0d,90.0d,1.0d,1.0d) not in {MinX=1000.0d, MinY=100000.0d, MaxX=10000.0d, MaxY=1000000.0d}");
}
try
{
Set(10999999, 90, 1, 1, "R2", tree);
Assert.Fail();
}
catch (Exception)
{
// expected
}
Set(5000, 800000, 1, 1, "R3", tree);
AssertCollect(tree, 0, 0, 10000000, 10000000, "R3");
AssertCollect(tree, 4000, 790000, 1200, 11000, "R3");
AssertCollect(tree, 4000, 790000, 900, 9000, "");
AssertCollectAll(tree, "R3");
}
public void TestPoints()
{
tree = MXCIFQuadTreeFactory.Make(0, 0, 10, 10);
Set(8.0, 4.0, 1, 1, "R0", tree);
AssertCollectAll(tree, "R0");
Set(8.0, 1.0, 1, 1, "R1", tree);
AssertCollectAll(tree, "R0,R1");
Set(8.0, 2.0, 1, 1, "R2", tree);
AssertCollectAll(tree, "R0,R1,R2");
Set(4.0, 4.0, 1, 1, "R3", tree);
AssertCollectAll(tree, "R0,R1,R2,R3");
Set(1.0, 9.0, 1, 1, "R4", tree);
AssertCollectAll(tree, "R0,R1,R2,R3,R4");
Set(8.0, 3.0, 1, 1, "R5", tree);
AssertCollectAll(tree, "R0,R1,R2,R3,R4,R5");
Set(0.0, 6.0, 1, 1, "R6", tree);
AssertCollectAll(tree, "R0,R1,R2,R3,R4,R5,R6");
Set(5.0, 1.0, 1, 1, "R7", tree);
AssertCollectAll(tree, "R0,R1,R2,R3,R4,R5,R6,R7");
Set(5.0, 8.0, 1, 1, "R8", tree);
AssertCollectAll(tree, "R0,R1,R2,R3,R4,R5,R6,R7,R8");
Set(7.0, 6.0, 1, 1, "R9", tree);
AssertCollectAll(tree, "R0,R1,R2,R3,R4,R5,R6,R7,R8,R9");
}
public void TestSubdivideAdd()
{
var tree = MXCIFQuadTreeFactory.Make(0, 0, 100, 100, 2, 3);
AddNonUnique(tree, 0, 0, 10, 10, "R1");
AddNonUnique(tree, 0, 0, 10, 10, "R2");
AddNonUnique(tree, 0, 0, 10, 10, "R3");
Assert.AreEqual(3, NavigateLeaf(tree, "nw,nw").Count);
}
public void TestAddRemoveSimple()
{
tree = MXCIFQuadTreeFactory.Make(0, 0, 50, 60);
AssertFound(tree, 0, 0, 10, 10, "");
AddNonUnique(tree, 5, 8, 1, 1, "R1");
AssertFound(tree, 0, 0, 10, 10, "R1");
AssertFound(tree, 0, 0, 5, 5, "");
MXCIFQuadTreeRowIndexRemove.Remove(5, 8, 1, 1, "R1", tree);
AssertFound(tree, 0, 0, 10, 10, "");
}
public override EventTable Make(
EventAdvancedIndexConfigStatement configStatement,
AdvancedIndexConfigContextPartition configCP,
EventTableOrganization organization)
{
var qt = (AdvancedIndexConfigContextPartitionQuadTree)configCP;
var quadTree =
MXCIFQuadTreeFactory <object> .Make(qt.X, qt.Y, qt.Width, qt.Height, qt.LeafCapacity, qt.MaxTreeHeight);
return(new EventTableQuadTreeMXCIFImpl(organization,
(AdvancedIndexConfigStatementMXCIFQuadtree)configStatement, quadTree));
}
public void TestDimension()
{
var tree = MXCIFQuadTreeFactory.Make(1000, 100000, 9000, 900000);
Assert.IsFalse(AddNonUnique(tree, 10, 90, 1, 1, "R1"));
Assert.IsFalse(AddNonUnique(tree, 10999999, 90, 1, 1, "R2"));
Assert.IsTrue(AddNonUnique(tree, 5000, 800000, 1, 1, "R3"));
AssertFound(tree, 0, 0, 10000000, 10000000, "R3");
AssertFound(tree, 4000, 790000, 1200, 11000, "R3");
AssertFound(tree, 4000, 790000, 900, 9000, "");
}
public FilterParamIndexQuadTreeMXCIF(IReaderWriterLock readWriteLock, FilterSpecLookupable lookupable)
: base(FilterOperator.ADVANCED_INDEX, lookupable)
{
_readWriteLock = readWriteLock;
_advancedIndex = (FilterSpecLookupableAdvancedIndex) lookupable;
var quadTreeConfig = _advancedIndex.QuadTreeConfig;
_quadTree = MXCIFQuadTreeFactory<object>.Make(
quadTreeConfig.X,
quadTreeConfig.Y,
quadTreeConfig.Width,
quadTreeConfig.Height);
}
public void TestSuperslim()
{
var tree = MXCIFQuadTreeFactory.Make(0, 0, 100, 100, 1, 100);
AddNonUnique(tree, 10, 90, 1, 1, "R1");
AddNonUnique(tree, 10, 95, 1, 1, "R2");
var ne = NavigateLeaf(tree, "sw,sw,sw,ne");
Compare(10, 90, 1, 1, "\"R1\"", (XYWHRectangleMultiType)ne.Data);
var se = NavigateLeaf(tree, "sw,sw,sw,se");
Compare(10, 95, 1, 1, "\"R2\"", (XYWHRectangleMultiType)se.Data);
}
public void TestSuperslim()
{
var tree = MXCIFQuadTreeFactory.Make(0, 0, 100, 100, 1, 100);
Set(10, 90, 0.1, 0.2, "R1", tree);
Set(10, 95, 0.3, 0.4, "R2", tree);
var ne = NavigateLeaf(tree, "sw,sw,sw,ne");
Compare(10, 90, 0.1, 0.2, "R1", (XYWHRectangleWValue)ne.Data);
var se = NavigateLeaf(tree, "sw,sw,sw,se");
Compare(10, 95, 0.3, 0.4, "R2", (XYWHRectangleWValue)se.Data);
}
public void TestSubdivideAddMany()
{
var tree = MXCIFQuadTreeFactory.Make(0, 0, 100, 100, 2, 3);
Set(0, 0, 1, 1, "R1", tree);
Set(1, 2, 1, 1, "R2", tree);
Set(3, 2, 1, 1, "R3", tree);
Assert.AreEqual(3, NavigateLeaf(tree, "nw,nw").Count);
Delete(1, 2, 1, 1, tree);
Delete(0, 0, 1, 1, tree);
Delete(3, 2, 1, 1, tree);
AssertCollectAll(tree, "");
}
public void TestGetSetRemove()
{
tree = MXCIFQuadTreeFactory.Make(0, 0, 100, 100);
Assert.IsNull(Get(10, 20, 30, 40, tree));
AssertCollectAll(tree, "");
Set(10, 20, 30, 40, "R0", tree);
Assert.AreEqual("R0", Get(10, 20, 30, 40, tree));
AssertCollectAll(tree, "R0");
Delete(10, 20, 30, 40, tree);
Assert.IsNull(Get(10, 20, 30, 40, tree));
AssertCollectAll(tree, "");
}
public void TestAddRemoveSamePoint()
{
tree = MXCIFQuadTreeFactory.Make(0, 0, 100, 100);
AddNonUnique(tree, 5, 8, 1, 1, "R1");
AddNonUnique(tree, 5, 8, 1, 1, "R2");
AssertFound(tree, 0, 0, 10, 10, "R1,R2");
MXCIFQuadTreeRowIndexRemove.Remove(5, 8, 1, 1, "R1", tree);
AssertFound(tree, 0, 0, 10, 10, "R2");
MXCIFQuadTreeRowIndexRemove.Remove(5, 8, 1, 1, "R2", tree);
AssertFound(tree, 0, 0, 10, 10, "");
}
public void TestSetRemoveTwiceSamePoint()
{
tree = MXCIFQuadTreeFactory.Make(0, 0, 100, 100);
Set(5, 8, 1, 2, "R1", tree);
Set(5, 8, 1, 2, "R2", tree);
AssertCollectAll(tree, "R2");
Delete(5, 8, 1, 2, tree);
AssertCollectAll(tree, "");
Delete(5, 8, 1, 2, tree);
AssertCollectAll(tree, "");
}
public void TestSubdivideMultiChild()
{
var tree = MXCIFQuadTreeFactory.Make(0, 0, 100, 100, 4, 3);
Set(60, 11, 1, 1, "R1", tree);
Set(60, 40, 1, 1, "R2", tree);
Set(70, 30, 1, 1, "R3", tree);
Set(60, 10, 1, 1, "R4", tree);
Set(90, 45, 1, 1, "R5", tree);
NavigateLeaf(tree, "nw");
NavigateLeaf(tree, "se");
NavigateLeaf(tree, "sw");
var ne = NavigateBranch(tree, "ne");
Assert.AreEqual(2, ne.Level);
var nw = NavigateLeaf(ne, "nw");
var collection = (IList <XYWHRectangleWValue>)nw.Data;
Compare(60, 11, 1, 1, "R1", collection[0]);
Compare(60, 10, 1, 1, "R4", collection[1]);
Assert.AreEqual(2, nw.Count);
var se = NavigateLeaf(ne, "se");
Compare(90, 45, 1, 1, "R5", (XYWHRectangleWValue)se.Data);
Assert.AreEqual(1, se.Count);
var sw = NavigateLeaf(ne, "sw");
collection = (IList <XYWHRectangleWValue>)sw.Data;
Compare(60, 40, 1, 1, "R2", collection[0]);
Compare(70, 30, 1, 1, "R3", collection[1]);
Assert.AreEqual(2, sw.Count);
Delete(60, 11, 1, 1, tree);
Delete(60, 40, 1, 1, tree);
var root = NavigateLeaf(tree, "");
collection = (IList <XYWHRectangleWValue>)root.Data;
Assert.AreEqual(3, root.Count);
Assert.AreEqual(3, collection.Count);
Compare(60, 10, 1, 1, "R4", collection[0]);
Compare(70, 30, 1, 1, "R3", collection[1]);
Compare(90, 45, 1, 1, "R5", collection[2]);
}
public void TestSubdivideMultiChild()
{
var tree = MXCIFQuadTreeFactory.Make(0, 0, 100, 100, 4, 3);
AddNonUnique(tree, 60, 10, 1, 1, "R1");
AddNonUnique(tree, 60, 40, 1, 1, "R2");
AddNonUnique(tree, 70, 30, 1, 1, "R3");
AddNonUnique(tree, 60, 10, 1, 1, "R4");
AddNonUnique(tree, 90, 45, 1, 1, "R5");
NavigateLeaf(tree, "nw");
NavigateLeaf(tree, "se");
NavigateLeaf(tree, "sw");
var ne = NavigateBranch(tree, "ne");
Assert.AreEqual(2, ne.Level);
var nw = NavigateLeaf(ne, "nw");
Compare(60, 10, 1, 1, "[\"R1\", \"R4\"]", (XYWHRectangleMultiType)nw.Data);
Assert.AreEqual(2, nw.Count);
var se = NavigateLeaf(ne, "se");
Compare(90, 45, 1, 1, "\"R5\"", (XYWHRectangleMultiType)se.Data);
Assert.AreEqual(1, se.Count);
var sw = NavigateLeaf(ne, "sw");
var collection = sw.Data.UnwrapIntoList <XYWHRectangleMultiType>();
Compare(60, 40, 1, 1, "\"R2\"", collection[0]);
Compare(70, 30, 1, 1, "\"R3\"", collection[1]);
Assert.AreEqual(2, sw.Count);
Remove(tree, 60, 10, 1, 1, "R1");
Remove(tree, 60, 40, 1, 1, "R2");
var root = NavigateLeaf(tree, "");
collection = root.Data.UnwrapIntoList <XYWHRectangleMultiType>();
Assert.AreEqual(3, root.Count);
Assert.AreEqual(3, collection.Count);
Compare(60, 10, 1, 1, "[\"R4\"]", collection[0]);
Compare(70, 30, 1, 1, "\"R3\"", collection[1]);
Compare(90, 45, 1, 1, "\"R5\"", collection[2]);
}
public void TestFewValues()
{
tree = MXCIFQuadTreeFactory.Make(0, 0, 100, 100);
AddNonUnique(tree, 73.32704983331149, 23.46990952575032, 1, 1, "R0");
AddNonUnique(tree, 53.09747562396894, 17.100976152185034, 1, 1, "R1");
AddNonUnique(tree, 56.75757294858788, 25.508506696809608, 1, 1, "R2");
AddNonUnique(tree, 83.66639067675291, 76.53772974832937, 1, 1, "R3");
AddNonUnique(tree, 51.01654641861326, 43.49009281983866, 1, 1, "R4");
double beginX = 50.45945198254618;
double endX = 88.31594559038719;
double beginY = 4.577595744501329;
double endY = 22.93393078279351;
AssertFound(tree, beginX, beginY, endX - beginX, endY - beginY, "R1");
}
public void TestSubdivideSingleMerge()
{
var tree = MXCIFQuadTreeFactory.Make(0, 0, 100, 100, 3, 2);
Set(65, 75, 1, 1, "R1", tree);
Set(81, 60, 1, 1, "R2", tree);
Set(80, 60, 1, 1, "R3", tree);
Set(80, 61, 1, 1, "R4", tree);
AssertCollect(tree, 60, 60, 20.5, 20.5, "R1,R3,R4");
AssertCollectAll(tree, "R1,R2,R3,R4");
Assert.IsFalse(tree.Root is MXCIFQuadTreeNodeLeaf);
Assert.AreEqual(4, NavigateLeaf(tree, "se").Count);
var collection = (IList <XYWHRectangleWValue>)NavigateLeaf(tree, "se").Data;
Assert.AreEqual(4, collection.Count);
Compare(65, 75, 1, 1, "R1", collection[0]);
Compare(81, 60, 1, 1, "R2", collection[1]);
Compare(80, 60, 1, 1, "R3", collection[2]);
Compare(80, 61, 1, 1, "R4", collection[3]);
Set(66, 78, 1, 1, "R5", tree);
Delete(65, 75, 1, 1, tree);
Delete(80, 60, 1, 1, tree);
Assert.AreEqual(3, NavigateLeaf(tree, "se").Count);
AssertCollectAll(tree, "R2,R4,R5");
Assert.AreEqual(3, collection.Count);
Compare(81, 60, 1, 1, "R2", collection[0]);
Compare(80, 61, 1, 1, "R4", collection[1]);
Compare(66, 78, 1, 1, "R5", collection[2]);
Delete(66, 78, 1, 1, tree);
AssertCollectAll(tree, "R2,R4");
Assert.AreEqual(2, NavigateLeaf(tree, "").Count);
collection = (IList <XYWHRectangleWValue>)NavigateLeaf(tree, "").Data;
Assert.AreEqual(2, collection.Count);
Compare(81, 60, 1, 1, "R2", collection[0]);
Compare(80, 61, 1, 1, "R4", collection[1]);
}
public void TestSubdivideSingleMerge()
{
var tree = MXCIFQuadTreeFactory.Make(0, 0, 100, 100, 3, 2);
AddNonUnique(tree, 65, 75, 1, 1, "P1");
AddNonUnique(tree, 80, 75, 1, 1, "P2");
AddNonUnique(tree, 80, 60, 1, 1, "P3");
AddNonUnique(tree, 80, 60, 1, 1, "P4");
AssertFound(tree, 60, 60, 21, 21, "P1,P2,P3,P4");
Assert.IsFalse(tree.Root is MXCIFQuadTreeNodeLeaf);
Assert.AreEqual(4, NavigateLeaf(tree, "se").Count);
var collection = NavigateLeaf(tree, "se").Data.UnwrapIntoList <XYWHRectangleMultiType>();
Assert.AreEqual(3, collection.Count);
Compare(65, 75, 1, 1, "\"P1\"", collection[0]);
Compare(80, 75, 1, 1, "\"P2\"", collection[1]);
Compare(80, 60, 1, 1, "[\"P3\", \"P4\"]", collection[2]);
AddNonUnique(tree, 66, 78, 1, 1, "P5");
Remove(tree, 65, 75, 1, 1, "P1");
Remove(tree, 80, 60, 1, 1, "P3");
collection = NavigateLeaf(tree, "se").Data.UnwrapIntoList <XYWHRectangleMultiType>();
Assert.AreEqual(3, NavigateLeaf(tree, "se").Count);
AssertFound(tree, 60, 60, 21, 21, "P2,P4,P5");
Assert.AreEqual(3, collection.Count);
Compare(80, 75, 1, 1, "\"P2\"", collection[0]);
Compare(80, 60, 1, 1, "[\"P4\"]", collection[1]);
Compare(66, 78, 1, 1, "\"P5\"", collection[2]);
Remove(tree, 66, 78, 1, 1, "P5");
AssertFound(tree, 60, 60, 21, 21, "P2,P4");
Assert.AreEqual(2, NavigateLeaf(tree, "").Count);
collection = NavigateLeaf(tree, "").Data.UnwrapIntoList <XYWHRectangleMultiType>();
Assert.AreEqual(2, collection.Count);
Compare(80, 75, 1, 1, "\"P2\"", collection[0]);
Compare(80, 60, 1, 1, "[\"P4\"]", collection[1]);
}
public void TestRemoveNonExistent()
{
var tree = MXCIFQuadTreeFactory.Make(0, 0, 100, 100, 20, 20);
Remove(tree, 10, 61, 1, 1, "R1");
AddNonUnique(tree, 10, 60, 1, 1, "R1");
Remove(tree, 10, 61, 1, 1, "R1");
Remove(tree, 10, 60, 2, 1, "R1");
Remove(tree, 10, 60, 1, 2, "R1");
Remove(tree, 11, 60, 1, 1, "R1");
AddNonUnique(tree, 10, 80, 1, 1, "R2");
AddNonUnique(tree, 20, 70, 1, 1, "R3");
AddNonUnique(tree, 10, 80, 1, 1, "R4");
Assert.AreEqual(4, NavigateLeaf(tree, "").Count);
AssertFound(tree, 10, 60, 10000, 10000, "R1,R2,R3,R4");
Remove(tree, 10, 61, 1, 1, "R1");
Remove(tree, 9, 60, 1, 1, "R1");
Remove(tree, 10, 60, 1, 1, "R2");
Remove(tree, 10, 80, 1, 1, "R1");
Assert.AreEqual(4, NavigateLeaf(tree, "").Count);
AssertFound(tree, 10, 60, 10000, 10000, "R1,R2,R3,R4");
Remove(tree, 10, 80, 1, 1, "R4");
Assert.AreEqual(3, NavigateLeaf(tree, "").Count);
AssertFound(tree, 10, 60, 10000, 10000, "R1,R2,R3");
Remove(tree, 10, 80, 1, 1, "R2");
Assert.AreEqual(2, NavigateLeaf(tree, "").Count);
AssertFound(tree, 10, 60, 10000, 10000, "R1,R3");
Remove(tree, 10, 60, 1, 1, "R1");
Assert.AreEqual(1, NavigateLeaf(tree, "").Count);
AssertFound(tree, 10, 60, 10000, 10000, "R3");
Remove(tree, 20, 70, 1, 1, "R3");
Assert.AreEqual(0, NavigateLeaf(tree, "").Count);
AssertFound(tree, 10, 60, 10000, 10000, "");
}
public void TestSubdivideMultitypeMerge()
{
var tree = MXCIFQuadTreeFactory.Make(0, 0, 100, 100, 6, 2);
Assert.AreEqual(1, tree.Root.Level);
AddNonUnique(tree, 10, 10, 0, 0, "P1");
AddNonUnique(tree, 9.9, 10, 0, 0, "P2");
AddNonUnique(tree, 10, 9.9, 0, 0, "P3");
AddNonUnique(tree, 10, 10, 0, 0, "P4");
AddNonUnique(tree, 10, 9.9, 0, 0, "P5");
AddNonUnique(tree, 9.9, 10, 0, 0, "P6");
Assert.IsInstanceOf <MXCIFQuadTreeNodeLeaf>(tree.Root);
AssertFound(tree, 9, 10, 0.99, 0.99, "P2,P6");
AssertFound(tree, 10, 9, 0.99, 0.99, "P3,P5");
AssertFound(tree, 10, 10, 0, 0, "P1,P4");
AssertFound(tree, 9, 9, 2, 2, "P1,P2,P3,P4,P5,P6");
AddNonUnique(tree, 10, 10, 0, 0, "P7");
Assert.IsNotInstanceOf <MXCIFQuadTreeNodeLeaf>(tree.Root);
Assert.AreEqual(1, tree.Root.Level);
Assert.AreEqual(7, NavigateLeaf(tree, "nw").Count);
var collection = NavigateLeaf(tree, "nw").Data.UnwrapIntoList <XYWHRectangleMultiType>();
Assert.AreEqual(3, collection.Count);
Compare(10, 10, 0, 0, "[\"P1\", \"P4\", \"P7\"]", collection[0]);
Compare(9.9, 10, 0, 0, "[\"P2\", \"P6\"]", collection[1]);
Compare(10, 9.9, 0, 0, "[\"P3\", \"P5\"]", collection[2]);
AssertFound(tree, 9, 10, 0.99, 0.99, "P2,P6");
AssertFound(tree, 10, 9, 0.99, 0.99, "P3,P5");
AssertFound(tree, 10, 10, 0, 0, "P1,P4,P7");
AssertFound(tree, 9, 9, 2, 2, "P1,P2,P3,P4,P5,P6,P7");
AddNonUnique(tree, 9.9, 10, 0, 0, "P8");
AddNonUnique(tree, 10, 9.9, 0, 0, "P9");
AddNonUnique(tree, 10, 10, 0, 0, "P10");
AddNonUnique(tree, 10, 10, 0, 0, "P11");
AddNonUnique(tree, 10, 10, 0, 0, "P12");
Assert.AreEqual(12, NavigateLeaf(tree, "nw").Count);
Assert.AreEqual(2, NavigateLeaf(tree, "nw").Level);
Assert.AreEqual(3, collection.Count);
Compare(10, 10, 0, 0, "[\"P1\", \"P4\", \"P7\", \"P10\", \"P11\", \"P12\"]", collection[0]);
Compare(9.9, 10, 0, 0, "[\"P2\", \"P6\", \"P8\"]", collection[1]);
Compare(10, 9.9, 0, 0, "[\"P3\", \"P5\", \"P9\"]", collection[2]);
AssertFound(tree, 9, 10, 0.99, 0.99, "P2,P6,P8");
AssertFound(tree, 10, 9, 0.99, 0.99, "P3,P5,P9");
AssertFound(tree, 10, 10, 1, 1, "P1,P4,P7,P10,P11,P12");
AssertFound(tree, 9, 9, 2, 2, "P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12");
Remove(tree, 9.9, 10, 0, 0, "P8");
Remove(tree, 10, 9.9, 0, 0, "P3");
Remove(tree, 10, 9.9, 0, 0, "P5");
Remove(tree, 10, 9.9, 0, 0, "P9");
AssertFound(tree, 9, 10, 0.99, 0.99, "P2,P6");
AssertFound(tree, 10, 9, 0.99, 0.99, "");
AssertFound(tree, 10, 10, 1, 1, "P1,P4,P7,P10,P11,P12");
AssertFound(tree, 9, 9, 2, 2, "P1,P2,P4,P6,P7,P10,P11,P12");
collection = NavigateLeaf(tree, "nw").Data.UnwrapIntoList <XYWHRectangleMultiType>();
Assert.AreEqual(8, NavigateLeaf(tree, "nw").Count);
Assert.AreEqual(2, collection.Count);
Compare(10, 10, 0, 0, "[\"P1\", \"P4\", \"P7\", \"P10\", \"P11\", \"P12\"]", collection[0]);
Compare(9.9, 10, 0, 0, "[\"P2\", \"P6\"]", collection[1]);
Assert.IsFalse(tree.Root is MXCIFQuadTreeNodeLeaf);
Remove(tree, 9.9, 10, 0, 0, "P2");
Remove(tree, 10, 10, 0, 0, "P1");
Remove(tree, 10, 10, 0, 0, "P10");
Assert.IsInstanceOf <MXCIFQuadTreeNodeLeaf>(tree.Root);
Assert.AreEqual(5, NavigateLeaf(tree, "").Count);
collection = NavigateLeaf(tree, "").Data.UnwrapIntoList <XYWHRectangleMultiType>();
Assert.AreEqual(2, collection.Count);
Compare(10, 10, 0, 0, "[\"P4\", \"P7\", \"P11\", \"P12\"]", collection[0]);
Compare(9.9, 10, 0, 0, "[\"P6\"]", collection[1]);
AssertFound(tree, 9, 10, 0.99, 0.99, "P6");
AssertFound(tree, 10, 9, 0.99, 0.99, "");
AssertFound(tree, 10, 10, 1, 1, "P4,P7,P11,P12");
AssertFound(tree, 9, 9, 2, 2, "P4,P6,P7,P11,P12");
}
public void TestSubdivideMerge()
{
var tree = MXCIFQuadTreeFactory.Make(0, 0, 100, 100, 3, 2);
Assert.AreEqual(1, tree.Root.Level);
Set(10, 10, 0.01, 0.01, "R1", tree);
Set(9.9, 10, 0.01, 0.01, "R2", tree);
Set(10, 9.9, 0.01, 0.01, "R3", tree);
Set(10, 10, 0.01, 0.01, "R4", tree);
Set(10, 9.9, 0.01, 0.01, "R5", tree);
Set(9.9, 10, 0.01, 0.01, "R6", tree);
Assert.IsInstanceOf <MXCIFQuadTreeNodeLeaf>(tree.Root);
AssertCollect(tree, 9, 10, 1, 1, "R4,R6");
AssertCollect(tree, 10, 9, 1, 1, "R4,R5");
AssertCollect(tree, 10, 10, 1, 1, "R4");
AssertCollect(tree, 9, 9, 2, 2, "R4,R5,R6");
AssertCollectAll(tree, "R4,R5,R6");
Set(10, 10, 0.01, 0.01, "R7", tree);
Assert.IsInstanceOf <MXCIFQuadTreeNodeLeaf>(tree.Root);
Set(9.9, 9.9, 0.01, 0.01, "R8", tree);
Assert.IsFalse(tree.Root is MXCIFQuadTreeNodeLeaf);
Assert.AreEqual(1, tree.Root.Level);
Assert.AreEqual(4, NavigateLeaf(tree, "nw").Count);
var collection = (IList <XYWHRectangleWValue>)NavigateLeaf(tree, "nw").Data;
Assert.AreEqual(4, collection.Count);
Compare(10, 10, 0.01, 0.01, "R7", collection[0]);
Compare(9.9, 10, 0.01, 0.01, "R6", collection[1]);
Compare(10, 9.9, 0.01, 0.01, "R5", collection[2]);
Compare(9.9, 9.9, 0.01, 0.01, "R8", collection[3]);
AssertCollect(tree, 9, 10, 1, 1, "R6,R7");
AssertCollect(tree, 10, 9, 1, 1, "R5,R7");
AssertCollect(tree, 10, 10, 1, 1, "R7");
AssertCollect(tree, 9, 9, 2, 2, "R5,R6,R7,R8");
AssertCollectAll(tree, "R5,R6,R7,R8");
Set(9.9, 10, 0.01, 0.01, "R9", tree);
Set(10, 9.9, 0.01, 0.01, "R10", tree);
Set(10, 10, 0.01, 0.01, "R11", tree);
Set(10, 10, 0.01, 0.01, "R12", tree);
Set(10, 10, 0.01, 0.01, "R13", tree);
Assert.AreEqual(4, NavigateLeaf(tree, "nw").Count);
Assert.AreEqual(2, NavigateLeaf(tree, "nw").Level);
Assert.AreEqual(4, collection.Count);
Compare(10, 10, 0.01, 0.01, "R13", collection[0]);
Compare(9.9, 10, 0.01, 0.01, "R9", collection[1]);
Compare(10, 9.9, 0.01, 0.01, "R10", collection[2]);
Compare(9.9, 9.9, 0.01, 0.01, "R8", collection[3]);
AssertCollect(tree, 9, 10, 1, 1, "R9,R13");
AssertCollect(tree, 10, 9, 1, 1, "R10,R13");
AssertCollect(tree, 10, 10, 1, 1, "R13");
AssertCollect(tree, 9, 9, 2, 2, "R8,R9,R10,R13");
Delete(9.9, 10, 0.01, 0.01, tree);
Delete(10, 9.9, 0.01, 0.01, tree);
Delete(10, 9.9, 0.01, 0.01, tree);
Delete(10, 9.9, 0.01, 0.01, tree);
AssertCollect(tree, 9, 10, 1, 1, "R13");
AssertCollect(tree, 10, 9, 1, 1, "R13");
AssertCollect(tree, 10, 10, 1, 1, "R13");
AssertCollect(tree, 9, 9, 2, 2, "R8,R13");
AssertCollectAll(tree, "R8,R13");
Assert.AreEqual(2, NavigateLeaf(tree, "").Count);
collection = (IList <XYWHRectangleWValue>)NavigateLeaf(tree, "").Data;
Assert.AreEqual(2, collection.Count);
Compare(10, 10, 0.01, 0.01, "R13", collection[0]);
Compare(9.9, 9.9, 0.01, 0.01, "R8", collection[1]);
Delete(9.9, 9.9, 0.01, 0.01, tree);
Delete(10, 10, 0.01, 0.01, tree);
Assert.IsInstanceOf <MXCIFQuadTreeNodeLeaf>(tree.Root);
Assert.AreEqual(0, NavigateLeaf(tree, "").Count);
AssertCollectAll(tree, "");
}
