morecantile 3.2.5__py3-none-any.whl → 4.0.0a0__py3-none-any.whl

morecantile/models.py

@@ -2,26 +2,29 @@
 
 import math
 import warnings
-from typing import Any, Dict, Iterator, List, Optional, Sequence, Tuple, Union
+from typing import Any, Dict, Iterator, List, Literal, Optional, Sequence, Tuple, Union
 
+from cachetools import LRUCache, cached
+from cachetools.keys import hashkey
 from pydantic import AnyHttpUrl, BaseModel, Field, PrivateAttr, validator
 from pyproj import CRS, Transformer
-from pyproj.enums import WktVersion
 from pyproj.exceptions import ProjError
 
-from .commons import BoundingBox, Coords, Tile
-from .errors import (
+from morecantile.commons import BoundingBox, Coords, Tile
+from morecantile.errors import (
+    DeprecationError,
     InvalidZoomError,
     NoQuadkeySupport,
     PointOutsideTMSBounds,
     QuadKeyError,
 )
-from .utils import (
+from morecantile.utils import (
     _parse_tile_arg,
     bbox_to_feature,
     check_quadkey_support,
     meters_per_unit,
     point_in_bbox,
+    to_rasterio_crs,
 )
 
 NumType = Union[float, int]
@@ -43,7 +46,8 @@ class CRSType(CRS, str):
     @classmethod
     def validate(cls, value: Union[CRS, str]) -> CRS:
         """Validate CRS."""
-        # If input is a string we tranlate it to CRS
+        # If input is a string we translate it to CRS
+        # TODO: add NotImplementedError for ISO 19115
         if not isinstance(value, CRS):
             return CRS.from_user_input(value)
 
@@ -89,6 +93,11 @@ def crs_axis_inverted(crs: CRS) -> bool:
     return crs.axis_info[0].abbrev.upper() in ["Y", "LAT", "N"]
 
 
+def ordered_axis_inverted(ordered_axes: List[str]) -> bool:
+    """Check if ordered axes have inverted AXIS (lat,lon) instead of (lon,lat)."""
+    return ordered_axes[0].upper() in ["Y", "LAT", "N"]
+
+
 class TMSBoundingBox(BaseModel):
     """Bounding box"""
 
@@ -104,44 +113,124 @@ class TMSBoundingBox(BaseModel):
         json_encoders = {CRS: lambda v: CRS_to_uri(v)}
 
 
+# class variableMatrixWidth(BaseModel):
+#     """Variable Matrix Width Definition
+
+
+#     ref: https://github.com/opengeospatial/2D-Tile-Matrix-Set/blob/master/schemas/tms/2.0/json/variableMatrixWidth.json
+#     """
+
+#     coalesce: int = Field(..., ge=2, multiple_of=1, description="Number of tiles in width that coalesce in a single tile for these rows")
+#     minTileRow: int = Field(..., ge=0, multiple_of=1, description="First tile row where the coalescence factor applies for this tilematrix")
+#     maxTileRow: int = Field(..., ge=0, multiple_of=1, description="Last tile row where the coalescence factor applies for this tilematrix")
+
+
 class TileMatrix(BaseModel):
-    """Tile matrix"""
-
-    type: str = Field("TileMatrixType", const=True)
-    title: Optional[str]
-    abstract: Optional[str]
-    keywords: Optional[List[str]]
-    identifier: str = Field(..., regex=r"^[0-9]+$")
-    scaleDenominator: float
-    topLeftCorner: BoundsType
-    tileWidth: int
-    tileHeight: int
-    matrixWidth: int
-    matrixHeight: int
+    """Tile Matrix Definition
+
+    A tile matrix, usually corresponding to a particular zoom level of a TileMatrixSet.
+
+    ref: https://github.com/opengeospatial/2D-Tile-Matrix-Set/blob/master/schemas/tms/2.0/json/tileMatrix.json
+    """
+
+    title: Optional[str] = Field(
+        description="Title of this tile matrix, normally used for display to a human"
+    )
+    description: Optional[str] = Field(
+        description="Brief narrative description of this tile matrix set, normally available for display to a human"
+    )
+    keywords: Optional[List[str]] = Field(
+        description="Unordered list of one or more commonly used or formalized word(s) or phrase(s) used to describe this dataset"
+    )
+    id: str = Field(
+        ...,
+        regex=r"^[0-9]+$",
+        description="Identifier selecting one of the scales defined in the TileMatrixSet and representing the scaleDenominator the tile. Implementation of 'identifier'",
+    )
+    scaleDenominator: float = Field(
+        ..., description="Scale denominator of this tile matrix"
+    )
+    cellSize: float = Field(..., description="Cell size of this tile matrix")
+    cornerOfOrigin: Optional[Literal["topLeft", "bottomLeft"]] = Field(
+        description="The corner of the tile matrix (_topLeft_ or _bottomLeft_) used as the origin for numbering tile rows and columns. This corner is also a corner of the (0, 0) tile."
+    )
+    pointOfOrigin: BoundsType = Field(
+        ...,
+        description="Precise position in CRS coordinates of the corner of origin (e.g. the top-left corner) for this tile matrix. This position is also a corner of the (0, 0) tile. In previous version, this was 'topLeftCorner' and 'cornerOfOrigin' did not exist.",
+    )
+    tileWidth: int = Field(
+        ...,
+        ge=1,
+        multiple_of=1,
+        description="Width of each tile of this tile matrix in pixels",
+    )
+    tileHeight: int = Field(
+        ...,
+        ge=1,
+        multiple_of=1,
+        description="Height of each tile of this tile matrix in pixels",
+    )
+    matrixWidth: int = Field(
+        ...,
+        ge=1,
+        multiple_of=1,
+        description="Width of the matrix (number of tiles in width)",
+    )
+    matrixHeight: int = Field(
+        ...,
+        ge=1,
+        multiple_of=1,
+        description="Height of the matrix (number of tiles in height)",
+    )
+    # variableMatrixWidths: Optional[List[variableMatrixWidth]] = Field(description="Describes the rows that has variable matrix width")
 
     class Config:
-        """Forbid additional items like variableMatrixWidth."""
+        """Forbid additional items like variableMatrixWidths."""
 
         extra = "forbid"
 
 
 class TileMatrixSet(BaseModel):
-    """Tile matrix set"""
-
-    type: str = Field("TileMatrixSetType", const=True)
-    title: str
-    abstract: Optional[str]
-    keywords: Optional[List[str]]
-    identifier: str = Field(..., regex=r"^[\w\d_\-]+$")
-    supportedCRS: CRSType
-    wellKnownScaleSet: Optional[AnyHttpUrl] = None
-    boundingBox: Optional[TMSBoundingBox]
-    tileMatrix: List[TileMatrix]
+    """Tile Matrix Set Definition
+
+    A definition of a tile matrix set following the Tile Matrix Set standard.
+    For tileset metadata, such a description (in `tileMatrixSet` property) is only required for offline use,
+    as an alternative to a link with a `http://www.opengis.net/def/rel/ogc/1.0/tiling-scheme` relation type.
+
+    ref: https://github.com/opengeospatial/2D-Tile-Matrix-Set/blob/master/schemas/tms/2.0/json/tileMatrixSet.json
+
+    """
+
+    title: Optional[str] = Field(
+        description="Title of this tile matrix set, normally used for display to a human"
+    )
+    description: Optional[str] = Field(
+        description="Brief narrative description of this tile matrix set, normally available for display to a human"
+    )
+    keywords: Optional[List[str]] = Field(
+        description="Unordered list of one or more commonly used or formalized word(s) or phrase(s) used to describe this tile matrix set"
+    )
+    id: Optional[str] = Field(
+        regex=r"^[\w\d_\-]+$",
+        description="Tile matrix set identifier. Implementation of 'identifier'",
+    )
+    uri: Optional[str] = Field(
+        description="Reference to an official source for this tileMatrixSet"
+    )
+    orderedAxes: Optional[List[str]]
+    crs: CRSType = Field(..., description="Coordinate Reference System (CRS)")
+    wellKnownScaleSet: Optional[AnyHttpUrl] = Field(
+        description="Reference to a well-known scale set"
+    )
+    boundingBox: Optional[TMSBoundingBox] = Field(
+        description="Minimum bounding rectangle surrounding the tile matrix set, in the supported CRS"
+    )
+    tileMatrices: List[TileMatrix] = Field(
+        ..., description="Describes scale levels and its tile matrices"
+    )
 
     # Private attributes
     _is_quadtree: bool = PrivateAttr()
-
-    # CRS transformation attributes
     _geographic_crs: CRSType = PrivateAttr(default=WGS84_CRS)
     _to_geographic: Transformer = PrivateAttr()
     _from_geographic: Transformer = PrivateAttr()
@@ -154,18 +243,23 @@ class TileMatrixSet(BaseModel):
 
     def __init__(self, **data):
         """Create PyProj transforms and check if TileMatrixSet supports quadkeys."""
+        if {"supportedCRS", "topLeftCorner"}.intersection(data):
+            raise DeprecationError(
+                "Tile Matrix Set must be version 2.0. Use morecantile <4.0 for TMS 1.0 support"
+            )
+
         super().__init__(**data)
 
-        self._is_quadtree = check_quadkey_support(self.tileMatrix)
+        self._is_quadtree = check_quadkey_support(self.tileMatrices)
 
         self._geographic_crs = data.get("_geographic_crs", WGS84_CRS)
 
         try:
             self._to_geographic = Transformer.from_crs(
-                self.supportedCRS, self._geographic_crs, always_xy=True
+                self.crs, self._geographic_crs, always_xy=True
             )
             self._from_geographic = Transformer.from_crs(
-                self._geographic_crs, self.supportedCRS, always_xy=True
+                self._geographic_crs, self.crs, always_xy=True
             )
         except ProjError:
             warnings.warn(
@@ -176,51 +270,103 @@ class TileMatrixSet(BaseModel):
             self._to_geographic = None
             self._from_geographic = None
 
-    @validator("tileMatrix")
+    @validator("tileMatrices")
     def sort_tile_matrices(cls, v):
         """Sort matrices by identifier"""
-        return sorted(v, key=lambda m: int(m.identifier))
+        return sorted(v, key=lambda m: int(m.id))
 
     def __iter__(self):
         """Iterate over matrices"""
-        for matrix in self.tileMatrix:
+        for matrix in self.tileMatrices:
             yield matrix
 
     def __repr__(self):
         """Simplify default pydantic model repr."""
-        return f"<TileMatrixSet title='{self.title}' identifier='{self.identifier}'>"
+        return f"<TileMatrixSet title='{self.title}' id='{self.id}'>"
 
     @property
-    def crs(self) -> CRS:
-        """Fetch CRS from epsg"""
-        return self.supportedCRS
+    def geographic_crs(self) -> CRSType:
+        """Return the TMS's geographic CRS."""
+        return self._geographic_crs
 
     @property
     def rasterio_crs(self):
         """Return rasterio CRS."""
+        return to_rasterio_crs(self.crs)
 
-        import rasterio
-        from rasterio.env import GDALVersion
-
-        if GDALVersion.runtime().major < 3:
-            return rasterio.crs.CRS.from_wkt(self.crs.to_wkt(WktVersion.WKT1_GDAL))
-        else:
-            return rasterio.crs.CRS.from_wkt(self.crs.to_wkt())
+    @property
+    def rasterio_geographic_crs(self):
+        """Return the geographic CRS as a rasterio CRS."""
+        return to_rasterio_crs(self._geographic_crs)
 
     @property
     def minzoom(self) -> int:
         """TileMatrixSet minimum TileMatrix identifier"""
-        return int(self.tileMatrix[0].identifier)
+        return int(self.tileMatrices[0].id)
 
     @property
     def maxzoom(self) -> int:
         """TileMatrixSet maximum TileMatrix identifier"""
-        return int(self.tileMatrix[-1].identifier)
+        return int(self.tileMatrices[-1].id)
 
     @property
     def _invert_axis(self) -> bool:
         """Check if CRS has inverted AXIS (lat,lon) instead of (lon,lat)."""
-        return crs_axis_inverted(self.crs)
+        return (
+            ordered_axis_inverted(self.orderedAxes)
+            if self.orderedAxes
+            else crs_axis_inverted(self.crs)
+        )
+
+    @classmethod
+    def from_v1(cls, tms: Dict) -> "TileMatrixSet":
+        """
+        Makes a TMS from a v1 TMS definition
+
+                Attributes
+        ----------
+        supportedCRS: CRSType
+            Tile Matrix Set coordinate reference system
+        title: str
+            Title of TMS
+        abstract: str (optional)
+            Abstract of CRS
+        keywords: str (optional)
+            Keywords
+        identifier: str
+            TMS Identifier
+        wellKnownScaleSet: AnyHttpUrl (optional)
+            WKSS URL
+        boundingBox: TMSBoundingBox (optional)
+            Bounding box of TMS
+        tileMatrix: List[TileMatrix]
+            List of Tile Matrices
+
+        Returns:
+        --------
+        TileMatrixSet
+        """
+        v2_tms = tms.copy()
+
+        del v2_tms["type"]
+
+        v2_tms["crs"] = v2_tms.pop("supportedCRS")
+        v2_tms["tileMatrices"] = v2_tms.pop("tileMatrix")
+        v2_tms["id"] = v2_tms.pop("identifier")
+        mpu = meters_per_unit(CRS.from_user_input(v2_tms["crs"]))
+        for i in range(len(v2_tms["tileMatrices"])):
+            v2_tms["tileMatrices"][i]["cellSize"] = (
+                v2_tms["tileMatrices"][i]["scaleDenominator"] * 0.00028 / mpu
+            )
+            v2_tms["tileMatrices"][i]["pointOfOrigin"] = v2_tms["tileMatrices"][i].pop(
+                "topLeftCorner"
+            )
+            v2_tms["tileMatrices"][i]["id"] = v2_tms["tileMatrices"][i].pop(
+                "identifier"
+            )
+            del v2_tms["tileMatrices"][i]["type"]
+
+        return TileMatrixSet(**v2_tms)
 
     @classmethod
     def custom(
@@ -229,13 +375,15 @@ class TileMatrixSet(BaseModel):
         crs: CRS,
         tile_width: int = 256,
         tile_height: int = 256,
-        matrix_scale: List = [1, 1],
+        matrix_scale: Optional[List] = None,
         extent_crs: Optional[CRS] = None,
         minzoom: int = 0,
         maxzoom: int = 24,
-        title: str = "Custom TileMatrixSet",
-        identifier: str = "Custom",
+        title: Optional[str] = None,
+        id: Optional[str] = None,
+        ordered_axes: Optional[List[str]] = None,
         geographic_crs: CRS = WGS84_CRS,
+        **kwargs: Any,
     ):
         """
         Construct a custom TileMatrixSet.
@@ -261,118 +409,109 @@ class TileMatrixSet(BaseModel):
             Tile Matrix Set minimum zoom level (default is 0).
         maxzoom: int
             Tile Matrix Set maximum zoom level (default is 24).
-        title: str
-            Tile Matrix Set title (default is 'Custom TileMatrixSet')
-        identifier: str
-            Tile Matrix Set identifier (default is 'Custom')
+        title: str, optional
+            Tile Matrix Set title
+        id: str, optional
+            Tile Matrix Set identifier
         geographic_crs: pyproj.CRS
             Geographic (lat,lon) coordinate reference system (default is EPSG:4326)
+        kwargs: Any
+            Attributes to forward to the TileMatrixSet
 
         Returns:
         --------
         TileMatrixSet
 
         """
-        tms: Dict[str, Any] = {
-            "title": title,
-            "identifier": identifier,
-            "supportedCRS": crs,
-            "tileMatrix": [],
-            "_geographic_crs": geographic_crs,
-        }
-
-        is_inverted = crs_axis_inverted(crs)
+        matrix_scale = matrix_scale or [1, 1]
 
-        if is_inverted:
-            tms["boundingBox"] = TMSBoundingBox(
-                crs=extent_crs or crs,
-                lowerCorner=[extent[1], extent[0]],
-                upperCorner=[extent[3], extent[2]],
-            )
+        if ordered_axes:
+            is_inverted = ordered_axis_inverted(ordered_axes)
         else:
-            tms["boundingBox"] = TMSBoundingBox(
-                crs=extent_crs or crs,
-                lowerCorner=[extent[0], extent[1]],
-                upperCorner=[extent[2], extent[3]],
-            )
+            is_inverted = crs_axis_inverted(crs)
 
         if extent_crs:
             transform = Transformer.from_crs(extent_crs, crs, always_xy=True)
-            left, bottom, right, top = extent
-            bbox = BoundingBox(
-                *transform.transform_bounds(left, bottom, right, top, densify_pts=21)
-            )
-        else:
-            bbox = BoundingBox(*extent)
+            extent = transform.transform_bounds(*extent, densify_pts=21)
 
+        bbox = BoundingBox(*extent)
         x_origin = bbox.left if not is_inverted else bbox.top
         y_origin = bbox.top if not is_inverted else bbox.left
-
         width = abs(bbox.right - bbox.left)
         height = abs(bbox.top - bbox.bottom)
         mpu = meters_per_unit(crs)
+
+        tile_matrices: List[TileMatrix] = []
         for zoom in range(minzoom, maxzoom + 1):
             res = max(
                 width / (tile_width * matrix_scale[0]) / 2.0**zoom,
                 height / (tile_height * matrix_scale[1]) / 2.0**zoom,
             )
-            tms["tileMatrix"].append(
+            tile_matrices.append(
                 TileMatrix(
-                    **dict(
-                        identifier=str(zoom),
-                        scaleDenominator=res * mpu / 0.00028,
-                        topLeftCorner=[x_origin, y_origin],
-                        tileWidth=tile_width,
-                        tileHeight=tile_height,
-                        matrixWidth=matrix_scale[0] * 2**zoom,
-                        matrixHeight=matrix_scale[1] * 2**zoom,
-                    )
+                    **{
+                        "id": str(zoom),
+                        "scaleDenominator": res * mpu / 0.00028,
+                        "cellSize": res,
+                        "pointOfOrigin": [x_origin, y_origin],
+                        "tileWidth": tile_width,
+                        "tileHeight": tile_height,
+                        "matrixWidth": matrix_scale[0] * 2**zoom,
+                        "matrixHeight": matrix_scale[1] * 2**zoom,
+                    }
                 )
             )
 
-        return cls(**tms)
+        return cls(
+            crs=crs,
+            tileMatrices=tile_matrices,
+            id=id,
+            title=title,
+            _geographic_crs=geographic_crs,
+            **kwargs,
+        )
 
     def matrix(self, zoom: int) -> TileMatrix:
         """Return the TileMatrix for a specific zoom."""
-        try:
-            tile_matrix = list(
-                filter(lambda m: m.identifier == str(zoom), self.tileMatrix)
-            )[0]
-        except IndexError:
-            matrix_scale = list(
-                {
-                    round(
-                        self.tileMatrix[idx].scaleDenominator
-                        / self.tileMatrix[idx - 1].scaleDenominator,
-                        2,
-                    )
-                    for idx in range(1, len(self.tileMatrix))
-                }
-            )
-            if len(matrix_scale) > 1:
-                raise Exception(
-                    f"TileMatrix not found for level: {zoom} - Unable to construct tileMatrix for TMS with variable scale"
+        for m in self.tileMatrices:
+            if m.id == str(zoom):
+                return m
+
+        matrix_scale = list(
+            {
+                round(
+                    self.tileMatrices[idx].scaleDenominator
+                    / self.tileMatrices[idx - 1].scaleDenominator,
+                    2,
                 )
-
-            warnings.warn(
-                f"TileMatrix not found for level: {zoom} - Creating values from TMS Scale.",
-                UserWarning,
+                for idx in range(1, len(self.tileMatrices))
+            }
+        )
+        if len(matrix_scale) > 1:
+            raise InvalidZoomError(
+                f"TileMatrix not found for level: {zoom} - Unable to construct tileMatrix for TMS with variable scale"
             )
 
-            tile_matrix = self.tileMatrix[-1]
-            factor = 1 / matrix_scale[0]
-            while not str(zoom) == tile_matrix.identifier:
-                tile_matrix = TileMatrix(
-                    **dict(
-                        identifier=str(int(tile_matrix.identifier) + 1),
-                        scaleDenominator=tile_matrix.scaleDenominator / factor,
-                        topLeftCorner=tile_matrix.topLeftCorner,
-                        tileWidth=tile_matrix.tileWidth,
-                        tileHeight=tile_matrix.tileHeight,
-                        matrixWidth=int(tile_matrix.matrixWidth * factor),
-                        matrixHeight=int(tile_matrix.matrixHeight * factor),
-                    )
-                )
+        warnings.warn(
+            f"TileMatrix not found for level: {zoom} - Creating values from TMS Scale.",
+            UserWarning,
+        )
+
+        tile_matrix = self.tileMatrices[-1]
+        factor = 1 / matrix_scale[0]
+        while not str(zoom) == tile_matrix.id:
+            tile_matrix = TileMatrix(
+                **{
+                    "id": str(int(tile_matrix.id) + 1),
+                    "scaleDenominator": tile_matrix.scaleDenominator / factor,
+                    "cellSize": tile_matrix.cellSize / factor,
+                    "pointOfOrigin": tile_matrix.pointOfOrigin,
+                    "tileWidth": tile_matrix.tileWidth,
+                    "tileHeight": tile_matrix.tileHeight,
+                    "matrixWidth": int(tile_matrix.matrixWidth * factor),
+                    "matrixHeight": int(tile_matrix.matrixHeight * factor),
+                }
+            )
 
         return tile_matrix
 
@@ -513,10 +652,10 @@ class TileMatrixSet(BaseModel):
         res = self._resolution(matrix)
 
         origin_x = (
-            matrix.topLeftCorner[1] if self._invert_axis else matrix.topLeftCorner[0]
+            matrix.pointOfOrigin[1] if self._invert_axis else matrix.pointOfOrigin[0]
         )
         origin_y = (
-            matrix.topLeftCorner[0] if self._invert_axis else matrix.topLeftCorner[1]
+            matrix.pointOfOrigin[0] if self._invert_axis else matrix.pointOfOrigin[1]
         )
 
         xtile = (
@@ -585,10 +724,10 @@ class TileMatrixSet(BaseModel):
         res = self._resolution(matrix)
 
         origin_x = (
-            matrix.topLeftCorner[1] if self._invert_axis else matrix.topLeftCorner[0]
+            matrix.pointOfOrigin[1] if self._invert_axis else matrix.pointOfOrigin[0]
         )
         origin_y = (
-            matrix.topLeftCorner[0] if self._invert_axis else matrix.topLeftCorner[1]
+            matrix.pointOfOrigin[0] if self._invert_axis else matrix.pointOfOrigin[1]
         )
 
         xcoord = origin_x + t.x * res * matrix.tileWidth
@@ -654,50 +793,19 @@ class TileMatrixSet(BaseModel):
     @property
     def xy_bbox(self):
         """Return TMS bounding box in TileMatrixSet's CRS."""
-        if self.boundingBox:
-            left = (
-                self.boundingBox.lowerCorner[1]
-                if self._invert_axis
-                else self.boundingBox.lowerCorner[0]
-            )
-            bottom = (
-                self.boundingBox.lowerCorner[0]
-                if self._invert_axis
-                else self.boundingBox.lowerCorner[1]
-            )
-            right = (
-                self.boundingBox.upperCorner[1]
-                if self._invert_axis
-                else self.boundingBox.upperCorner[0]
-            )
-            top = (
-                self.boundingBox.upperCorner[0]
-                if self._invert_axis
-                else self.boundingBox.upperCorner[1]
-            )
-            if self.boundingBox.crs != self.crs:
-                transform = Transformer.from_crs(
-                    self.boundingBox.crs, self.crs, always_xy=True
-                )
-                left, bottom, right, top = transform.transform_bounds(
-                    left,
-                    bottom,
-                    right,
-                    top,
-                    densify_pts=21,
-                )
+        zoom = self.minzoom
+        matrix = self.matrix(zoom)
 
-        else:
-            zoom = self.minzoom
-            matrix = self.matrix(zoom)
-            left, top = self._ul(Tile(0, 0, zoom))
-            right, bottom = self._ul(
-                Tile(matrix.matrixWidth, matrix.matrixHeight, zoom)
-            )
+        left, top = self._ul(Tile(0, 0, zoom))
+        right, bottom = self._ul(Tile(matrix.matrixWidth, matrix.matrixHeight, zoom))
 
         return BoundingBox(left, bottom, right, top)
 
     @property
+    @cached(  # type: ignore
+        LRUCache(maxsize=512),
+        key=lambda self: hashkey(self.id, self.tileMatrices[0].pointOfOrigin),
+    )
     def bbox(self):
         """Return TMS bounding box in geographic coordinate reference system."""
         left, bottom, right, top = self.xy_bbox
@@ -742,7 +850,7 @@ class TileMatrixSet(BaseModel):
         zooms : int or sequence of int
             One or more zoom levels.
         truncate : bool, optional
-            Whether or not to truncate inputs to web mercator limits.
+            Whether or not to truncate inputs to TMS limits.
 
         Yields
         ------
@@ -776,20 +884,25 @@ class TileMatrixSet(BaseModel):
             n = min(self.bbox.top, n)
 
             for z in zooms:
-                ul_tile = self.tile(
+                nw_tile = self.tile(
                     w + LL_EPSILON, n - LL_EPSILON, z
                 )  # Not in mercantile
-                lr_tile = self.tile(e - LL_EPSILON, s + LL_EPSILON, z)
+                se_tile = self.tile(e - LL_EPSILON, s + LL_EPSILON, z)
+
+                minx = min(nw_tile.x, se_tile.x)
+                maxx = max(nw_tile.x, se_tile.x)
+                miny = min(nw_tile.y, se_tile.y)
+                maxy = max(nw_tile.y, se_tile.y)
 
-                for i in range(ul_tile.x, lr_tile.x + 1):
-                    for j in range(ul_tile.y, lr_tile.y + 1):
+                for i in range(minx, maxx + 1):
+                    for j in range(miny, maxy + 1):
                         yield Tile(i, j, z)
 
     def feature(
         self,
         tile: Tile,
         fid: Optional[str] = None,
-        props: Dict = {},
+        props: Optional[Dict] = None,
         buffer: Optional[NumType] = None,
         precision: Optional[int] = None,
         projected: bool = False,
@@ -849,7 +962,7 @@ class TileMatrixSet(BaseModel):
             "geometry": geom,
             "properties": {
                 "title": f"XYZ tile {xyz}",
-                "grid_name": self.identifier,
+                "grid_name": self.id,
                 "grid_crs": self.crs.to_string(),
             },
         }
@@ -1061,8 +1174,8 @@ class TileMatrixSet(BaseModel):
         tile : Tile or sequence of int
             May be be either an instance of Tile or 3 ints, X, Y, Z.
         zoom : int, optional
-            Determines the *zoom* level of the returned parent tile.
-            This defaults to one lower than the tile (the immediate parent).
+            Determines the *zoom* level of the returned child tiles.
+            This defaults to one higher than the tile (the immediate children).
 
         Returns
         -------