public QuadTreeNode CreateNewRoot(QuadTreeNode currentRoot)
{
var bounds = currentRoot.Bounds;
int startRow = bounds.Start.Row;
int startCol = bounds.Start.Column;
int halfCol = bounds.ColumnsCount ;
int halfRow = bounds.RowsCount;
var Depth = currentRoot.Depth;
var QuadTree = currentRoot.QuadTree;
var newRoot = new QuadTreeNode(
new Range(startRow, startCol, halfCol * 2, halfRow * 2),
currentRoot.Depth, currentRoot.QuadTree);
newRoot.Nodes.Add(currentRoot);
newRoot.Nodes.Add(new QuadTreeNode(Range.From(
new Position(startRow, startCol + halfCol),
halfRow, halfCol), Depth, QuadTree));
newRoot.Nodes.Add(new QuadTreeNode(Range.From(
new Position(startRow + halfRow, startCol),
halfRow, halfCol), Depth, QuadTree));
newRoot.Nodes.Add(new QuadTreeNode(Range.From(
new Position(startRow + halfRow, startCol + halfCol),
halfRow, halfCol), Depth, QuadTree));
return newRoot;
}
/// <summary>
/// Get the colour for a QuadTreeNode from the hash table or else create a new colour
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
Color GetColor(QuadTreeNode<Item> node)
{
if (m_dictionary.ContainsKey(node))
return m_dictionary[node];
Color color = Utility.RandomColor;
m_dictionary.Add(node, color);
return color;
}
public void CreateNotProportionateNodes()
{
var node = new QuadTreeNode(new Range(1, 1, 1000, 100));
var divider = new ProportioanteSizeNodeDivider();
divider.CreateSubNodes(node);
Assert.AreEqual(2, node.Nodes.Count);
Assert.AreEqual(new Range(1, 1, 500, 100), node.Nodes[0].Bounds);
Assert.AreEqual(new Range(501, 1, 1000, 100), node.Nodes[1].Bounds);
}
public void CreateSubNodes(QuadTreeNode parentNode)
{
// the smallest subnode has an area
if ((parentNode.Bounds.ColumnsCount * parentNode.Bounds.RowsCount) <= 10)
return;
if (IsProportionate(parentNode) == false)
CreateNotProportionate(parentNode);
else
CreateProportionate(parentNode);
}
private void CreateNotProportionate(QuadTreeNode parentNode)
{
var m_bounds = parentNode.Bounds;
int startRow = m_bounds.Start.Row;
int startCol = m_bounds.Start.Column;
int halfCol = m_bounds.ColumnsCount;
int halfRow = (m_bounds.RowsCount/ 2);
var Depth = parentNode.Depth;
var QuadTree = parentNode.QuadTree;
parentNode.Nodes.Add(new QuadTreeNode(Range.From(m_bounds.Start, halfRow, halfCol), Depth, QuadTree));
parentNode.Nodes.Add(new QuadTreeNode(Range.From(
new Position(startRow + halfRow, startCol),
halfRow, halfCol), Depth, QuadTree));
}
private void CreateProportionate(QuadTreeNode parentNode)
{
var m_bounds = parentNode.Bounds;
int startRow = m_bounds.Start.Row;
int startCol = m_bounds.Start.Column;
int halfCol = (m_bounds.ColumnsCount / 2);
int halfRow = (m_bounds.RowsCount / 2);
var Depth = parentNode.Depth;
var QuadTree = parentNode.QuadTree;
parentNode.Nodes.Add(new QuadTreeNode(Range.From(m_bounds.Start, halfRow, halfCol), Depth, QuadTree));
parentNode.Nodes.Add(new QuadTreeNode(Range.From(
new Position(startRow, startCol + halfCol),
halfRow, halfCol), Depth, QuadTree));
parentNode.Nodes.Add(new QuadTreeNode(Range.From(
new Position(startRow + halfRow, startCol),
halfRow, halfCol), Depth, QuadTree));
parentNode.Nodes.Add(new QuadTreeNode(Range.From(
new Position(startRow + halfRow, startCol + halfCol),
halfRow, halfCol), Depth, QuadTree));
}
/// <summary>
///
/// </summary>
/// <param name="rectangle"></param>
public QuadTree(Range rectangle)
{
m_rectangle = rectangle;
m_root = new QuadTreeNode(m_rectangle, 0, this);
QuadTreeNodeDivider = new ProportioanteSizeNodeDivider();
}
public QuadTreeNode CreateNewRoot(QuadTreeNode currentRoot)
{
return(new ProportioanteSizeNodeDivider().CreateNewRoot(currentRoot));
}
public void IsProportionateTrue()
{
var node = new QuadTreeNode(new Range(0, 0, 1000, 500));
var divider = new ProportioanteSizeNodeDivider();
Assert.AreEqual(true, divider.IsProportionate(node));
}
/// <summary>
/// Double ocuppied space by adding one more root level node.
/// Current root will go under the new root
/// </summary>
public void Grow()
{
this.m_root = this.QuadTreeNodeDivider.CreateNewRoot(m_root);
this.m_rectangle = m_root.Bounds;
}
/// <summary>
///
/// </summary>
/// <param name="rectangle"></param>
public QuadTree(RectangleF rectangle)
{
m_rectangle = rectangle;
m_root = new QuadTreeNode <T>(m_rectangle);
}
/// <summary>
///
/// </summary>
/// <param name="rectangle"></param>
public QuadTree(Range rectangle)
{
m_rectangle = rectangle;
m_root = new QuadTreeNode(m_rectangle, 0, this);
QuadTreeNodeDivider = new ProportioanteSizeNodeDivider();
}
public QuadTree(Rectangle bound)
{
m_rectangle = bound;
m_root = new QuadTreeNode(m_rectangle);
}
public QuadTreeNode CreateNewRoot(QuadTreeNode currentRoot)
{
return new ProportioanteSizeNodeDivider().CreateNewRoot(currentRoot);
}
/// <summary>
/// Double ocuppied space by adding one more root level node.
/// Current root will go under the new root
/// </summary>
public void Grow()
{
this.m_root = this.QuadTreeNodeDivider.CreateNewRoot(m_root);
this.m_rectangle = m_root.Bounds;
}
public bool IsProportionate(QuadTreeNode node)
{
if (node.Bounds.ColumnsCount * 2 < node.Bounds.RowsCount)
return false;
return true;
}
public void CreateSubNodes(QuadTreeNode parentNode)
{
var m_bounds = parentNode.Bounds;
// the smallest subnode has an area
if ((parentNode.Bounds.ColumnsCount * parentNode.Bounds.RowsCount) <= 10)
return;
int startRow = m_bounds.Start.Row;
int startCol = m_bounds.Start.Column;
int halfCol = (m_bounds.ColumnsCount / 2);
int halfRow = (m_bounds.RowsCount/ 2);
var Depth = parentNode.Depth;
var QuadTree = parentNode.QuadTree;
parentNode.Nodes.Add(new QuadTreeNode(Range.From(m_bounds.Start, halfRow, halfCol), Depth, QuadTree));
parentNode.Nodes.Add(new QuadTreeNode(Range.From(
new Position(startRow, startCol + halfCol),
halfRow, halfCol), Depth, QuadTree));
parentNode.Nodes.Add(new QuadTreeNode(Range.From(
new Position(startRow + halfRow, startCol),
halfRow, halfCol), Depth, QuadTree));
parentNode.Nodes.Add(new QuadTreeNode(Range.From(
new Position(startRow + halfRow, startCol + halfCol),
halfRow, halfCol), Depth, QuadTree));
}
