Can we specify name of X and Y columns from DIMS while reading netCDF

[krishnaglodha]

I'm trying to read netcdf file which has dimensions as ('TIME', 'COADSY', 'COADSX') because of this, when I run any API from titiler.xarray, I'm getting an error

  File "/Users/krishnaglodha/Documents/content/content/titiler/env/lib/python3.12/site-packages/titiler/xarray/io.py", line 113, in _arrange_dims
    raise ValueError(f"Couldn't find X/Y dimensions in {da.dims}") from e
ValueError: Couldn't find X/Y dimensions in ('TIME', 'COADSY', 'COADSX')

I'm imagining that this might be because the default X and Y are not available in dimensions, but that might be the case with many datasets. If we can let user also specify X and Y dimension similar to show_time , that'd be great!

I'd love to contribute to this issue as well

[hrodmn]

Hi @krishnaglodha - thanks for raising this discussion! titiler.xarray will check for lon or lat dimensions and use those if they are available, but that's the only logic we have to handle this type of scenario.

titiler/src/titiler/xarray/titiler/xarray/io.py

Lines 100 to 113 in 4aa57c3

	if "x" not in da.dims and "y" not in da.dims:
	try:
	latitude_var_name = next(
	name
	for name in ["lat", "latitude", "LAT", "LATITUDE", "Lat"]
	if name in da.dims
	)
	longitude_var_name = next(
	name
	for name in ["lon", "longitude", "LON", "LONGITUDE", "Lon"]
	if name in da.dims
	)
	except StopIteration as e:
	raise ValueError(f"Couldn't find X/Y dimensions in {da.dims}") from e

I think it could be useful to add a pair of parameters x_dim and y_dim to the XarrayDsParams dependency class, which could be passed along to the Reader for opening the dataset and setting the x/y dimensions.

titiler/src/titiler/xarray/titiler/xarray/dependencies.py

Lines 40 to 58 in 4aa57c3

	class XarrayDsParams(DefaultDependency):
	"""Xarray Dataset Options."""
	variable: Annotated[str, Query(description="Xarray Variable name.")]
	sel: Annotated[
	Optional[List[SelDimStr]],
	Query(
	description="Xarray Indexing using dimension names `{dimension}={value}`.",
	),
	] = None
	method: Annotated[
	Optional[Literal["nearest", "pad", "ffill", "backfill", "bfill"]],
	Query(
	alias="sel_method",
	description="Xarray indexing method to use for inexact matches.",
	),
	] = None

I'd love to contribute to this issue as well

It would be great if you opened a PR with this change!

[vincentsarago]

it's hard to keep up with everything people can do with their NetCDF and I don't think we should over-compensate on titiler side.

Note: we tend to support what rioxarray supported and COADSX or COADSY are not supported

That's said, you could easily build a custom IO

from typing import Any, Callable, Dict, List, Literal, Optional, Union
from urllib.parse import urlparse

import attr
import xarray
from morecantile import TileMatrixSet
from rio_tiler.constants import WEB_MERCATOR_TMS
from rio_tiler.io.xarray import XarrayReader

from titiler.xarray.io import xarray_open_dataset


def get_variable(
    ds: xarray.Dataset,
    variable: str,
    sel: Optional[List[str]] = None,
    method: Optional[Literal["nearest", "pad", "ffill", "backfill", "bfill"]] = None,
) -> xarray.DataArray:
    """Get Xarray variable as DataArray.

    Args:
        ds (xarray.Dataset): Xarray Dataset.
        variable (str): Variable to extract from the Dataset.
        sel (list of str, optional): List of Xarray Indexes.
        method (str): Xarray indexing method.

    Returns:
        xarray.DataArray: 2D or 3D DataArray.

    """
    da = ds[variable]

    # CUSTOM
    if "COADSX" in da.dims:
        da = da.rename({"COADSX": "x"})
    if "COADSY" in da.dims:
        da = da.rename({"COADSY": "y"})

    if sel:
        _idx: Dict[str, List] = {}
        for s in sel:
            val: Union[str, slice]
            dim, val = s.split("=")

            # cast string to dtype of the dimension
            if da[dim].dtype != "O":
                val = da[dim].dtype.type(val)

            if dim in _idx:
                _idx[dim].append(val)
            else:
                _idx[dim] = [val]

        sel_idx = {k: v[0] if len(v) < 2 else v for k, v in _idx.items()}
        da = da.sel(sel_idx, method=method)

    da = _arrange_dims(da)

    # Make sure we have a valid CRS
    crs = da.rio.crs or "epsg:4326"
    da = da.rio.write_crs(crs)

    if crs == "epsg:4326" and (da.x > 180).any():
        # Adjust the longitude coordinates to the -180 to 180 range
        da = da.assign_coords(x=(da.x + 180) % 360 - 180)

        # Sort the dataset by the updated longitude coordinates
        da = da.sortby(da.x)

    assert len(da.dims) in [2, 3], "titiler.xarray can only work with 2D or 3D dataset"

    return da


@attr.s
class Reader(XarrayReader):
    """Reader: Open Zarr file and access DataArray."""

    src_path: str = attr.ib()
    variable: str = attr.ib()

    # xarray.Dataset options
    opener: Callable[..., xarray.Dataset] = attr.ib(default=xarray_open_dataset)

    group: Optional[str] = attr.ib(default=None)
    decode_times: bool = attr.ib(default=True)

    # xarray.DataArray options
    sel: Optional[List[str]] = attr.ib(default=None)
    method: Optional[Literal["nearest", "pad", "ffill", "backfill", "bfill"]] = attr.ib(
        default=None
    )

    tms: TileMatrixSet = attr.ib(default=WEB_MERCATOR_TMS)

    ds: xarray.Dataset = attr.ib(init=False)
    input: xarray.DataArray = attr.ib(init=False)

    _dims: List = attr.ib(init=False, factory=list)

    def __attrs_post_init__(self):
        """Set bounds and CRS."""
        self.ds = self.opener(
            self.src_path,
            group=self.group,
            decode_times=self.decode_times,
        )

        self.input = get_variable(
            self.ds,
            self.variable,
            sel=self.sel,
            method=self.method,
        )
        super().__attrs_post_init__()

    def close(self):
        """Close xarray dataset."""
        self.ds.close()

    def __exit__(self, exc_type, exc_value, traceback):
        """Support using with Context Managers."""
        self.close()



# custom app

from fastapi import FastAPI
app = FastAPI(
    openapi_url="/api",
    docs_url="/api.html",
)

md = TilerFactory(reader=Reader)
app.include_router(md.router, tags=["Multi Dimensional"])

[krishnaglodha]

Yeah we can always create a custom reader, so should I not work on this?