示例#1
0
class Test_tiled_overlapping_tiles:
    def setup_class(self):
        self.qt = Node(0, 0, 90, 90)
        # put a 9x9 tile on every 3 horizontal and vertical units
        [
            self.qt.insert(Rectangle(x, y, x + 9, y + 9))
            for x in range(0, 80, 3) for y in range(0, 80, 3)
        ]
        assert len(self.qt.get_children()) == 27 * 27

    ### enclose ###

    def enclose(self, x1, y1, x2, y2):
        return self.qt.get_enclosed_children((x1, y1, x2, y2))

    def test_enclose_all(self):
        assert len(self.enclose(-1, -1, 91, 91)) == 27 * 27
        assert len(self.enclose(0, 0, 90, 90)) == 27 * 27

    def test_enclose_each_30x30(self):
        for x in range(0, 51, 3):  # some couldn't fit near the end bounds
            for y in range(0, 51, 3):  # so skip looking for them
                assert len(self.enclose(x, y, x + 30, y + 30)) == 64

    ### overlap ###

    def overlap(self, x1, y1, x2, y2):
        return self.qt.get_overlapped_children((x1, y1, x2, y2))

    def test_overlap_all(self):
        assert len(self.overlap(-1, -1, 91, 91)) == 27 * 27
        assert len(self.overlap(0, 0, 91, 91)) == 27 * 27
        assert len(self.overlap(2, 2, 88, 98)) == 27 * 27

    ### under_point ###
    # this implicitly tests get_overlapped_children, skipped testing that
    # explicitly since it'd be too verbose

    def under(self, x, y):
        return self.qt.get_children_under_point(x, y)

    def test_under_point_each(self):
        # for these values it must be 9 rectangles under point, however for
        # some other values it might be up to 16 (at boundaries, e.g. at 9x9)
        for x in range(7, 80, 9):
            for y in range(7, 80, 9):
                assert len(self.under(x, y)) == 9
        assert len(self.under(9, 9)) == 16
示例#2
0
class Test_tiled_overlapping_tiles:
    def setup_class(self):
        self.qt = Node(0, 0, 90, 90)
        # put a 9x9 tile on every 3 horizontal and vertical units
        [self.qt.insert(Rectangle(x, y, x + 9, y + 9))
         for x in range(0, 80, 3)
         for y in range(0, 80, 3)]
        assert len(self.qt.get_children()) == 27 * 27

    ### enclose ###

    def enclose(self, x1, y1, x2, y2):
        return self.qt.get_enclosed_children((x1, y1, x2, y2))

    def test_enclose_all(self):
        assert len(self.enclose(-1, -1, 91, 91)) == 27 * 27
        assert len(self.enclose(0, 0, 90, 90)) == 27 * 27

    def test_enclose_each_30x30(self):
        for x in range(0, 51, 3):      # some couldn't fit near the end bounds
            for y in range(0, 51, 3):  # so skip looking for them
                assert len(self.enclose(x, y, x + 30, y + 30)) == 64

    ### overlap ###

    def overlap(self, x1, y1, x2, y2):
        return self.qt.get_overlapped_children((x1, y1, x2, y2))

    def test_overlap_all(self):
        assert len(self.overlap(-1, -1, 91, 91)) == 27 * 27
        assert len(self.overlap(0, 0, 91, 91)) == 27 * 27
        assert len(self.overlap(2, 2, 88, 98)) == 27 * 27

    ### under_point ###
    # this implicitly tests get_overlapped_children, skipped testing that
    # explicitly since it'd be too verbose

    def under(self, x, y):
        return self.qt.get_children_under_point(x, y)

    def test_under_point_each(self):
        # for these values it must be 9 rectangles under point, however for
        # some other values it might be up to 16 (at boundaries, e.g. at 9x9)
        for x in range(7, 80, 9):
            for y in range(7, 80, 9):
                assert len(self.under(x, y)) == 9
        assert len(self.under(9, 9)) == 16
示例#3
0
class Test_tiled:
    def setup_class(self):
        self.qt = Node(0, 0, 1000, 1000)
        # fill with 10x10 squares
        [
            self.qt.insert(Rectangle(x, y, x + 10, y + 10))
            for x in range(0, 1000, 10) for y in range(0, 1000, 10)
        ]
        assert len(self.qt.get_children()) == 10000

    ### enclose ###

    def enclose(self, x1, y1, x2, y2):
        return self.qt.get_enclosed_children((x1, y1, x2, y2))

    def test_enclose_all(self):
        assert len(self.enclose(-1, -1, 1001, 1001)) == 10000
        assert len(self.enclose(0, 0, 1000, 1000)) == 10000

    def test_enclose_each(self):
        for x in range(0, 1000, 10):
            for y in range(0, 1000, 10):
                exp = Rectangle(x, y, x + 10, y + 10)
                assert self.enclose(x - 1, y - 1, x + 11, y + 11) == [exp]

    def test_enclose_some(self):
        got = sorted(self.enclose(377, 499, 401, 601), key=key)
        exp = sorted([
            Rectangle(380, 500, 390, 510),
            Rectangle(390, 500, 400, 510),
            Rectangle(380, 510, 390, 520),
            Rectangle(390, 510, 400, 520),
            Rectangle(380, 520, 390, 530),
            Rectangle(390, 520, 400, 530),
            Rectangle(380, 530, 390, 540),
            Rectangle(390, 530, 400, 540),
            Rectangle(380, 540, 390, 550),
            Rectangle(390, 540, 400, 550),
            Rectangle(380, 550, 390, 560),
            Rectangle(390, 550, 400, 560),
            Rectangle(380, 560, 390, 570),
            Rectangle(390, 560, 400, 570),
            Rectangle(380, 570, 390, 580),
            Rectangle(390, 570, 400, 580),
            Rectangle(380, 580, 390, 590),
            Rectangle(390, 580, 400, 590),
            Rectangle(380, 590, 390, 600),
            Rectangle(390, 590, 400, 600),
        ],
                     key=key)
        assert got == exp

    ### overlap ###

    def overlap(self, x1, y1, x2, y2):
        return self.qt.get_overlapped_children((x1, y1, x2, y2))

    def test_overlap_all(self):
        assert len(self.overlap(-1, -1, 1001, 1001)) == 10000
        assert len(self.overlap(0, 0, 1000, 1000)) == 10000
        assert len(self.overlap(8, 8, 992, 992)) == 10000

    def test_overlap_each(self):
        # overlap at the corner where 4 rectangles meet
        for x in range(10, 1000, 10):
            for y in range(10, 1000, 10):
                exp = sorted([
                    Rectangle(x - 10, y - 10, x, y),
                    Rectangle(x - 10, y, x, y + 10),
                    Rectangle(x, y, x + 10, y + 10),
                    Rectangle(x, y - 10, x + 10, y),
                ],
                             key=key)
                got = sorted(self.overlap(x - 1, y - 1, x + 1, y + 1), key=key)
                assert got == exp

    def test_overlap_some(self):
        got = sorted(self.overlap(387, 501, 391, 591), key=key)
        exp = sorted([
            Rectangle(380, 500, 390, 510),
            Rectangle(390, 500, 400, 510),
            Rectangle(380, 510, 390, 520),
            Rectangle(390, 510, 400, 520),
            Rectangle(380, 520, 390, 530),
            Rectangle(390, 520, 400, 530),
            Rectangle(380, 530, 390, 540),
            Rectangle(390, 530, 400, 540),
            Rectangle(380, 540, 390, 550),
            Rectangle(390, 540, 400, 550),
            Rectangle(380, 550, 390, 560),
            Rectangle(390, 550, 400, 560),
            Rectangle(380, 560, 390, 570),
            Rectangle(390, 560, 400, 570),
            Rectangle(380, 570, 390, 580),
            Rectangle(390, 570, 400, 580),
            Rectangle(380, 580, 390, 590),
            Rectangle(390, 580, 400, 590),
            Rectangle(380, 590, 390, 600),
            Rectangle(390, 590, 400, 600),
        ],
                     key=key)
        assert got == exp

    ### under_point ###

    def under(self, x, y):
        return self.qt.get_children_under_point(x, y)

    def test_under_point_each(self):
        for x in range(10, 1000, 10):
            for y in range(10, 1000, 10):
                exp = [Rectangle(x, y, x + 10, y + 10)]
                got = self.under(x + randint(1, 9), y + randint(1, 9))
                assert got == exp
示例#4
0
class Test_tiled:
    def setup_class(self):
        self.qt = Node(0, 0, 1000, 1000)
        # fill with 10x10 squares
        [self.qt.insert(Rectangle(x, y, x + 10, y + 10))
         for x in range(0, 1000, 10)
         for y in range(0, 1000, 10)]
        assert len(self.qt.get_children()) == 10000

    ### enclose ###

    def enclose(self, x1, y1, x2, y2):
        return self.qt.get_enclosed_children((x1, y1, x2, y2))

    def test_enclose_all(self):
        assert len(self.enclose(-1, -1, 1001, 1001)) == 10000
        assert len(self.enclose(0, 0, 1000, 1000)) == 10000

    def test_enclose_each(self):
        for x in range(0, 1000, 10):
            for y in range(0, 1000, 10):
                exp = Rectangle(x, y, x + 10, y + 10)
                assert self.enclose(x - 1, y - 1, x + 11, y + 11) == [exp]

    def test_enclose_some(self):
        got = sorted(self.enclose(377, 499, 401, 601), key=key)
        exp = sorted([
            Rectangle(380, 500, 390, 510), Rectangle(390, 500, 400, 510),
            Rectangle(380, 510, 390, 520), Rectangle(390, 510, 400, 520),
            Rectangle(380, 520, 390, 530), Rectangle(390, 520, 400, 530),
            Rectangle(380, 530, 390, 540), Rectangle(390, 530, 400, 540),
            Rectangle(380, 540, 390, 550), Rectangle(390, 540, 400, 550),
            Rectangle(380, 550, 390, 560), Rectangle(390, 550, 400, 560),
            Rectangle(380, 560, 390, 570), Rectangle(390, 560, 400, 570),
            Rectangle(380, 570, 390, 580), Rectangle(390, 570, 400, 580),
            Rectangle(380, 580, 390, 590), Rectangle(390, 580, 400, 590),
            Rectangle(380, 590, 390, 600), Rectangle(390, 590, 400, 600),
        ], key=key)
        assert got == exp

    ### overlap ###

    def overlap(self, x1, y1, x2, y2):
        return self.qt.get_overlapped_children((x1, y1, x2, y2))

    def test_overlap_all(self):
        assert len(self.overlap(-1, -1, 1001, 1001)) == 10000
        assert len(self.overlap(0, 0, 1000, 1000)) == 10000
        assert len(self.overlap(8, 8, 992, 992)) == 10000

    def test_overlap_each(self):
        # overlap at the corner where 4 rectangles meet
        for x in range(10, 1000, 10):
            for y in range(10, 1000, 10):
                exp = sorted([
                    Rectangle(x - 10, y - 10, x, y),
                    Rectangle(x - 10, y, x, y + 10),
                    Rectangle(x, y, x + 10, y + 10),
                    Rectangle(x, y - 10, x + 10, y),
                ], key=key)
                got = sorted(self.overlap(x - 1, y - 1, x + 1, y + 1), key=key)
                assert got == exp

    def test_overlap_some(self):
        got = sorted(self.overlap(387, 501, 391, 591), key=key)
        exp = sorted([
            Rectangle(380, 500, 390, 510), Rectangle(390, 500, 400, 510),
            Rectangle(380, 510, 390, 520), Rectangle(390, 510, 400, 520),
            Rectangle(380, 520, 390, 530), Rectangle(390, 520, 400, 530),
            Rectangle(380, 530, 390, 540), Rectangle(390, 530, 400, 540),
            Rectangle(380, 540, 390, 550), Rectangle(390, 540, 400, 550),
            Rectangle(380, 550, 390, 560), Rectangle(390, 550, 400, 560),
            Rectangle(380, 560, 390, 570), Rectangle(390, 560, 400, 570),
            Rectangle(380, 570, 390, 580), Rectangle(390, 570, 400, 580),
            Rectangle(380, 580, 390, 590), Rectangle(390, 580, 400, 590),
            Rectangle(380, 590, 390, 600), Rectangle(390, 590, 400, 600),
        ], key=key)
        assert got == exp

    ### under_point ###

    def under(self, x, y):
        return self.qt.get_children_under_point(x, y)

    def test_under_point_each(self):
        for x in range(10, 1000, 10):
            for y in range(10, 1000, 10):
                exp = [Rectangle(x, y, x + 10, y + 10)]
                got = self.under(x + randint(1, 9), y + randint(1, 9))
                assert got == exp