class TestFreeQuadTileGridEquivalence(unittest.TestCase):

    def setUp(self):
        self.ftg = FreeTileGrid([8, 4, 2, 1], tile_size=0.125)
        self.qtg = QuadTileGrid(max_zoom=3)

    def test_children(self):
        tc = TileCoord(2, 2, 3)
        self.assertEqual(sorted(self.ftg.children(tc)), sorted(self.qtg.children(tc)))

    def test_children_root(self):
        tc = TileCoord(0, 0, 0)
        self.assertEqual(sorted(self.ftg.children(tc)), sorted(self.qtg.children(tc)))

    def test_extent(self):
        for z in xrange(0, 4):
            for x in xrange(0, 1 << z):
                for y in xrange(0, 1 << z):
                    tilecoord = TileCoord(z, x, y)
                    self.assertEqual(self.ftg.extent(tilecoord), self.qtg.extent(tilecoord))

    def test_parent(self):
        tc = TileCoord(3, 3, 5)
        self.assertEqual(self.ftg.parent(tc), self.qtg.parent(tc))

    def test_roots(self):
        self.assertEqual(list(self.ftg.roots()), list(self.qtg.roots()))

    def test_zs(self):
        self.assertEqual(list(self.ftg.zs()), list(self.qtg.zs()))
Beispiel #2
0
class TestFreeQuadTileGridEquivalence(unittest.TestCase):

    def setUp(self):
        self.ftg = FreeTileGrid([8, 4, 2, 1], tile_size=0.125)
        self.qtg = QuadTileGrid(max_zoom=3)

    def test_children(self):
        tc = TileCoord(2, 2, 3)
        assert sorted(self.ftg.children(tc)) == sorted(self.qtg.children(tc))

    def test_children_root(self):
        tc = TileCoord(0, 0, 0)
        assert sorted(self.ftg.children(tc)) == sorted(self.qtg.children(tc))

    def test_extent(self):
        for z in xrange(0, 4):
            for x in xrange(0, 1 << z):
                for y in xrange(0, 1 << z):
                    tilecoord = TileCoord(z, x, y)
                    assert self.ftg.extent(tilecoord) == self.qtg.extent(tilecoord)

    def test_parent(self):
        tc = TileCoord(3, 3, 5)
        assert self.ftg.parent(tc) == self.qtg.parent(tc)

    def test_roots(self):
        assert list(self.ftg.roots()) == list(self.qtg.roots())

    def test_zs(self):
        assert list(self.ftg.zs()) == list(self.qtg.zs())
class TestFreeTileGrid(unittest.TestCase):

    def setUp(self):
        self.resolutions = (1000, 999, 500, 250, 125, 123, 111, 100, 50, 25, 10)
        self.ftg = FreeTileGrid(self.resolutions)

    def test_factors(self):
        for i in range(len(self.resolutions)):
            for child_z in self.ftg.child_zs[i]:
                self.assertEquals(self.resolutions[i] % self.resolutions[child_z], 0)

    def test_root_parents(self):
        for root_z in set(root.z for root in self.ftg.roots()):
            self.assertEquals(self.ftg.parent(TileCoord(root_z, 0, 0)), None)

    def test_root_zero(self):
        self.assertEquals(self.ftg.parent(TileCoord(0, 0, 0)), None)

    def test_zs(self):
        self.assertEquals(list(self.ftg.zs()), [e for e in range(len(self.resolutions))])
Beispiel #4
0
class TestFreeTileGrid(unittest.TestCase):

    def setUp(self):
        self.resolutions = (1000, 999, 500, 250, 125, 123, 111, 100, 50, 25, 10)
        self.ftg = FreeTileGrid(self.resolutions)

    def test_factors(self):
        for i in range(len(self.resolutions)):
            for child_z in self.ftg.child_zs[i]:
                assert self.resolutions[i] % self.resolutions[child_z] == 0

    def test_root_parents(self):
        for root_z in set(root.z for root in self.ftg.roots()):
            assert self.ftg.parent(TileCoord(root_z, 0, 0)) is None

    def test_root_zero(self):
        assert self.ftg.parent(TileCoord(0, 0, 0)) is None

    def test_zs(self):
        assert list(self.ftg.zs()) == [e for e in range(len(self.resolutions))]
Beispiel #5
0
class TestFreeTileGrid(unittest.TestCase):
    def setUp(self) -> None:
        self.resolutions = (1000, 999, 500, 250, 125, 123, 111, 100, 50, 25,
                            10)
        self.ftg = FreeTileGrid(self.resolutions)

    def test_factors(self) -> None:
        for i in range(len(self.resolutions)):
            for child_z in self.ftg.child_zs[i]:
                assert self.resolutions[i] % self.resolutions[child_z] == 0

    def test_root_parents(self) -> None:
        for root_z in {root.z for root in self.ftg.roots()}:
            assert self.ftg.parent(TileCoord(root_z, 0, 0)) is None

    def test_root_zero(self) -> None:
        assert self.ftg.parent(TileCoord(0, 0, 0)) is None

    def test_zs(self) -> None:
        assert list(self.ftg.zs()) == [e for e in range(len(self.resolutions))]
Beispiel #6
0
class TestFreeTileGrid(unittest.TestCase):

    def setUp(self):
        self.resolutions = (1000, 999, 500, 250, 125, 123, 111, 100, 50, 25, 10)
        self.ftg = FreeTileGrid(self.resolutions)

    def test_factors(self):
        for i, resolution in enumerate(self.resolutions):
            for child_z in self.ftg.child_zs[i]:
                self.assertEquals(self.resolutions[i] % self.resolutions[child_z], 0)

    def test_root_parents(self):
        for root_z in set(root.z for root in self.ftg.roots()):
            self.assertEquals(self.ftg.parent(TileCoord(root_z, 0, 0)), None)

    def test_root_zero(self):
        self.assertEquals(self.ftg.parent(TileCoord(0, 0, 0)), None)

    def test_zs(self):
        self.assertEquals(list(self.ftg.zs()), range(len(self.resolutions)))