Beispiel #1
0
        private void Relocate(QuadTreeObject <T> item)
        {
            // Are we still inside our parent?
            if (QuadRect.Contains(item.Data.Rect))
            {
                // Good, have we moved inside any of our children?
                if (childTL != null)
                {
                    QuadTreeNode <T> dest = GetDestinationTree(item);
                    if (item.Owner != dest)
                    {
                        // Delete the item from this quad and add it to our child
                        // Note: Do NOT clean during this call, it can potentially delete our destination quad
                        QuadTreeNode <T> formerOwner = item.Owner;
                        Delete(item, false);
                        dest.Insert(item);

                        // Clean up ourselves
                        formerOwner.CleanUpwards();
                    }
                }
            }
            else
            {
                // We don't fit here anymore, move up, if we can
                if (parent != null)
                {
                    parent.Relocate(item);
                }
            }
        }
Beispiel #2
0
        public void Add(T item)
        {
            QuadTreeObject <T> wrappedObject = new QuadTreeObject <T>(item);

            wrappedDictionary.Add(item, wrappedObject);
            quadTreeRoot.Insert(wrappedObject);
        }
Beispiel #3
0
        internal void Insert(QuadTreeObject <T> item)
        {
            // If this quad doesn't contain the items rectangle, do nothing, unless we are the root
            if (!rect.Contains(item.Data.Rect))
            {
                System.Diagnostics.Debug.Assert(parent == null, "We are not the root, and this object doesn't fit here. How did we get here?");
                if (parent == null)
                {
                    // This object is outside of the QuadTree bounds, we should add it at the root level
                    Add(item);
                }
                else
                {
                    return;
                }
            }

            if (objects == null ||
                (childTL == null && objects.Count + 1 <= maxObjectsPerNode))
            {
                // If there's room to add the object, just add it
                Add(item);
            }
            else
            {
                // No quads, create them and bump objects down where appropriate
                if (childTL == null)
                {
                    Subdivide();
                }

                // Find out which tree this object should go in and add it there
                QuadTreeNode <T> destTree = GetDestinationTree(item);
                if (destTree == this)
                {
                    Add(item);
                }
                else
                {
                    destTree.Insert(item);
                }
            }
        }
Beispiel #4
0
        private void Subdivide()
        {
            Point size = new Point(rect.Width / 2, rect.Height / 2);
            Point mid  = new Point(rect.X + size.X, rect.Y + size.Y);

            childTL = new QuadTreeNode <T>(this, new Rectangle(rect.Left, rect.Top, size.X, size.Y));
            childTR = new QuadTreeNode <T>(this, new Rectangle(mid.X, rect.Top, size.X, size.Y));
            childBL = new QuadTreeNode <T>(this, new Rectangle(rect.Left, mid.Y, size.X, size.Y));
            childBR = new QuadTreeNode <T>(this, new Rectangle(mid.X, mid.Y, size.X, size.Y));

            for (int i = 0; i < objects.Count; i++)
            {
                QuadTreeNode <T> destTree = GetDestinationTree(objects[i]);

                if (destTree != this)
                {
                    destTree.Insert(objects[i]);
                    Remove(objects[i]);
                    i--;
                }
            }
        }