Example #1
0
        public bool Set(ref Point2i point, ref T value)
        {
            var anySet = setInternal(ref point, ref value);

            if (anySet)
            {
                unsubdivide();
            }

            return(anySet);
        }
Example #2
0
        public bool Unset(ref Point2i point)
        {
            var anyUnset = unsetInternal(ref point);

            if (anyUnset)
            {
                unsubdivide();
            }

            return(anyUnset);
        }
Example #3
0
        private bool unsetInternal(ref Point2i point)
        {
            if (!aabb.Contains(point))
            {
                return(false);
            }

            if (Type == QuadType.White)
            {
                return(false);
            }

            if (depth < resolution)
            {
                if (Type != QuadType.Grey)
                {
                    subdivide();
                }
            }
            else
            {
                propagateEvent(EventType.Removing);

                this.value = null;

                return(true);
            }

            foreach (var quad in quads)
            {
                if (quad.unsetInternal(ref point))
                {
                    return(true);
                }
            }

            return(false);

            throw new InvalidOperationException("This is not supposed to happen!");
        }
Example #4
0
        public bool UnsetCircle(Point2i point, int radius)
        {
            var rectSize = (int)(radius / Math.Sqrt(2));
            var testAABB = new AABB2i(
                point - new Point2i(rectSize - 1, rectSize - 1),
                point + new Point2i(rectSize - 1, rectSize - 1));

            bool anyOuterUnset = false;

            for (int i = point.X - radius; i <= point.X + radius; i++)
            {
                for (int j = point.Y - radius; j <= point.Y + radius; j++)
                {
                    var currentPoint = new Point2i(i, j);

                    if (testAABB.Contains(currentPoint))
                    {
                        continue;
                    }

                    if ((point - currentPoint).Length() <= radius)
                    {
                        anyOuterUnset |= unsetInternal(ref currentPoint);
                    }
                }
            }

            var anyAABBUnset = unsetAABBInternal(ref testAABB);

            if (anyOuterUnset || anyAABBUnset)
            {
                unsubdivide();
            }

            return(anyOuterUnset || anyAABBUnset);
        }
Example #5
0
        private bool setInternal(ref Point2i point, ref T value)
        {
            if (isPointOutside(point))
            {
                return(false);
            }

            if (Type == QuadType.Black && this.value.Value.Equals(value))
            {
                return(false);
            }

            if (depth < resolution)
            {
                if (Type != QuadType.Grey)
                {
                    subdivide();
                }
            }
            else
            {
                return(setInternal(ref value));
            }

            foreach (var quad in quads)
            {
                if (quad.setInternal(ref point, ref value))
                {
                    return(true);
                }
            }

            return(false);

            throw new InvalidOperationException("Set didn't fail nor succeed. This is not supposed to happen!");
        }
Example #6
0
 public void Combine(ref AABB2i aabb)
 {
     LowerBound = new Point2i(Math.Min(LowerBound.X, aabb.LowerBound.X), Math.Min(LowerBound.Y, aabb.LowerBound.Y));
     UpperBound = new Point2i(Math.Max(UpperBound.X, aabb.UpperBound.X), Math.Max(UpperBound.Y, aabb.UpperBound.Y));
 }
Example #7
0
 public bool Contains(Point2i point)
 {
     return(point.X >= (LowerBound.X) && point.X < (UpperBound.X) &&
            (point.Y >= (LowerBound.Y) && point.Y < (UpperBound.Y)));
 }
Example #8
0
 public AABB2i(Point2i min, Point2i max)
 {
     LowerBound = min;
     UpperBound = max;
 }
Example #9
0
        public RegionQuadtree <T> ExpandFromCenter()
        {
            if (Type != QuadType.Grey)
            {
                subdivide();
            }

            Action <RegionQuadtree <T>, Action <RegionQuadtree <T> > > doForEach = null;

            doForEach = (qt, f) =>
            {
                f(qt);

                if (qt.Type == QuadType.Grey)
                {
                    foreach (var dir in QDO.Quadrants)
                    {
                        doForEach(qt[dir], f);
                    }
                }
            };

            doForEach(this, (qt) =>
            {
                if (qt.Type == QuadType.Black)
                {
                    qt.propagateEvent(EventType.Removing);
                }
            });

            var newRoot = new RegionQuadtree <T>(resolution + 1);

            newRoot.AutoExpand = AutoExpand;
            newRoot.subdivide();
            foreach (var child in newRoot.quads)
            {
                child.subdivide();
            }

            var offset = new Point2i(newRoot.aabb.Width / 4, newRoot.aabb.Height / 4);

            var offsets = new Dictionary <QuadDirection, Point2i>
            {
                { QuadDirection.NorthWest, new Point2i(quads[0].aabb.Width / 2, quads[0].aabb.Height / 2) },
                { QuadDirection.SouthEast, new Point2i(quads[0].aabb.Width / 2, quads[0].aabb.Height / 2) },
                { QuadDirection.NorthEast, new Point2i(quads[0].aabb.Width / 2, quads[0].aabb.Height / 2) },
                { QuadDirection.SouthWest, new Point2i(quads[0].aabb.Width / 2, quads[0].aabb.Height / 2) },
            };

            // Set children

            Action <RegionQuadtree <T>, RegionQuadtree <T> > expandProcessor = null;

            expandProcessor = (qt, parent) =>
            {
                // Do this
                qt.parent     = parent;
                qt.depth      = qt.parent.depth + 1;
                qt.resolution = qt.parent.resolution;

                // Do children
                if (qt.Type == QuadType.Grey)
                {
                    foreach (var dir in QDO.Quadrants)
                    {
                        switch (dir)
                        {
                        case QuadDirection.NorthWest:
                            qt[dir].aabb.LowerBound = qt.aabb.LowerBound;
                            qt[dir].aabb.UpperBound = qt.aabb.LowerBound + new Point2i(qt.aabb.Width / 2, qt.aabb.Height / 2);
                            break;

                        case QuadDirection.NorthEast:
                            qt[dir].aabb.LowerBound = qt.aabb.LowerBound + new Point2i(qt.aabb.Width / 2, 0);
                            qt[dir].aabb.UpperBound = qt.aabb.LowerBound + new Point2i(qt.aabb.Width, qt.aabb.Height / 2);
                            break;

                        case QuadDirection.SouthEast:
                            qt[dir].aabb.LowerBound = qt.aabb.LowerBound + new Point2i(qt.aabb.Width / 2, qt.aabb.Height / 2);
                            qt[dir].aabb.UpperBound = qt.aabb.LowerBound + new Point2i(qt.aabb.Width, qt.aabb.Height);
                            break;

                        case QuadDirection.SouthWest:
                            qt[dir].aabb.LowerBound = qt.aabb.LowerBound + new Point2i(0, qt.aabb.Height / 2);
                            qt[dir].aabb.UpperBound = qt.aabb.LowerBound + new Point2i(qt.aabb.Width / 2, qt.aabb.Height);
                            break;

                        default:
                            throw new ArgumentException("Invalid direction");
                        }

                        expandProcessor(qt[dir], qt);
                    }
                }
            };

            foreach (var quadDirection in QDO.Quadrants)
            {
                var oldQuad = newRoot[quadDirection][QDO.OpSide(quadDirection)];

                newRoot[quadDirection][QDO.OpSide(quadDirection)] = this[quadDirection];

                var newQuad = newRoot[quadDirection][QDO.OpSide(quadDirection)];

                newQuad.aabb = oldQuad.aabb;
                expandProcessor(newQuad, oldQuad.parent);
            }

            // Call the event
            if (OnExpand != null)
            {
                OnExpand(this, new QuadExpandEventArgs <T>(newRoot, offset));
            }

            // Move events
            // TODO: Test this works properly
            newRoot.OnQuadAdded    = OnQuadAdded;
            OnQuadAdded            = null;
            newRoot.OnQuadRemoving = OnQuadRemoving;
            OnQuadRemoving         = null;
            newRoot.OnQuadChanged  = OnQuadChanged;
            OnQuadChanged          = null;

            doForEach(newRoot, (qt) =>
            {
                if (qt.Type == QuadType.Black)
                {
                    qt.propagateEvent(EventType.Added);
                }
            });

            newRoot.OnExpand = OnExpand;

            return(newRoot);
        }
Example #10
0
 private bool isPointOutside(Point2i point)
 {
     return(!aabb.Contains(point));
 }
Example #11
0
 public bool Unset(Point2i point)
 {
     return(Unset(ref point));
 }
Example #12
0
 public bool Set(Point2i point, T value)
 {
     return(Set(ref point, ref value));
 }
Example #13
0
        public bool SetCircle(Point2i point, int radius, T value)
        {
            var rectSize = (int)(radius / Math.Sqrt(2));
            var testAABB = new AABB2i(point - new Point2i(rectSize, rectSize), point + new Point2i(rectSize, rectSize));

            for (int i = point.X - radius; i <= point.X + radius; i++)
            {
                for (int j = point.Y - radius; j <= point.Y + radius; j++)
                {
                    var currentPoint = new Point2i(i, j);

                    if (testAABB.Contains(currentPoint))
                    {
                        continue;
                    }

                    if ((point - currentPoint).Length() < radius)
                    {
                        if (isPointOutside(currentPoint))
                        {
                            if (findRoot() == this && AutoExpand)
                            {
                                RegionQuadtree <T> newRoot = this;
                                if (newRoot.isPointOutside(currentPoint))
                                {
                                    newRoot = newRoot.ExpandFromCenter();
                                    point  += new Point2i(newRoot.aabb.Width / 4, newRoot.aabb.Height / 4);
                                }

                                return(newRoot.SetCircle(point, radius, value));
                            }
                        }
                    }
                }
            }

            bool anyOuterSet = false;

            for (int i = point.X - radius; i <= point.X + radius; i++)
            {
                for (int j = point.Y - radius; j <= point.Y + radius; j++)
                {
                    var currentPoint = new Point2i(i, j);

                    if (testAABB.Contains(currentPoint))
                    {
                        continue;
                    }

                    if ((point - currentPoint).Length() < radius)
                    {
                        anyOuterSet |= setInternal(ref currentPoint, ref value);
                    }
                }
            }

            var anyAABBSet = setAABBInternal(ref testAABB, ref value);

            if (anyOuterSet || anyAABBSet)
            {
                unsubdivide();
            }

            return(anyOuterSet || anyAABBSet);
        }
Example #14
0
 public QuadExpandEventArgs(RegionQuadtree <T> newRoot, Point2i offset)
 {
     this.newRoot = newRoot;
     this.offset  = offset;
 }