torch-geopooling 1.0.0rc3__cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

torch_geopooling/nn.py

@@ -0,0 +1,391 @@
+# Copyright (C) 2024, Yakau Bubnou
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from typing import Optional, Union
+
+import torch
+from shapely.geometry import Polygon
+from torch import Tensor, nn
+
+from torch_geopooling import functional as F
+from torch_geopooling.tiling import Exterior, ExteriorTuple, regular_tiling
+
+__all__ = [
+    "AdaptiveAvgQuadPool2d",
+    "AdaptiveQuadPool2d",
+    "AdaptiveMaxQuadPool2d",
+    "AvgQuadPool2d",
+    "MaxQuadPool2d",
+    "QuadPool2d",
+]
+
+
+_Exterior = Union[Exterior, ExteriorTuple]
+
+
+_exterior_doc = """
+    Note:
+        Input coordinates must be within a specified exterior geometry (including boundaries).
+        For input coordinates outsize of the specified exterior, module throws an exception.
+"""
+
+
+_terminal_group_doc = """
+    Note:
+        A **terminal group** refers to a collection of terminal nodes within the quadtree that
+        share the same parent tile.
+"""
+
+
+class _AdaptiveQuadPool(nn.Module):
+    __doc__ = f"""
+    Args:
+        feature_dim: Size of each feature vector.
+        exterior: Geometrical boundary of the learning space in (X, Y, W, H) format.
+        max_terminal_nodes: Optional maximum number of terminal nodes in a quadtree. Once a
+            maximum is reached, internal nodes are no longer sub-divided and tree stops growing.
+        max_depth: Maximum depth of the quadtree. Default: 17.
+        capacity: Maximum number of inputs, after which a quadtree's node is subdivided and
+            depth of the tree grows. Default: 1.
+        precision: Optional rounding of the input coordinates. Default: 7.
+
+    Shape:
+        - Input: :math:`(*, 2)`, where 2 comprises longitude and latitude coordinates.
+        - Output: :math:`(*, H)`, where * is the input shape and :math:`H = \\text{{feature_dim}}`.
+
+    {_exterior_doc}
+    {_terminal_group_doc}
+    """
+
+    def __init__(
+        self,
+        feature_dim: int,
+        exterior: _Exterior,
+        max_terminal_nodes: Optional[int] = None,
+        max_depth: int = 17,
+        capacity: int = 1,
+        precision: Optional[int] = 7,
+    ) -> None:
+        super().__init__()
+        self.feature_dim = feature_dim
+        self.exterior = tuple(map(float, exterior))
+        self.max_terminal_nodes = max_terminal_nodes
+        self.max_depth = max_depth
+        self.capacity = capacity
+        self.precision = precision
+
+        self.initialize_parameters()
+
+    def initialize_parameters(self) -> None:
+        # The weight for adaptive operation should be sparse, since training operation
+        # results in a dynamic change of the underlying quadtree.
+        weight_size = (self.max_depth, 1 << self.max_depth, 1 << self.max_depth, self.feature_dim)
+        self.weight = nn.Parameter(torch.sparse_coo_tensor(size=weight_size, dtype=torch.float64))
+
+    @property
+    def tiles(self) -> torch.Tensor:
+        """Return tiles of the quadtree."""
+        return self.weight.coalesce().detach().indices().t()[:, :-1]
+
+    def extra_repr(self) -> str:
+        return (
+            "{feature_dim}, "
+            "exterior={exterior}, capacity={capacity}, max_depth={max_depth}, "
+            "precision={precision}".format(**self.__dict__)
+        )
+
+
+class AdaptiveQuadPool2d(_AdaptiveQuadPool):
+    __doc__ = f"""Adaptive lookup index over quadtree decomposition of input 2D coordinates.
+
+    This module constructs an internal lookup quadtree to organize closely situated 2D points.
+    Each terminal node in the resulting quadtree is paired with a weight. Thus, when providing
+    an input coordinate, the module retrieves the corresponding terminal node and returns its
+    associated weight.
+
+    {_AdaptiveQuadPool.__doc__}
+
+    Examples:
+
+    >>> # Feature vectors of size 4 over a 2d space.
+    >>> pool = nn.AdaptiveQuadPool2d(4, (-10, -5, 20, 10))
+    >>> # Grow tree up to 4-th level and sub-divides a node after 8 coordinates in a quad.
+    >>> pool = nn.AdaptiveQuadPool2d(4, (-10, -5, 20, 10), max_depth=4, capacity=8)
+    >>> # Create 2D coordinates and query associated weights.
+    >>> input = torch.rand((1024, 2), dtype=torch.float64) * 10 - 5
+    >>> output = pool(input)
+    """
+
+    def forward(self, input: Tensor) -> Tensor:
+        result = F.adaptive_quad_pool2d(
+            self.weight,
+            input,
+            self.exterior,
+            training=self.training,
+            max_terminal_nodes=self.max_terminal_nodes,
+            max_depth=self.max_depth,
+            capacity=self.capacity,
+            precision=self.precision,
+        )
+        if self.training:
+            self.weight.data = result.weight
+        return result.values
+
+
+class AdaptiveMaxQuadPool2d(_AdaptiveQuadPool):
+    __doc__ = f"""Adaptive maximum pooling over quadtree decomposition of input 2D coordinates.
+
+    This module constructs an internal lookup quadtree to organize closely situated 2D points.
+    Each terminal node in the resulting quadtree is paired with a weight. Thus, when providing
+    an input coordinate, the module retrieves a **terminal group** of nodes and calculates the
+    maximum value for each ``feature_dim``.
+
+    {_AdaptiveQuadPool.__doc__}
+
+    Examples:
+
+    >>> pool = nn.AdaptiveMaxQuadPool2d(3, (-10, -5, 20, 10), max_depth=5)
+    >>> # Create 2D coordinates and feature vector associated with them.
+    >>> input = torch.rand((2048, 2), dtype=torch.float64) * 10 - 5
+    >>> output = pool(input)
+    """
+
+    def forward(self, input: Tensor) -> Tensor:
+        result = F.adaptive_max_quad_pool2d(
+            self.weight,
+            input,
+            self.exterior,
+            training=self.training,
+            max_terminal_nodes=self.max_terminal_nodes,
+            max_depth=self.max_depth,
+            capacity=self.capacity,
+            precision=self.precision,
+        )
+        if self.training:
+            self.weight.data = result.weight
+        return result.values
+
+
+class AdaptiveAvgQuadPool2d(_AdaptiveQuadPool):
+    __doc__ = f"""Adaptive average pooling over quadtree decomposition of input 2D coordinates.
+
+    This module constructs an internal lookup quadtree to organize closely situated 2D points.
+    Each terminal node in the resulting quadtree is paired with a weight. Thus, when providing
+    an input coordinate, the module retrieves a **terminal group** of nodes and calculates an
+    average value for each ``feature_dim``.
+
+    {_AdaptiveQuadPool.__doc__}
+
+    Examples:
+
+    >>> # Create pool with 7 features.
+    >>> pool = nn.AdaptiveAvgQuadPool2d(7, (0, 0, 1, 1), max_depth=12)
+    >>> input = torch.rand((2048, 2), dtype=torch.float64)
+    >>> output = pool(input)
+    """
+
+    def forward(self, input: Tensor) -> Tensor:
+        result = F.adaptive_avg_quad_pool2d(
+            self.weight,
+            input,
+            self.exterior,
+            training=self.training,
+            max_terminal_nodes=self.max_terminal_nodes,
+            max_depth=self.max_depth,
+            capacity=self.capacity,
+            precision=self.precision,
+        )
+        if self.training:
+            self.weight.data = result.weight
+        return result.values
+
+
+class _QuadPool(nn.Module):
+    __doc__ = f"""
+    Args:
+        feature_dim: Size of each feature vector.
+        polygon: Polygon that resembles boundary for the terminal nodes of a quadtree.
+        exterior: Geometrical boundary of the learning space in (X, Y, W, H) format.
+        max_terminal_nodes: Optional maximum number of terminal nodes in a quadtree. Once a
+            maximum is reached, internal nodes are no longer sub-divided and tree stops growing.
+        max_depth: Maximum depth of the quadtree. Default: 17.
+        precision: Optional rounding of the input coordinates. Default: 7.
+
+    Shape:
+        - Input: :math:`(*, 2)`, where 2 comprises longitude and latitude coordinates.
+        - Output: :math:`(*, H)`, where * is the input shape and :math:`H = \\text{{feature_dim}}`.
+
+    {_exterior_doc}
+    {_terminal_group_doc}
+
+    Note:
+        All terminal nodes that have an intersection with the specified polygon boundary are
+        included into the quadtree.
+    """
+
+    def __init__(
+        self,
+        feature_dim: int,
+        polygon: Polygon,
+        exterior: _Exterior,
+        max_terminal_nodes: Optional[int] = None,
+        max_depth: int = 17,
+        precision: Optional[int] = 7,
+    ) -> None:
+        super().__init__()
+        self.feature_dim = feature_dim
+        self.polygon = polygon
+        self.exterior = tuple(map(float, exterior))
+        self.max_terminal_nodes = max_terminal_nodes
+        self.max_depth = max_depth
+        self.precision = precision
+
+        # Generate regular tiling for the provided polygon and build from those
+        # tiles a quadtree from terminal nodes all way up to the root node.
+        tiles_iter = regular_tiling(
+            polygon, Exterior.from_tuple(exterior), z=max_depth, internal=True
+        )
+        tiles = torch.tensor(list(tiles_iter), dtype=torch.int64)
+
+        self.register_buffer("tiles", tiles)
+        self.tiles: Tensor
+
+        self.initialize_parameters()
+        self.reset_parameters()
+
+    def initialize_parameters(self) -> None:
+        weight_size = [self.tiles.size(0), self.feature_dim]
+        self.weight = nn.Parameter(torch.empty(weight_size, dtype=torch.float64))
+
+    def reset_parameters(self) -> None:
+        nn.init.uniform_(self.weight)
+
+    def extra_repr(self) -> str:
+        return (
+            "{feature_dim}, exterior={exterior}, max_depth={max_depth}, "
+            "precision={precision}".format(**self.__dict__)
+        )
+
+
+class QuadPool2d(_QuadPool):
+    __doc__ = f"""Lookup index over quadtree decomposition of input 2D coordinates.
+
+    This module constructs an internal lookup tree to organize closely situated 2D points using
+    a specified polygon and exterior, where polygon is treated as a *boundary* of terminal
+    nodes of a quadtree.
+
+    Each terminal node in the resulting quadtree is paired with a weight. Thus, when providing
+    an input coordinate, the module retrieves the corresponding terminal node and returns its
+    associated weight.
+
+    {_QuadPool.__doc__}
+
+    Examples:
+
+    >>> from shapely.geometry import Polygon
+    >>> # Create a pool for squared exterior 100x100 and use only a portion of that
+    >>> # exterior isolated by a square 10x10.
+    >>> poly = Polygon([(0, 0), (10, 0), (10, 10), (0, 10)])
+    >>> pool = nn.QuadPool2d(5, poly, exterior=(0, 0, 100, 100))
+    >>> input = torch.rand((2048, 2), dtype=torch.float64)
+    >>> output = pool(input)
+    """
+
+    def forward(self, input: Tensor) -> Tensor:
+        result = F.quad_pool2d(
+            self.tiles,
+            self.weight,
+            input,
+            self.exterior,
+            # This is not a mistake, since we already know the shape of the
+            # quadtree, there is no need to learn it.
+            training=False,
+            max_terminal_nodes=self.max_terminal_nodes,
+            max_depth=self.max_depth,
+            precision=self.precision,
+        )
+        return result.values
+
+
+class MaxQuadPool2d(_QuadPool):
+    __doc__ = f"""Maximum pooling over quadtree decomposition of input 2D coordinates.
+
+    This module constructs an internal lookup tree to organize closely situated 2D points using
+    a specified polygon and exterior, where polygon is treated as a *boundary* of terminal nodes
+    of a quadtree.
+
+    Each terminal node in the resulting quadtree is paired with a weight. Thus, when providing
+    an input coordinate, the module retrieves a **terminal group** of nodes and calculates the
+    maximum value for each ``feature_dim``.
+
+    {_QuadPool.__doc__}
+
+    Examples:
+
+    >>> from shapely.geometry import Polygon
+    >>> poly = Polygon([(0, 0), (10, 0), (10, 10), (0, 10)])
+    >>> pool = nn.MaxQuadPool2d(3, poly, exterior=(0, 0, 100, 100))
+    >>> input = torch.rand((2048, 2), dtype=torch.float64)
+    >>> output = pool(input)
+    """
+
+    def forward(self, input: Tensor) -> Tensor:
+        result = F.max_quad_pool2d(
+            self.tiles,
+            self.weight,
+            input,
+            self.exterior,
+            training=False,
+            max_terminal_nodes=self.max_terminal_nodes,
+            max_depth=self.max_depth,
+            precision=self.precision,
+        )
+        return result.values
+
+
+class AvgQuadPool2d(_QuadPool):
+    __doc__ = f"""Average pooling over quadtree decomposition of input 2D coordinates.
+
+    This module constructs an internal lookup tree to organize closely situated 2D points using
+    a specified polygon and exterior, where polygon is treated as a *boundary* of terminal
+    nodes of a quadtree.
+
+    Each terminal node in the resulting quadtree is paired with a weight. Thus, when providing
+    an input coordinate, the module retrieves a **terminal group** of nodes and calculates an
+    average value for each ``feature_dim``.
+
+    {_QuadPool.__doc__}
+
+    Examples:
+
+    >>> from shapely.geometry import Polygon
+    >>> poly = Polygon([(0, 0), (10, 0), (10, 10), (0, 10)])
+    >>> pool = nn.AvgQuadPool2d(4, poly, exterior=(0, 0, 100, 100))
+    >>> input = torch.rand((2048, 2), dtype=torch.float64)
+    >>> output = pool(input)
+    """
+
+    def forward(self, input: Tensor) -> Tensor:
+        result = F.avg_quad_pool2d(
+            self.tiles,
+            self.weight,
+            input,
+            self.exterior,
+            training=False,
+            max_terminal_nodes=self.max_terminal_nodes,
+            max_depth=self.max_depth,
+            precision=self.precision,
+        )
+        return result.values

torch_geopooling/nn_test.py

@@ -0,0 +1,85 @@
+# Copyright (C) 2024, Yakau Bubnou
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from typing import Type
+
+import pytest
+import torch
+from shapely.geometry import Polygon
+from torch import nn
+from torch.nn import L1Loss
+
+from torch_geopooling.nn import (
+    AdaptiveAvgQuadPool2d,
+    AdaptiveMaxQuadPool2d,
+    AdaptiveQuadPool2d,
+    AvgQuadPool2d,
+    MaxQuadPool2d,
+    QuadPool2d,
+)
+
+
+@pytest.mark.parametrize(
+    "module_class",
+    [
+        AdaptiveQuadPool2d,
+        AdaptiveMaxQuadPool2d,
+        AdaptiveAvgQuadPool2d,
+    ],
+    ids=["id", "max", "avg"],
+)
+def test_adaptive_quad_pool2d_gradient(module_class: Type[nn.Module]) -> None:
+    pool = module_class(5, (-180, -90, 360, 180))
+
+    input = torch.rand((100, 2), dtype=torch.float64) * 90
+    y = pool(input)
+
+    assert pool.weight.grad is None
+
+    loss_fn = L1Loss()
+    loss = loss_fn(y, torch.ones_like(y))
+    loss.backward()
+
+    assert pool.weight.grad is not None
+    assert pool.weight.grad.sum().item() == pytest.approx(-1)
+
+
+@pytest.mark.parametrize(
+    "module_class",
+    [
+        QuadPool2d,
+        MaxQuadPool2d,
+        AvgQuadPool2d,
+    ],
+    ids=["id", "max", "avg"],
+)
+def test_quad_pool2d_gradient(module_class: Type[nn.Module]) -> None:
+    poly = Polygon([(0.0, 0.0), (1.0, 0.0), (1.0, 1.1), (0.0, 1.0)])
+    exterior = (0.0, 0.0, 1.0, 1.0)
+
+    pool = module_class(4, poly, exterior, max_depth=5)
+    assert pool.weight.size() == torch.Size([pool.tiles.size(0), 4])
+
+    input = torch.rand((100, 2), dtype=torch.float64)
+    y = pool(input)
+
+    assert pool.weight.grad is None
+
+    loss_fn = L1Loss()
+    loss = loss_fn(y, torch.ones_like(y))
+    loss.backward()
+
+    assert pool.weight.grad is not None
+    assert pool.weight.grad.sum().item() == pytest.approx(-1)

torch_geopooling/return_types.py

@@ -0,0 +1,29 @@
+# Copyright (C) 2024, Yakau Bubnou
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from typing import NamedTuple
+
+from torch import Tensor
+
+
+class quad_pool2d(NamedTuple):
+    tiles: Tensor
+    weight: Tensor
+    values: Tensor
+
+
+class adaptive_quad_pool2d(NamedTuple):
+    weight: Tensor
+    values: Tensor

torch_geopooling/tiling.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from collections import deque
+from itertools import product
+from typing import Iterator, NamedTuple, Tuple
+
+from shapely.geometry import Polygon
+
+__all__ = ["Exterior", "ExteriorTuple", "Tile", "regular_tiling"]
+
+
+class Tile(NamedTuple):
+    z: int
+    x: int
+    y: int
+
+    @classmethod
+    def root(cls) -> Tile:
+        return cls(0, 0, 0)
+
+    def child(self, x: int, y: int) -> Tile:
+        return Tile(self.z + 1, self.x * 2 + x, self.y * 2 + y)
+
+    def children(self) -> Iterator[Tile]:
+        for x, y in product(range(2), range(2)):
+            yield self.child(x, y)
+
+
+ExteriorTuple = Tuple[float, float, float, float]
+
+
+class Exterior(NamedTuple):
+    xmin: float
+    ymin: float
+    width: float
+    height: float
+
+    @classmethod
+    def from_tuple(cls, exterior_tuple: ExteriorTuple) -> Exterior:
+        return cls(*exterior_tuple)
+
+    @property
+    def xmax(self) -> float:
+        return self.xmin + self.width
+
+    @property
+    def ymax(self) -> float:
+        return self.ymin + self.height
+
+    def slice(self, tile: Tile) -> Exterior:
+        w = self.width / (1 << tile.z)
+        h = self.height / (1 << tile.z)
+        return Exterior(self.xmin + tile.x * w, self.ymin + tile.y * h, w, h)
+
+    def as_polygon(self) -> Polygon:
+        return Polygon(
+            [
+                (self.xmin, self.ymin),
+                (self.xmax, self.ymin),
+                (self.xmax, self.ymax),
+                (self.xmin, self.ymax),
+            ]
+        )
+
+
+def regular_tiling(
+    polygon: Polygon, exterior: Exterior, z: int, internal: bool = False
+) -> Iterator[Tile]:
+    """Returns a regular quad-tiling (tiles of the same size).
+
+    Method returns all tiles of level (z) that have a common intersection with a specified
+    polygon.
+
+    Args:
+        polygon: A polygon to cover with tiles.
+        exterior: Exterior (bounding box) of the quadtree. For example, for geospatial
+            coordinates, this will be `(-180.0, -90.0, 360.0, 180.0)`.
+        z: Zoom level of the tiles.
+        internal: When `True`, returns internal tiles (nodes) of the quadtree up to a root
+            tile (0,0,0).
+
+    Returns:
+        Iterator of tiles.
+    """
+    queue = deque([Tile.root()])
+
+    while len(queue) > 0:
+        tile = queue.pop()
+
+        tile_poly = exterior.slice(tile).as_polygon()
+        if not tile_poly.intersects(polygon):
+            continue
+
+        if internal or tile.z >= z:
+            yield tile
+        if tile.z < z:
+            queue.extend(tile.children())

torch_geopooling/transforms.py

@@ -0,0 +1,103 @@
+# Copyright (C) 2024, Yakau Bubnou
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from __future__ import annotations
+
+from typing import Iterator, Tuple
+
+from torch import Tensor
+
+from torch_geopooling.tiling import Tile
+
+__all__ = ["TileWKT"]
+
+
+class _TileSet(set):
+    def __init__(self, tiles: Tensor) -> None:
+        super().__init__(Tile(*tile.detach().tolist()) for tile in tiles)
+
+    def is_terminal(self, tile: Tile) -> bool:
+        return (
+            (tile.child(0, 0) not in self)
+            and (tile.child(0, 1) not in self)
+            and (tile.child(1, 0) not in self)
+            and (tile.child(1, 1) not in self)
+        )
+
+
+class TileWKT:
+    """Convert a Tile to a WKT polygon given the exterior of the whole geometry.
+
+    Module returns a tile geometry in WKT format, which comprises a polygon.
+
+    Args:
+        exterior: Exterior coordinates in (X, Y, W, H) format. The exterior is used to calculate
+            boundaries of a tile to produce a final WKT.
+        precision: A precision of the resulting geometry, digits after the decimal point.
+        internal: When `True`, output includes internal nodes of the quadtree tiles.
+            Otherwise (default) returns only geometry of terminal nodes.
+    """
+
+    def __init__(
+        self,
+        exterior: Tuple[float, float, float, float],
+        precision: int = 7,
+        internal: bool = False,
+    ) -> None:
+        self.exterior = tuple(map(float, exterior))
+        self.precision = precision
+        self.internal = internal
+
+        self._xmin, self._ymin, self._width, self._height = exterior
+        if self._width <= 0:
+            raise ValueError(f"exterior width should be >0, got {self._width}")
+        if self._height <= 0:
+            raise ValueError(f"exterior height should be >0, got {self._height}")
+
+    def __call__(self, tiles: Tensor) -> Iterator[str]:
+        if len(tiles.size()) != 2:
+            raise ValueError(f"tiles tensor must be a 2D tensor, got {tiles.size()} shape")
+
+        if tiles.size(1) != 3:
+            raise ValueError(
+                f"tiles should be triplets of (z, x, y), got tensor of shape {tiles.size()}"
+            )
+
+        tileset = _TileSet(tiles)
+
+        for tile in tiles:
+            z, x, y = tile.detach().tolist()
+            width = self._width / (1 << z)
+            height = self._height / (1 << z)
+
+            if (not self.internal) and (not tileset.is_terminal(Tile(z, x, y))):
+                continue
+
+            xmin = self._xmin + width * x
+            xmax = round(xmin + width, self.precision)
+            xmin = round(xmin, self.precision)
+
+            ymin = self._ymin + height * y
+            ymax = round(ymin + height, self.precision)
+            ymin = round(ymin, self.precision)
+
+            yield (
+                "POLYGON (("
+                f"{xmin} {ymin}, {xmax} {ymin}, {xmax} {ymax}, {xmin} {ymax}, {xmin} {ymin}"
+                "))"
+            )
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(exterior={self.exterior})"