morecantile 6.1.0__py3-none-any.whl → 7.0.0__py3-none-any.whl

morecantile/models.py

@@ -1,8 +1,9 @@
 """Pydantic modules for OGC TileMatrixSets (https://www.ogc.org/standards/tms)"""
 
 import math
+import os
 import warnings
-from functools import cached_property
+from functools import cached_property, lru_cache
 from typing import Any, Dict, Iterator, List, Literal, Optional, Sequence, Tuple, Union
 
 import pyproj
@@ -16,7 +17,7 @@ from pydantic import (
     field_validator,
     model_validator,
 )
-from pyproj.exceptions import CRSError, ProjError
+from pyproj.exceptions import CRSError
 from typing_extensions import Annotated
 
 from morecantile.commons import BoundingBox, Coords, Tile
@@ -35,12 +36,17 @@ from morecantile.utils import (
     meters_per_unit,
     point_in_bbox,
     to_rasterio_crs,
+    truncate_coordinates,
 )
 
 NumType = Union[float, int]
 BoundsType = Tuple[NumType, NumType]
 LL_EPSILON = 1e-11
 axesInfo = Annotated[List[str], Field(min_length=2, max_length=2)]
+WGS84_CRS = pyproj.CRS.from_epsg(4326)
+DEFAULT_GEOGRAPHIC_CRS = os.environ.get("MORECANTILE_DEFAULT_GEOGRAPHIC_CRS")
+
+TransformerFromCRS = lru_cache(pyproj.Transformer.from_crs)
 
 
 class CRSUri(BaseModel):
@@ -391,7 +397,7 @@ class TileMatrix(BaseModel, extra="forbid"):
         return 1
 
 
-class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
+class TileMatrixSet(BaseModel, arbitrary_types_allowed=True, extra="ignore"):
     """Tile Matrix Set Definition
 
     A definition of a tile matrix set following the Tile Matrix Set standard.
@@ -407,7 +413,8 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
         Field(
             json_schema_extra={
                 "description": "Title of this tile matrix set, normally used for display to a human",
-            }
+            },
+            frozen=True,
         ),
     ] = None
     description: Annotated[
@@ -415,7 +422,8 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
         Field(
             json_schema_extra={
                 "description": "Brief narrative description of this tile matrix set, normally available for display to a human",
-            }
+            },
+            frozen=True,
         ),
     ] = None
     keywords: Annotated[
@@ -423,7 +431,8 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
         Field(
             json_schema_extra={
                 "description": "Unordered list of one or more commonly used or formalized word(s) or phrase(s) used to describe this tile matrix set",
-            }
+            },
+            frozen=True,
         ),
     ] = None
     id: Annotated[
@@ -433,6 +442,7 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
             json_schema_extra={
                 "description": "Tile matrix set identifier. Implementation of 'identifier'",
             },
+            frozen=True,
         ),
     ] = None
     uri: Annotated[
@@ -440,7 +450,8 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
         Field(
             json_schema_extra={
                 "description": "Reference to an official source for this tileMatrixSet",
-            }
+            },
+            frozen=True,
         ),
     ] = None
     orderedAxes: Annotated[
@@ -448,7 +459,8 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
         Field(
             json_schema_extra={
                 "description": "Ordered list of names of the dimensions defined in the CRS",
-            }
+            },
+            frozen=True,
         ),
     ] = None
     crs: Annotated[
@@ -456,7 +468,8 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
         Field(
             json_schema_extra={
                 "description": "Coordinate Reference System (CRS)",
-            }
+            },
+            frozen=True,
         ),
     ]
     wellKnownScaleSet: Annotated[
@@ -464,7 +477,8 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
         Field(
             json_schema_extra={
                 "description": "Reference to a well-known scale set",
-            }
+            },
+            frozen=True,
         ),
     ] = None
     boundingBox: Annotated[
@@ -472,7 +486,8 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
         Field(
             json_schema_extra={
                 "description": "Minimum bounding rectangle surrounding the tile matrix set, in the supported CRS",
-            }
+            },
+            frozen=True,
         ),
     ] = None
     tileMatrices: Annotated[
@@ -480,14 +495,13 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
         Field(
             json_schema_extra={
                 "description": "Describes scale levels and its tile matrices",
-            }
+            },
+            frozen=True,
         ),
     ]
 
     # Private attributes
-    _to_geographic: pyproj.Transformer = PrivateAttr()
-    _from_geographic: pyproj.Transformer = PrivateAttr()
-
+    _geographic_crs: pyproj.CRS = PrivateAttr()
     _tile_matrices_idx: Dict[int, int] = PrivateAttr()
 
     def __init__(self, **data):
@@ -498,21 +512,12 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
             int(mat.id): idx for idx, mat in enumerate(self.tileMatrices)
         }
 
-        try:
-            self._to_geographic = pyproj.Transformer.from_crs(
-                self.crs._pyproj_crs, self.crs._pyproj_crs.geodetic_crs, always_xy=True
-            )
-            self._from_geographic = pyproj.Transformer.from_crs(
-                self.crs._pyproj_crs.geodetic_crs, self.crs._pyproj_crs, always_xy=True
-            )
-        except ProjError:
-            warnings.warn(
-                "Could not create coordinate Transformer from input CRS to the given geographic CRS"
-                "some methods might not be available.",
-                UserWarning,
-            )
-            self._to_geographic = None
-            self._from_geographic = None
+        # Default Geographic CRS from TMS's CRS
+        self._geographic_crs = (
+            pyproj.CRS.from_user_input(DEFAULT_GEOGRAPHIC_CRS)
+            if DEFAULT_GEOGRAPHIC_CRS
+            else self.crs._pyproj_crs.geodetic_crs
+        )
 
     @model_validator(mode="before")
     def check_for_old_specification(cls, data):
@@ -537,10 +542,8 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
     def is_variable(self) -> bool:
         """Check if TMS has variable width matrix."""
         return any(
-            [
-                True if matrix.variableMatrixWidths is not None else False
-                for matrix in self.tileMatrices
-            ]
+            True if matrix.variableMatrixWidths is not None else False
+            for matrix in self.tileMatrices
         )
 
     def __iter__(self):
@@ -552,20 +555,36 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
         """Simplify default pydantic model repr."""
         return f"<TileMatrixSet title='{self.title}' id='{self.id}' crs='{CRS_to_uri(self.crs._pyproj_crs)}>"
 
-    @cached_property
-    def geographic_crs(self) -> pyproj.CRS:
-        """Return the TMS's geographic CRS."""
-        return self.crs._pyproj_crs.geodetic_crs
-
     @cached_property
     def rasterio_crs(self):
         """Return rasterio CRS."""
         return to_rasterio_crs(self.crs._pyproj_crs)
 
-    @cached_property
+    def set_geographic_crs(self, crs: CRS) -> None:
+        """Overwrite Geographic CRS for the TMS."""
+        self._geographic_crs = crs
+
+    @property
+    def _to_geographic(self) -> pyproj.Transformer:
+        return TransformerFromCRS(
+            self.crs._pyproj_crs, self.geographic_crs, always_xy=True
+        )
+
+    @property
+    def _from_geographic(self) -> pyproj.Transformer:
+        return TransformerFromCRS(
+            self.geographic_crs, self.crs._pyproj_crs, always_xy=True
+        )
+
+    @property
+    def geographic_crs(self) -> pyproj.CRS:
+        """Return the TMS's geographic CRS."""
+        return self._geographic_crs
+
+    @property
     def rasterio_geographic_crs(self):
         """Return the geographic CRS as a rasterio CRS."""
-        return to_rasterio_crs(self.crs._pyproj_crs.geodetic_crs)
+        return to_rasterio_crs(self._geographic_crs)
 
     @property
     def minzoom(self) -> int:
@@ -658,6 +677,8 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
         ordered_axes: Optional[List[str]] = None,
         screen_pixel_size: float = 0.28e-3,
         decimation_base: int = 2,
+        corner_of_origin: Literal["topLeft", "bottomLeft"] = "topLeft",
+        point_of_origin: List[float] = None,
         **kwargs: Any,
     ):
         """
@@ -665,10 +686,10 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
 
         Attributes
         ----------
-        crs: pyproj.CRS
-            Tile Matrix Set coordinate reference system
         extent: list
             Bounding box of the Tile Matrix Set, (left, bottom, right, top).
+        crs: pyproj.CRS
+            Tile Matrix Set coordinate reference system
         tile_width: int
             Width of each tile of this tile matrix in pixels (default is 256).
         tile_height: int
@@ -694,6 +715,10 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
             Rendering pixel size. 0.28 mm was the actual pixel size of a common display from 2005 and considered as standard by OGC.
         decimation_base: int, optional
             How tiles are divided at each zoom level (default is 2). Must be greater than 1.
+        corner_of_origin: str, optional
+            Corner of origin for the TMS, either 'topLeft' or 'bottomLeft'
+        point_of_origin: list, optional
+            Point of origin for the TMS, (x, y) coordinates in the TMS CRS.
         kwargs: Any
             Attributes to forward to the TileMatrixSet
 
@@ -719,8 +744,20 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
             )
 
         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
+        if not point_of_origin:
+            if corner_of_origin == "topLeft":
+                x_origin = bbox.left if not is_inverted else bbox.top
+                y_origin = bbox.top if not is_inverted else bbox.left
+                point_of_origin = [x_origin, y_origin]
+            elif corner_of_origin == "bottomLeft":
+                x_origin = bbox.left if not is_inverted else bbox.bottom
+                y_origin = bbox.bottom if not is_inverted else bbox.left
+                point_of_origin = [x_origin, y_origin]
+            else:
+                raise ValueError(
+                    f"Invalid `corner_of_origin` value: {corner_of_origin},  must be either 'topLeft' or 'bottomLeft'"
+                )
+
         width = abs(bbox.right - bbox.left)
         height = abs(bbox.top - bbox.bottom)
         mpu = meters_per_unit(crs)
@@ -739,7 +776,8 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
                         "id": str(zoom),
                         "scaleDenominator": res * mpu / screen_pixel_size,
                         "cellSize": res,
-                        "pointOfOrigin": [x_origin, y_origin],
+                        "cornerOfOrigin": corner_of_origin,
+                        "pointOfOrigin": point_of_origin,
                         "tileWidth": tile_width,
                         "tileHeight": tile_height,
                         "matrixWidth": matrix_scale[0] * decimation_base**zoom,
@@ -800,6 +838,7 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
         warnings.warn(
             f"TileMatrix not found for level: {zoom} - Creating values from TMS Scale.",
             UserWarning,
+            stacklevel=1,
         )
 
         # TODO: what if we want to construct a matrix for a level up ?
@@ -810,6 +849,7 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
                 id=str(int(tile_matrix.id) + 1),
                 scaleDenominator=tile_matrix.scaleDenominator / factor,
                 cellSize=tile_matrix.cellSize / factor,
+                cornerOfOrigin=tile_matrix.cornerOfOrigin,
                 pointOfOrigin=tile_matrix.pointOfOrigin,
                 tileWidth=tile_matrix.tileWidth,
                 tileHeight=tile_matrix.tileHeight,
@@ -887,57 +927,50 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
 
         return zoom_level
 
-    def lnglat(self, x: float, y: float, truncate=False) -> Coords:
+    def intersect_tms(self, bbox: BoundingBox) -> bool:
+        """Check if a bounds intersects with the TMS bounds."""
+        tms_bounds = self.xy_bbox
+        return (
+            (bbox[0] < tms_bounds[2])
+            and (bbox[2] > tms_bounds[0])
+            and (bbox[3] > tms_bounds[1])
+            and (bbox[1] < tms_bounds[3])
+        )
+
+    def lnglat(self, x: float, y: float, truncate: bool = False) -> Coords:
         """Transform point(x,y) to geographic longitude and latitude."""
         inside = point_in_bbox(Coords(x, y), self.xy_bbox)
         if not inside:
             warnings.warn(
                 f"Point ({x}, {y}) is outside TMS bounds {list(self.xy_bbox)}.",
                 PointOutsideTMSBounds,
+                stacklevel=1,
             )
 
         lng, lat = self._to_geographic.transform(x, y)
 
         if truncate:
-            lng, lat = self.truncate_lnglat(lng, lat)
+            lng, lat = truncate_coordinates(lng, lat, self.bbox)
 
         return Coords(lng, lat)
 
-    def xy(self, lng: float, lat: float, truncate=False) -> Coords:
+    def xy(self, lng: float, lat: float, truncate: bool = False) -> Coords:
         """Transform geographic longitude and latitude coordinates to TMS CRS."""
         if truncate:
-            lng, lat = self.truncate_lnglat(lng, lat)
+            lng, lat = truncate_coordinates(lng, lat, self.bbox)
 
         inside = point_in_bbox(Coords(lng, lat), self.bbox)
         if not inside:
             warnings.warn(
                 f"Point ({lng}, {lat}) is outside TMS bounds {list(self.bbox)}.",
                 PointOutsideTMSBounds,
+                stacklevel=1,
             )
 
         x, y = self._from_geographic.transform(lng, lat)
 
         return Coords(x, y)
 
-    def truncate_lnglat(self, lng: float, lat: float) -> Tuple[float, float]:
-        """
-        Truncate geographic coordinates to TMS geographic bbox.
-
-        Adapted from https://github.com/mapbox/mercantile/blob/master/mercantile/__init__.py
-
-        """
-        if lng > self.bbox.right:
-            lng = self.bbox.right
-        elif lng < self.bbox.left:
-            lng = self.bbox.left
-
-        if lat > self.bbox.top:
-            lat = self.bbox.top
-        elif lat < self.bbox.bottom:
-            lat = self.bbox.bottom
-
-        return lng, lat
-
     def _tile(
         self,
         xcoord: float,
@@ -968,8 +1001,14 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
             if not math.isinf(xcoord)
             else 0
         )
+
+        coord = (
+            (origin_y - ycoord)
+            if matrix.cornerOfOrigin == "topLeft"
+            else (ycoord - origin_y)
+        )
         ytile = (
-            math.floor((origin_y - ycoord) / float(matrix.cellSize * matrix.tileHeight))
+            math.floor(coord / float(matrix.cellSize * matrix.tileHeight))
             if not math.isinf(ycoord)
             else 0
         )
@@ -1005,6 +1044,7 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
         zoom: int,
         truncate=False,
         ignore_coalescence: bool = False,
+        geographic_crs: Optional[CRS] = None,
     ) -> Tile:
         """
         Get the tile for a given geographic longitude and latitude pair.
@@ -1017,13 +1057,38 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
             The zoom level.
         truncate : bool
             Whether or not to truncate inputs to limits of TMS geographic bounds.
+        ignore_coalescence : bool
+            Whether or not to ignore coalescence factor for TMS with variable matrix width.
+        geographic_crs: pyproj.CRS, optional
+            Geographic CRS of the given coordinates. Default to TMS's Geographic CRS.
 
         Returns
         -------
         Tile
 
         """
-        x, y = self.xy(lng, lat, truncate=truncate)
+        geographic_crs = geographic_crs or self.geographic_crs or WGS84_CRS
+        _from_geographic = TransformerFromCRS(
+            geographic_crs, self.crs._pyproj_crs, always_xy=True
+        )
+        _to_geographic = TransformerFromCRS(
+            self.crs._pyproj_crs, geographic_crs, always_xy=True
+        )
+
+        if truncate:
+            bbox = BoundingBox(
+                *_to_geographic.transform_bounds(*self.xy_bbox, densify_pts=21),
+            )
+            lng, lat = truncate_coordinates(lng, lat, bbox)
+
+        x, y = _from_geographic.transform(lng, lat)
+        if not point_in_bbox(Coords(x, y), self.xy_bbox):
+            warnings.warn(
+                f"Point ({lng}, {lat}) is outside TMS bounds.",
+                PointOutsideTMSBounds,
+                stacklevel=1,
+            )
+
         return self._tile(x, y, zoom, ignore_coalescence=ignore_coalescence)
 
     def _ul(self, *tile: Tile) -> Coords:
@@ -1049,11 +1114,17 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
             if matrix.variableMatrixWidths is not None
             else 1
         )
-        return Coords(
-            origin_x + math.floor(t.x / cf) * matrix.cellSize * cf * matrix.tileWidth,
-            origin_y - t.y * matrix.cellSize * matrix.tileHeight,
+        x_coord = (
+            origin_x + math.floor(t.x / cf) * matrix.cellSize * cf * matrix.tileWidth
+        )
+        y_coord = (
+            origin_y - t.y * matrix.cellSize * matrix.tileHeight
+            if matrix.cornerOfOrigin == "topLeft"
+            else origin_y + t.y * matrix.cellSize * matrix.tileHeight
         )
 
+        return Coords(x_coord, y_coord)
+
     def _lr(self, *tile: Tile) -> Coords:
         """
         Return the lower right coordinate of the tile in TMS coordinate reference system.
@@ -1077,11 +1148,17 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
             if matrix.variableMatrixWidths is not None
             else 1
         )
-        return Coords(
+        x_coord = (
             origin_x
-            + (math.floor(t.x / cf) + 1) * matrix.cellSize * cf * matrix.tileWidth,
-            origin_y - (t.y + 1) * matrix.cellSize * matrix.tileHeight,
+            + (math.floor(t.x / cf) + 1) * matrix.cellSize * cf * matrix.tileWidth
         )
+        y_coord = (
+            origin_y - (t.y + 1) * matrix.cellSize * matrix.tileHeight
+            if matrix.cornerOfOrigin == "topLeft"
+            else origin_y + (t.y + 1) * matrix.cellSize * matrix.tileHeight
+        )
+
+        return Coords(x_coord, y_coord)
 
     def xy_bounds(self, *tile: Tile) -> BoundingBox:
         """
@@ -1108,12 +1185,16 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
         )
 
         left = origin_x + math.floor(t.x / cf) * matrix.cellSize * cf * matrix.tileWidth
-        top = origin_y - t.y * matrix.cellSize * matrix.tileHeight
         right = (
             origin_x
             + (math.floor(t.x / cf) + 1) * matrix.cellSize * cf * matrix.tileWidth
         )
-        bottom = origin_y - (t.y + 1) * matrix.cellSize * matrix.tileHeight
+        if matrix.cornerOfOrigin == "topLeft":
+            top = origin_y - t.y * matrix.cellSize * matrix.tileHeight
+            bottom = origin_y - (t.y + 1) * matrix.cellSize * matrix.tileHeight
+        else:
+            bottom = origin_y + t.y * matrix.cellSize * matrix.tileHeight
+            top = origin_y + (t.y + 1) * matrix.cellSize * matrix.tileHeight
 
         return BoundingBox(left, bottom, right, top)
 
@@ -1172,7 +1253,7 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
 
         return BoundingBox(left, bottom, right, top)
 
-    @property
+    @cached_property
     def xy_bbox(self):
         """Return TMS bounding box in TileMatrixSet's CRS."""
         zoom = self.minzoom
@@ -1184,7 +1265,7 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
         )
         return BoundingBox(left, bottom, right, top)
 
-    @cached_property
+    @property
     def bbox(self):
         """Return TMS bounding box in geographic coordinate reference system."""
         left, bottom, right, top = self.xy_bbox
@@ -1198,16 +1279,6 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
             )
         )
 
-    def intersect_tms(self, bbox: BoundingBox) -> bool:
-        """Check if a bounds intersects with the TMS bounds."""
-        tms_bounds = self.xy_bbox
-        return (
-            (bbox[0] < tms_bounds[2])
-            and (bbox[2] > tms_bounds[0])
-            and (bbox[3] > tms_bounds[1])
-            and (bbox[1] < tms_bounds[3])
-        )
-
     def tiles(  # noqa: C901
         self,
         west: float,
@@ -1216,6 +1287,7 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
         north: float,
         zooms: Sequence[int],
         truncate: bool = False,
+        geographic_crs: Optional[CRS] = None,
     ) -> Iterator[Tile]:
         """
         Get the tiles overlapped by a geographic bounding box
@@ -1230,6 +1302,8 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
             One or more zoom levels.
         truncate : bool, optional
             Whether or not to truncate inputs to TMS limits.
+        geographic_crs: pyproj.CRS, optional
+            Geographic CRS of the given coordinates. Default to TMS's Geographic CRS
 
         Yields
         ------
@@ -1247,39 +1321,43 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
         if isinstance(zooms, int):
             zooms = (zooms,)
 
+        geographic_crs = geographic_crs or self.geographic_crs or WGS84_CRS
+        _from_geographic = TransformerFromCRS(
+            geographic_crs, self.crs._pyproj_crs, always_xy=True
+        )
+        _to_geographic = TransformerFromCRS(
+            self.crs._pyproj_crs, geographic_crs, always_xy=True
+        )
+
+        # TMS bbox
+        bbox = BoundingBox(
+            *_to_geographic.transform_bounds(*self.xy_bbox, densify_pts=21),
+        )
+
         if truncate:
-            west, south = self.truncate_lnglat(west, south)
-            east, north = self.truncate_lnglat(east, north)
+            west, south = truncate_coordinates(west, south, bbox)
+            east, north = truncate_coordinates(east, north, bbox)
 
         if west > east:
-            bbox_west = (self.bbox.left, south, east, north)
-            bbox_east = (west, south, self.bbox.right, north)
+            bbox_west = (bbox.left, south, east, north)
+            bbox_east = (west, south, bbox.right, north)
             bboxes = [bbox_west, bbox_east]
         else:
             bboxes = [(west, south, east, north)]
 
         for w, s, e, n in bboxes:
             # Clamp bounding values.
-            es_contain_180th = lons_contain_antimeridian(e, self.bbox.right)
-            w = max(self.bbox.left, w)
-            s = max(self.bbox.bottom, s)
-            e = max(self.bbox.right, e) if es_contain_180th else min(self.bbox.right, e)
-            n = min(self.bbox.top, n)
-
+            es_contain_180th = lons_contain_antimeridian(e, bbox.right)
+            w = max(bbox.left, w)
+            s = max(bbox.bottom, s)
+            e = max(bbox.right, e) if es_contain_180th else min(bbox.right, e)
+            n = min(bbox.top, n)
+
+            w, n = _from_geographic.transform(w + LL_EPSILON, n - LL_EPSILON)
+            e, s = _from_geographic.transform(e - LL_EPSILON, s + LL_EPSILON)
             for z in zooms:
-                nw_tile = self.tile(
-                    w + LL_EPSILON,
-                    n - LL_EPSILON,
-                    z,
-                    ignore_coalescence=True,
-                )  # Not in mercantile
-                se_tile = self.tile(
-                    e - LL_EPSILON,
-                    s + LL_EPSILON,
-                    z,
-                    ignore_coalescence=True,
-                )
-
+                nw_tile = self._tile(w, n, z, ignore_coalescence=True)
+                se_tile = self._tile(e, s, z, ignore_coalescence=True)
                 minx = min(nw_tile.x, se_tile.x)
                 maxx = max(nw_tile.x, se_tile.x)
                 miny = min(nw_tile.y, se_tile.y)
@@ -1306,6 +1384,7 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
         buffer: Optional[NumType] = None,
         precision: Optional[int] = None,
         projected: bool = False,
+        geographic_crs: Optional[CRS] = None,
     ) -> Dict:
         """
         Get the GeoJSON feature corresponding to a tile.
@@ -1327,16 +1406,27 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
             otherwise original coordinate values will be preserved (default).
         projected : bool, optional
             Return coordinates in TMS projection. Default is false.
+        geographic_crs: pyproj.CRS, optional
+            Geographic CRS to use when `projected=False`. Default to 'EPSG:4326' as per GeoJSON specification.
+            .
 
         Returns
         -------
         dict
 
         """
+        geographic_crs = geographic_crs or WGS84_CRS
+
+        feature_crs = self.crs._pyproj_crs
         west, south, east, north = self.xy_bounds(tile)
 
         if not projected:
-            west, south, east, north = self._to_geographic.transform_bounds(
+            feature_crs = geographic_crs
+            tr = pyproj.Transformer.from_crs(
+                self.crs._pyproj_crs, geographic_crs, always_xy=True
+            )
+
+            west, south, east, north = tr.transform_bounds(
                 west, south, east, north, densify_pts=21
             )
 
@@ -1362,25 +1452,38 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
             "geometry": geom,
             "properties": {
                 "title": f"XYZ tile {xyz}",
-                "grid_name": self.id,
-                "grid_crs": CRS_to_uri(self.crs._pyproj_crs),
+                "tms": self.id,
+                "tms_crs": CRS_to_uri(self.crs._pyproj_crs),
             },
         }
 
-        if projected:
+        if feature_crs != WGS84_CRS:
             warnings.warn(
                 "CRS is no longer part of the GeoJSON specification."
                 "Other projection than EPSG:4326 might not be supported.",
                 UserWarning,
+                stacklevel=1,
             )
-            feat.update(
-                {
-                    "crs": {
-                        "type": "EPSG",
-                        "properties": {"code": self.crs.to_epsg()},
+
+            if authority_code := feature_crs.to_authority(min_confidence=20):
+                authority, code = authority_code
+                feat.update(
+                    {
+                        "crs": {
+                            "type": "name",
+                            "properties": {"name": CRS_to_uri(feature_crs)},
+                        }
                     }
-                }
-            )
+                )
+            else:
+                feat.update(
+                    {
+                        "crs": {
+                            "type": "wkt",
+                            "properties": {"wkt": feature_crs.to_wkt()},
+                        }
+                    }
+                )
 
         if props:
             feat["properties"].update(props)
@@ -1477,11 +1580,12 @@ class TileMatrixSet(BaseModel, arbitrary_types_allowed=True):
             "y": {"min": 0, "max": m.matrixHeight - 1},
         }
 
-    def is_valid(self, *tile: Tile) -> bool:
+    def is_valid(self, *tile: Tile, strict: bool = True) -> bool:
         """Check if a tile is valid."""
         t = _parse_tile_arg(*tile)
 
-        if t.z < self.minzoom:
+        disable_overzoom = self.is_variable or strict
+        if t.z < self.minzoom or (disable_overzoom and t.z > self.maxzoom):
             return False
 
         matrix = self.matrix(t.z)