Пример #1
0
 /// <summary>
 /// Internal helper function for computing intersections.
 /// </summary>
 private static bool IntersectHorizontal(ref RCNumRectangle lRect, ref RCNumRectangle rRect, out RCNumber intersectLeft, out RCNumber intersectRight)
 {
     if ((lRect.Left <= rRect.Left && rRect.Left < lRect.Right && lRect.Right <= rRect.Right))
     {
         intersectLeft  = rRect.Left;
         intersectRight = lRect.Right;
         return(true);
     }
     else if (rRect.Left <= lRect.Left && lRect.Left < lRect.Right && lRect.Right <= rRect.Right)
     {
         intersectLeft  = lRect.Left;
         intersectRight = lRect.Right;
         return(true);
     }
     else if (rRect.Left <= lRect.Left && lRect.Left < rRect.Right && rRect.Right <= lRect.Right)
     {
         intersectLeft  = lRect.Left;
         intersectRight = rRect.Right;
         return(true);
     }
     else
     {
         intersectLeft  = 0;
         intersectRight = 0;
         return(false);
     }
 }
Пример #2
0
 /// <summary>
 /// Internal helper function for computing intersections.
 /// </summary>
 private static bool IntersectVertical(ref RCNumRectangle lRect, ref RCNumRectangle rRect, out RCNumber intersectTop, out RCNumber intersectBottom)
 {
     if (lRect.Top <= rRect.Top && rRect.Top < lRect.Bottom && lRect.Bottom <= rRect.Bottom)
     {
         intersectTop    = rRect.Top;
         intersectBottom = lRect.Bottom;
         return(true);
     }
     else if (rRect.Top <= lRect.Top && lRect.Top < lRect.Bottom && lRect.Bottom <= rRect.Bottom)
     {
         intersectTop    = lRect.Top;
         intersectBottom = lRect.Bottom;
         return(true);
     }
     else if (rRect.Top <= lRect.Top && lRect.Top < rRect.Bottom && rRect.Bottom <= lRect.Bottom)
     {
         intersectTop    = lRect.Top;
         intersectBottom = rRect.Bottom;
         return(true);
     }
     else
     {
         intersectTop    = 0;
         intersectBottom = 0;
         return(false);
     }
 }
Пример #3
0
        /// <summary>
        /// Subdivides this BspSearchTreeNode if necessary.
        /// </summary>
        /// <remarks>Subdivision is only allowed in case of leaf-nodes.</remarks>
        private void Subdivide()
        {
            if (!this.isLeaf)
            {
                throw new InvalidOperationException("Only leaf-nodes can be subdivided!");
            }

            this.isLeaf = false;
            if (this.firstChild == null || this.secondChild == null)
            {
                /// Children have to be created.
                RCNumRectangle firstChildArea = this.area.Width > this.area.Height
                                              ? new RCNumRectangle(this.area.X, this.area.Y, this.area.Width / 2, this.area.Height)
                                              : new RCNumRectangle(this.area.X, this.area.Y, this.area.Width, this.area.Height / 2);
                RCNumRectangle secondChildArea = this.area.Width > this.area.Height
                                               ? firstChildArea + new RCNumVector(firstChildArea.Width, 0)
                                               : firstChildArea + new RCNumVector(0, firstChildArea.Height);
                this.firstChild  = new BspSearchTreeNode <T>(firstChildArea, this.capacity, this.minSize);
                this.secondChild = new BspSearchTreeNode <T>(secondChildArea, this.capacity, this.minSize);
            }
            else
            {
                /// Children already exist.
                this.firstChild.isLeaf  = true;
                this.secondChild.isLeaf = true;
                this.firstChild.contents.Clear();
                this.secondChild.contents.Clear();
            }
        }
Пример #4
0
        /// <summary>
        /// Returns a third RCNumRectangle that represents the intersection of two other RCRectangles.
        /// If there is no intersection, RCNumRectangle.Undefined is returned.
        /// </summary>
        /// <param name="lRect">An RCNumRectangle to intersect.</param>
        /// <param name="rRect">An RCNumRectangle to intersect.</param>
        /// <returns>
        /// An RCNumRectangle that is the intersection of lRect and rRect or RCNumRectangle.Undefined if there is no intersection.
        /// </returns>
        public static RCNumRectangle Intersect(RCNumRectangle lRect, RCNumRectangle rRect)
        {
            if (!lRect.isDefined)
            {
                throw new ArgumentNullException("lRect");
            }
            if (!rRect.isDefined)
            {
                throw new ArgumentNullException("rRect");
            }

            RCNumber intersectLeft, intersectRight, intersectTop, intersectBottom;

            /// Compute the horizontal coordinates of the intersection
            if (!IntersectHorizontal(ref lRect, ref rRect, out intersectLeft, out intersectRight) &&
                !IntersectHorizontal(ref rRect, ref lRect, out intersectLeft, out intersectRight))
            {
                return(RCNumRectangle.Undefined);
            }

            /// Compute the vertical coordinates of the intersection
            if (!IntersectVertical(ref lRect, ref rRect, out intersectTop, out intersectBottom) &&
                !IntersectVertical(ref rRect, ref lRect, out intersectTop, out intersectBottom))
            {
                return(RCNumRectangle.Undefined);
            }

            return(new RCNumRectangle(intersectLeft, intersectTop, intersectRight - intersectLeft, intersectBottom - intersectTop));
        }
Пример #5
0
 /// <summary>
 /// Collects every content attached to this BspSearchTreeNode inside the given rectangular area.
 /// </summary>
 /// <param name="area">The rectangular area.</param>
 /// <param name="outputList">
 /// A list that contains every content attached to this BspSearchTreeNode inside the given rectangular area.
 /// </param>
 public void CollectContents(RCNumRectangle area, ref RCSet <T> outputList)
 {
     if (this.isLeaf)
     {
         /// Leaf node -> collect the contents inside the given selection box.
         foreach (T content in this.contents)
         {
             if (content.BoundingBox.IntersectsWith(area))
             {
                 outputList.Add(content);
             }
         }
     }
     else
     {
         /// Not a leaf node -> propagate the call to the appropriate child(ren).
         if (this.firstChild.area.IntersectsWith(area))
         {
             this.firstChild.CollectContents(area, ref outputList);
         }
         if (this.secondChild.area.IntersectsWith(area))
         {
             this.secondChild.CollectContents(area, ref outputList);
         }
     }
 }
Пример #6
0
 /// <summary>
 /// Constructs a BspSearchTreeNode instance.
 /// </summary>
 /// <param name="area">The rectangular area covered by this BspSearchTreeNode.</param>
 /// <param name="capacity">The maximum number of contents this node can hold without subdivision.</param>
 /// <param name="minSize">The minimum size of a BSP-node.</param>
 public BspSearchTreeNode(RCNumRectangle area, int capacity, int minSize)
 {
     this.contents    = new RCSet <T>();
     this.isLeaf      = true;
     this.capacity    = capacity;
     this.minSize     = minSize;
     this.area        = area;
     this.firstChild  = null;
     this.secondChild = null;
 }
Пример #7
0
        /// <see cref="ISearchTree<T>.GetContents"/>
        public RCSet <T> GetContents(RCNumRectangle area)
        {
            if (area == RCNumRectangle.Undefined)
            {
                throw new ArgumentNullException("area");
            }

            RCSet <T> retList = new RCSet <T>();

            this.rootNode.CollectContents(area, ref retList);
            return(retList);
        }
Пример #8
0
        /// <summary>
        /// Replaces this RCNumRectangle with the intersection of itself and the specified Rectangle.
        /// </summary>
        /// <param name="other">The other RCNumRectangle to intersect with.</param>
        /// <remarks>
        /// If this and other RCRectangles don't intersect each other, then this RCNumRectangle becomes RCNumRectangle.Undefined.
        /// </remarks>
        public void Intersect(RCNumRectangle other)
        {
            if (!this.isDefined)
            {
                throw new InvalidOperationException("Illegal use of undefined RCNumRectangle!");
            }
            if (!other.isDefined)
            {
                throw new ArgumentNullException("other");
            }

            this = RCNumRectangle.Intersect(this, other);
        }
Пример #9
0
        /// <summary>
        /// Determines if this RCNumRectangle intersects with rect.
        /// </summary>
        /// <param name="rect">The RCNumRectangle to test.</param>
        /// <returns>True if there is any intersection, false otherwise.</returns>
        public bool IntersectsWith(RCNumRectangle rect)
        {
            if (!this.isDefined)
            {
                throw new InvalidOperationException("Illegal use of undefined RCNumRectangle!");
            }
            if (!rect.isDefined)
            {
                throw new ArgumentNullException("rect");
            }

            return((this.Left < rect.Right) && (this.Right > rect.Left) && (this.Top < rect.Bottom) && (this.Bottom > rect.Top));
        }
Пример #10
0
        /// <summary>
        /// Initializes a new RCNumRectangle with the specified RCNumRectangle.
        /// </summary>
        /// <param name="other">The RCNumRectangle to initialize with.</param>
        public RCNumRectangle(RCNumRectangle other)
        {
            if (!other.isDefined)
            {
                throw new ArgumentNullException("other");
            }

            this.isDefined = true;
            this.x         = other.x;
            this.y         = other.y;
            this.width     = other.width;
            this.height    = other.height;
        }
Пример #11
0
        /// <summary>
        /// Determines if the rectangular region represented by rect is entirely contained within this RCNumRectangle.
        /// </summary>
        /// <param name="rect">The RCNumRectangle to test.</param>
        /// <returns>True if the rectangular region represented by rect is entirely contained within this RCNumRectangle, false otherwise.</returns>
        public bool Contains(RCNumRectangle rect)
        {
            if (!this.isDefined)
            {
                throw new InvalidOperationException("Illegal use of undefined RCNumRectangle!");
            }
            if (!rect.isDefined)
            {
                throw new ArgumentNullException("rect");
            }

            return(this.Contains(rect.x, rect.y) &&
                   this.Contains(rect.x + rect.width - new RCNumber(1), rect.y + rect.height - new RCNumber(1)));
        }
Пример #12
0
        /// <summary>
        /// Constructs a BspSearchTree instance.
        /// </summary>
        /// <param name="area">The rectangular area covered by this search tree.</param>
        /// <param name="nodeCapacity">The maximum number of contents a BSP-tree node can hold without subdivision.</param>
        /// <param name="minNodeSize">The minimum size of a BSP-node.</param>
        public BspSearchTree(RCNumRectangle area, int nodeCapacity, int minNodeSize)
        {
            if (area == RCNumRectangle.Undefined)
            {
                throw new ArgumentNullException("area");
            }
            if (nodeCapacity <= 0)
            {
                throw new ArgumentOutOfRangeException("nodeCapacity", "Node capacity must be greater than 0!");
            }
            if (minNodeSize <= 0)
            {
                throw new ArgumentOutOfRangeException("minNodeSize", "Minimum BSP-node size must be positive!");
            }

            this.attachedContents = new RCSet <T>();
            this.rootNode         = new BspSearchTreeNode <T>(area, nodeCapacity, minNodeSize);
        }
Пример #13
0
 /// <summary>
 /// Checks whether this RCNumRectangle has the same location and size as the specified RCNumRectangle.
 /// </summary>
 /// <param name="other">The RCNumRectangle to test.</param>
 /// <returns>True if other RCNumRectangle has same location and size as this RCNumRectangle.</returns>
 public bool Equals(RCNumRectangle other)
 {
     return((!this.isDefined && !other.isDefined) ||
            (this.isDefined && other.isDefined && this.x == other.x && this.y == other.y &&
             this.width == other.width && this.height == other.height));
 }