Пример #1
0
        public void InsertAndRemoveManyOverlapping()
        {
            var items = new List <MockQuadtreeItem>
            {
                new MockQuadtreeItem(1, new RectangleF(0, 0, 1, 1)),
                new MockQuadtreeItem(2, new RectangleF(0, 0, 1.25f, 1.25f)),
                new MockQuadtreeItem(3, new RectangleF(0, 0, 1.5f, 1.5f)),
                new MockQuadtreeItem(4, new RectangleF(0, 0, 1.75f, 1.75f)),
                new MockQuadtreeItem(5, new RectangleF(0, 0, 2f, 2f)),
            };

            var quadtree = new Quadtree <MockQuadtreeItem>(new RectangleF(0, 0, 10, 10));

            foreach (var item in items)
            {
                quadtree.Insert(item);
            }

            Assert.Equal(5, quadtree.FindIntersecting(quadtree.Bounds).Count());

            foreach (var item in items)
            {
                quadtree.Remove(item);
            }

            Assert.Empty(quadtree.FindIntersecting(quadtree.Bounds));
        }
Пример #2
0
        public void CreateAndInsertUnderLimit()
        {
            var quadtree = new Quadtree <MockQuadtreeItem>(new RectangleF(0, 0, 100, 100));

            quadtree.Insert(new MockQuadtreeItem(1, new RectangleF(0, 0, 1, 1)));
            quadtree.Insert(new MockQuadtreeItem(2, new RectangleF(1, 1, 2, 2)));

            var allItems = quadtree.FindIntersecting(quadtree.Bounds).ToList();

            Assert.Equal(2, allItems.Count);
        }
Пример #3
0
        public void InsertAndRemoveNonExistant()
        {
            var quadtree = new Quadtree <MockQuadtreeItem>(new RectangleF(0, 0, 10, 10));

            var item = new MockQuadtreeItem(1, new RectangleF(8, 8, 2, 2));

            quadtree.Insert(item);
            quadtree.Remove(new RectangleF(0, 0, 1, 1));

            Assert.Equal(new[] { item }, quadtree.FindIntersecting(quadtree.Bounds));
        }
Пример #4
0
        public void InsertAndRemove()
        {
            var quadtree = new Quadtree <MockQuadtreeItem>(new RectangleF(0, 0, 10, 10));

            var item = new MockQuadtreeItem(1, new RectangleF(0.5f, 0.5f, 1, 1));

            quadtree.Insert(item);
            quadtree.Remove(item.Bounds);

            Assert.Empty(quadtree.FindIntersecting(quadtree.Bounds));
        }
Пример #5
0
        public void CreateAndInsertOverLimit()
        {
            var quadtree = new Quadtree <MockQuadtreeItem>(new RectangleF(0, 0, 10, 10));

            var items = new[]
            {
                new MockQuadtreeItem(1, new RectangleF(0, 0, 1, 1)),
                new MockQuadtreeItem(2, new RectangleF(1, 2, 1, 1)),
                new MockQuadtreeItem(3, new RectangleF(9, 9, 1, 1)),
                new MockQuadtreeItem(4, new RectangleF(4, 4, 2, 2)),
                new MockQuadtreeItem(5, new RectangleF(3, 3, 1, 1))
            };

            foreach (var item in items)
            {
                quadtree.Insert(item);
            }

            Assert.Equal(items, quadtree.FindIntersecting(quadtree.Bounds).OrderBy(x => x.Id));
        }
Пример #6
0
 public List <BenchQuadtreeItem> QueryAreaQuadtree()
 {
     return(_quadtree.FindIntersecting(_queryArea).ToList());
 }
Пример #7
0
        public void CreateEmpty()
        {
            var quadtree = new Quadtree <MockQuadtreeItem>(new RectangleF(0, 0, 100, 100));

            Assert.Empty(quadtree.FindIntersecting(quadtree.Bounds));
        }