//
//You can use the following additional attributes as you write your tests:
//
//Use ClassInitialize to run code before running the first test in the class
//[ClassInitialize()]
//public static void MyClassInitialize(TestContext testContext)
//{
//}
//
//Use ClassCleanup to run code after all tests in a class have run
//[ClassCleanup()]
//public static void MyClassCleanup()
//{
//}
//
//Use TestInitialize to run code before running each test
//[TestInitialize()]
//public void MyTestInitialize()
//{
//}
//
//Use TestCleanup to run code after each test has run
//[TestCleanup()]
//public void MyTestCleanup()
//{
//}
//
#endregion
internal virtual IRTreeContainer CreateIRTreeContainer()
{
// TODO: Instantiate an appropriate concrete class.
IRTreeContainer target = null;
return(target);
}
public void ParentUnitTest()
{
Assert.Inconclusive("TODO");
IRTreeContainer target = CreateIRTreeContainer(); // TODO: Initialize to an appropriate value
ARTreeContainer expected = null; // TODO: Initialize to an appropriate value
ARTreeContainer actual;
target.Parent = expected;
actual = target.Parent;
Assert.AreEqual(expected, actual);
}
private void RecalculationByRemoving(IRTreeContainer removeContainer)
{
var recalculatePath = removeContainer;
while (recalculatePath.Parent != null)
{
if (recalculatePath.Parent.IsLeaf)
{
var newMBR = FindMBR(((RTreeLeaf)recalculatePath.Parent).Data);
recalculatePath.Parent.Lower = newMBR.Lower;
recalculatePath.Parent.Upper = newMBR.Upper;
recalculatePath.Parent.Area = GetArea(newMBR);
}
else
{
var newMBR = FindMBR(((RTreeNode)recalculatePath.Parent).Children);
recalculatePath.Parent.Lower = newMBR.Lower;
recalculatePath.Parent.Upper = newMBR.Upper;
recalculatePath.Parent.Area = GetArea(newMBR);
}
recalculatePath = recalculatePath.Parent;
if (recalculatePath.Parent == null || recalculatePath.Parent.Inclusion(removeContainer))
break;
}
}
//recalculation
private void Recalculation(IRTreeContainer newContainer)
{
var recalculatePath = newContainer;
while (recalculatePath.Parent != null)
{
if (recalculatePath.Parent.Inclusion(newContainer))
break;
var recalculateMBR = FindMBR(recalculatePath.Parent, newContainer);
recalculatePath.Parent.Area = GetArea(recalculateMBR);
recalculatePath.Parent.Lower = recalculateMBR.Lower;
recalculatePath.Parent.Upper = recalculateMBR.Upper;
recalculatePath = recalculatePath.Parent;
}
}
private void Insert(IRTreeContainer container, int level)
{
if (level == _levelForOverflowStrategy.Count - 1)
{
var chooseSubTree = (RTreeLeaf)ChooseSubTree(container, level);
container.Parent = chooseSubTree;
chooseSubTree.Data.Add((IRTreeDataContainer)container);
Recalculation(container);
if (chooseSubTree.Data.Count > MaxCountOfNode)
{
OverflowTreatment(level, chooseSubTree);
}
}
else
{
var chooseSubTree = (RTreeNode)ChooseSubTree(container, level);
container.Parent = chooseSubTree;
chooseSubTree.Children.Add((ARTreeContainer)container);
Recalculation(container);
if (chooseSubTree.Children.Count > MaxCountOfNode)
{
OverflowTreatment(level, chooseSubTree);
}
}
}
private ARTreeContainer GetNodeByAreaValue(List<ARTreeContainer> list, IRTreeContainer container)
{
float minAreaValue = float.PositiveInfinity;
float minOldAreaValue = float.PositiveInfinity;
ARTreeContainer areaRechtangle = null;
foreach (var value in list)
{
var newMBR = FindMBR(value, container);
var oldArea = value.Area;
var enlargementArea = GetArea(newMBR) - oldArea;
if (minAreaValue > enlargementArea)
{
areaRechtangle = value;
minAreaValue = enlargementArea;
minOldAreaValue = oldArea;
}
else
{
if (minAreaValue == enlargementArea && oldArea < minOldAreaValue)
{
areaRechtangle = value;
minOldAreaValue = oldArea;
}
}
}
return areaRechtangle;
}
private ARTreeContainer GetLeavesLevelByOverlap(List<ARTreeContainer> list, IRTreeContainer container)
{
ARTreeContainer output = null;
IMBR currentOutputMBR = null;
float minEnlagargmentOfOverlap = float.PositiveInfinity;
foreach (var value in list)
{
var oldOverlap = 0.0f;
var newOverlap = 0.0f;
var newMBR = FindMBR(value, container);
foreach (var value2 in list)
{
if (value != value2)
{
oldOverlap += FindOverlapValue(value, value2);
newOverlap += FindOverlapValue(newMBR, value2);
}
}
var enlargagment = newOverlap - oldOverlap;
if (enlargagment < minEnlagargmentOfOverlap)
{
output = value;
minEnlagargmentOfOverlap = enlargagment;
currentOutputMBR = newMBR;
}
else
{
if (enlargagment == minEnlagargmentOfOverlap)
{
var oldCurrentArea = value.Area;
var oldMinArea = output.Area;
var enlargementCurrentArea = GetArea(newMBR) - oldCurrentArea;
var enlargementMinArea = GetArea(currentOutputMBR) - oldMinArea;
if ((enlargementMinArea > enlargementCurrentArea) || (enlargementMinArea == enlargementCurrentArea && oldMinArea > oldCurrentArea))
{
output = value;
currentOutputMBR = newMBR;
}
}
}
}
return output;
}
private ARTreeContainer ChooseSubTree(IRTreeContainer container, int level)
{
if (_root.IsLeaf) return _root;
var currentNode = (RTreeNode)_root;
var counterOfLevel = 0;
while (counterOfLevel < level)
{
if (counterOfLevel + 1 == level)
{
return GetLeavesLevelByOverlap(currentNode.Children, container);
}
currentNode = (RTreeNode)GetNodeByAreaValue(currentNode.Children, container);
counterOfLevel++;
}
return currentNode;
}
