xbarray 0.0.1a8__py3-none-any.whl → 0.0.1a10__py3-none-any.whl

xbarray/__init__.py

@@ -1 +1 @@
-from .base import * # Import Abstract Typings
+from .backends.base import * # Import Abstract Typings

xbarray/backends/_cls_base.py

@@ -0,0 +1,9 @@
+from typing import Type, Generic
+from .base import BArrayType, BDeviceType, BDtypeType, BRNGType
+
+class ComputeBackendImplCls(Generic[BArrayType, BDeviceType, BDtypeType, BRNGType], Type):
+    def __str__(self):
+        return self.simplified_name
+    
+    def __repr__(self):
+        return self.simplified_name

xbarray/{_src/implementations → backends/_implementations}/_common/implementations.py

@@ -1,10 +1,12 @@
-from typing import Any, Union, Callable
+from typing import Any, Union, Callable, Mapping, Sequence
 from array_api_typing.typing_compat import ArrayAPINamespace as CompatNamespace, ArrayAPIArray as CompatArray, ArrayAPIDType as CompatDType
 import array_api_compat
+import dataclasses
 
 __all__ = [
     "get_abbreviate_array_function",
     "get_map_fn_over_arrays_function",
+    "get_pad_dim_function",
 ]
 
 def get_abbreviate_array_function(
@@ -51,12 +53,35 @@ def get_map_fn_over_arrays_function(
         """
         if is_backendarray(data):
             return func(data)
-        elif isinstance(data, dict):
-            return {k: map_fn_over_arrays(v, func) for k, v in data.items()}
-        elif isinstance(data, tuple):
-            return tuple(map_fn_over_arrays(i, func) for i in data)
-        elif isinstance(data, list):
-            return [map_fn_over_arrays(i, func) for i in data]
+        elif isinstance(data, Mapping):
+            ret = {k: map_fn_over_arrays(v, func) for k, v in data.items()}
+            try:
+                return type(data)(**ret)  # try to keep the same mapping type
+            except:
+                return ret
+        elif isinstance(data, Sequence):
+            ret = [map_fn_over_arrays(i, func) for i in data]
+            try:
+                return type(data)(ret)  # try to keep the same sequence type
+            except:
+                return ret
+        elif dataclasses.is_dataclass(data):
+            return type(data)(**map_fn_over_arrays(dataclasses.asdict(data), func))
         else:
             return data
     return map_fn_over_arrays
+
+def get_pad_dim_function(
+    backend : CompatNamespace[CompatArray, Any, Any],
+):
+    def pad_dim(x : CompatArray, dim : int, target_size : int, value : Union[float, int] = 0) -> CompatArray:
+        size_at_target = x.shape[dim]
+        if size_at_target > target_size:
+            raise ValueError(f"Cannot pad dimension {dim} of size {size_at_target} to smaller target size {target_size}")
+        if size_at_target == target_size:
+            return x
+        target_size = list(x.shape)
+        target_size[dim] = target_size - size_at_target
+        pad_value = backend.full(target_size, value, dtype=x.dtype, device=array_api_compat.device(x))
+        return backend.concat([x, pad_value], axis=dim)
+    return pad_dim

xbarray/{_src/implementations → backends/_implementations}/jax/_extra.py

@@ -3,7 +3,7 @@ import jax
 import jax.numpy as jnp
 import numpy as np
 from ._typing import ARRAY_TYPE, DTYPE_TYPE, DEVICE_TYPE, RNG_TYPE
-from xbarray.base import ComputeBackend, SupportsDLPack
+from xbarray.backends.base import ComputeBackend, SupportsDLPack
 
 __all__ = [
     "default_integer_dtype",
@@ -96,3 +96,6 @@ def map_fn_over_arrays(
         func,
         data
     )
+pad_dim = get_pad_dim_function(
+    backend=compat_module,
+)

xbarray/{_src/implementations → backends/_implementations}/numpy/_extra.py

@@ -1,7 +1,7 @@
 from typing import Any, Union, Optional
 import numpy as np
 from ._typing import ARRAY_TYPE, DTYPE_TYPE, DEVICE_TYPE, RNG_TYPE
-from xbarray.base import ComputeBackend, SupportsDLPack
+from xbarray.backends.base import ComputeBackend, SupportsDLPack
 
 __all__ = [
     "default_integer_dtype",
@@ -68,7 +68,7 @@ def dtype_is_boolean(
 ) -> bool:
     return dtype == np.bool_ or dtype == bool
 
-from .._common.implementations import get_abbreviate_array_function, get_map_fn_over_arrays_function
+from .._common.implementations import *
 from array_api_compat import numpy as compat_module
 abbreviate_array = get_abbreviate_array_function(
     backend=compat_module,
@@ -80,4 +80,8 @@ abbreviate_array = get_abbreviate_array_function(
 
 map_fn_over_arrays = get_map_fn_over_arrays_function(
     is_backendarray=is_backendarray,
+)
+
+pad_dim = get_pad_dim_function(
+    backend=compat_module,
 )

xbarray/{_src/implementations → backends/_implementations}/pytorch/_extra.py

@@ -2,7 +2,7 @@ from typing import Any, Union, Optional
 import numpy as np
 import torch
 from ._typing import ARRAY_TYPE, DTYPE_TYPE, DEVICE_TYPE, RNG_TYPE
-from xbarray.base import ComputeBackend, SupportsDLPack
+from xbarray.backends.base import ComputeBackend, SupportsDLPack
 
 PYTORCH_DTYPE_CAST_MAP = {
     torch.uint16: torch.int16,
@@ -95,7 +95,7 @@ def dtype_is_boolean(
 ) -> bool:
     return dtype == torch.bool
 
-from .._common.implementations import get_abbreviate_array_function, get_map_fn_over_arrays_function
+from .._common.implementations import *
 from array_api_compat import torch as compat_module
 abbreviate_array = get_abbreviate_array_function(
     compat_module, 
@@ -106,4 +106,7 @@ abbreviate_array = get_abbreviate_array_function(
 )
 map_fn_over_arrays = get_map_fn_over_arrays_function(
     is_backendarray=is_backendarray,
+)
+pad_dim = get_pad_dim_function(
+    backend=compat_module,
 )

xbarray/{base → backends}/base.py

@@ -189,7 +189,7 @@ class ComputeBackend(ArrayAPINamespace[BArrayType, BDeviceType, BDtypeType], Pro
         Abbreviates an array to a single element if possible.
         Or, if some dimensions are the same, abbreviates to a smaller array (but with the same number of dimensions).
         """
-        pass
+        raise NotImplementedError
     
     @abc.abstractmethod
     def map_fn_over_arrays(self, data : Any, func : Callable[[BArrayType], BArrayType]) -> Any:
@@ -197,3 +197,13 @@ class ComputeBackend(ArrayAPINamespace[BArrayType, BDeviceType, BDtypeType], Pro
         Map a function over arrays in a data structure and produce a new data structure with the same shape.
         This is useful for applying a function to all arrays in a nested structure.
         """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def pad_dim(self, x : BArrayType, dim : int, target_size : int, value : Union[float, int] = 0) -> BArrayType:
+        """
+        Pad a dimension of an array to a target size with a given value.
+        If the dimension is already the target size, return the original array.
+        If the dimension is larger than the target size, raise an error.
+        """
+        raise NotImplementedError

xbarray/backends/jax.py

@@ -0,0 +1,19 @@
+from ._cls_base import ComputeBackendImplCls
+from ._implementations import jax as jax_impl
+
+class JaxComputeBackend(metaclass=ComputeBackendImplCls[jax_impl.ARRAY_TYPE, jax_impl.DEVICE_TYPE, jax_impl.DTYPE_TYPE, jax_impl.RNG_TYPE]):
+    ARRAY_TYPE = jax_impl.ARRAY_TYPE
+    DTYPE_TYPE = jax_impl.DTYPE_TYPE
+    DEVICE_TYPE = jax_impl.DEVICE_TYPE
+    RNG_TYPE = jax_impl.RNG_TYPE
+
+for name in dir(jax_impl):
+    if not name.startswith('_') or name in [
+        '__array_namespace_info__',
+        '__array_api_version__',
+    ]:
+        setattr(JaxComputeBackend, name, getattr(jax_impl, name))
+
+__all__ = [
+    'JaxComputeBackend',
+]

xbarray/backends/numpy.py

@@ -0,0 +1,19 @@
+from ._cls_base import ComputeBackendImplCls
+from ._implementations import numpy as numpy_impl
+
+class NumpyComputeBackend(metaclass=ComputeBackendImplCls[numpy_impl.ARRAY_TYPE, numpy_impl.DEVICE_TYPE, numpy_impl.DTYPE_TYPE, numpy_impl.RNG_TYPE]):
+    ARRAY_TYPE = numpy_impl.ARRAY_TYPE
+    DTYPE_TYPE = numpy_impl.DTYPE_TYPE
+    DEVICE_TYPE = numpy_impl.DEVICE_TYPE
+    RNG_TYPE = numpy_impl.RNG_TYPE
+
+for name in dir(numpy_impl):
+    if not name.startswith('_') or name in [
+        '__array_namespace_info__',
+        '__array_api_version__',
+    ]:
+        setattr(NumpyComputeBackend, name, getattr(numpy_impl, name))
+
+__all__ = [
+    'NumpyComputeBackend',
+]

xbarray/backends/pytorch.py

@@ -0,0 +1,22 @@
+from ._cls_base import ComputeBackendImplCls
+from ._implementations import pytorch as pytorch_impl
+
+class PytorchComputeBackend(metaclass=ComputeBackendImplCls[pytorch_impl.ARRAY_TYPE, pytorch_impl.DEVICE_TYPE, pytorch_impl.DTYPE_TYPE, pytorch_impl.RNG_TYPE]):
+    ARRAY_TYPE = pytorch_impl.ARRAY_TYPE
+    DTYPE_TYPE = pytorch_impl.DTYPE_TYPE
+    DEVICE_TYPE = pytorch_impl.DEVICE_TYPE
+    RNG_TYPE = pytorch_impl.RNG_TYPE
+
+for name in dir(pytorch_impl):
+    if not name.startswith('_') or name in [
+        '__array_namespace_info__',
+        '__array_api_version__',
+    ]:
+        try:
+            setattr(PytorchComputeBackend, name, getattr(pytorch_impl, name))
+        except AttributeError:
+            pass
+
+__all__ = [
+    'PytorchComputeBackend',
+]

xbarray/jax.py

@@ -1,19 +1,4 @@
-from xbarray.cls_impl.cls_base import ComputeBackendImplCls
-from ._src.implementations import jax as jax_impl
-
-class JaxComputeBackend(metaclass=ComputeBackendImplCls):
-    ARRAY_TYPE = jax_impl.ARRAY_TYPE
-    DTYPE_TYPE = jax_impl.DTYPE_TYPE
-    DEVICE_TYPE = jax_impl.DEVICE_TYPE
-    RNG_TYPE = jax_impl.RNG_TYPE
-
-for name in dir(jax_impl):
-    if not name.startswith('_') or name in [
-        '__array_namespace_info__',
-        '__array_api_version__',
-    ]:
-        setattr(JaxComputeBackend, name, getattr(jax_impl, name))
-
-__all__ = [
-    'JaxComputeBackend',
-]
+""" This file is generated for backward compatibility.
+If you are using xbarray >= 0.0.1a9, please import from `xbarray.backends.jax` instead.
+"""
+from .backends.jax import *

xbarray/numpy.py

@@ -1,19 +1,4 @@
-from xbarray.cls_impl.cls_base import ComputeBackendImplCls
-from ._src.implementations import numpy as numpy_impl
-
-class NumpyComputeBackend(metaclass=ComputeBackendImplCls):
-    ARRAY_TYPE = numpy_impl.ARRAY_TYPE
-    DTYPE_TYPE = numpy_impl.DTYPE_TYPE
-    DEVICE_TYPE = numpy_impl.DEVICE_TYPE
-    RNG_TYPE = numpy_impl.RNG_TYPE
-
-for name in dir(numpy_impl):
-    if not name.startswith('_') or name in [
-        '__array_namespace_info__',
-        '__array_api_version__',
-    ]:
-        setattr(NumpyComputeBackend, name, getattr(numpy_impl, name))
-
-__all__ = [
-    'NumpyComputeBackend',
-]
+""" This file is generated for backward compatibility.
+If you are using xbarray >= 0.0.1a9, please import from `xbarray.backends.numpy` instead.
+"""
+from .backends.numpy import *

xbarray/pytorch.py

@@ -1,19 +1,4 @@
-from xbarray.cls_impl.cls_base import ComputeBackendImplCls
-from ._src.implementations import pytorch as pytorch_impl
-
-class PytorchComputeBackend(metaclass=ComputeBackendImplCls):
-    ARRAY_TYPE = pytorch_impl.ARRAY_TYPE
-    DTYPE_TYPE = pytorch_impl.DTYPE_TYPE
-    DEVICE_TYPE = pytorch_impl.DEVICE_TYPE
-    RNG_TYPE = pytorch_impl.RNG_TYPE
-
-for name in dir(pytorch_impl):
-    if not name.startswith('_') or name in [
-        '__array_namespace_info__',
-        '__array_api_version__',
-    ]:
-        setattr(PytorchComputeBackend, name, getattr(pytorch_impl, name))
-
-__all__ = [
-    'PytorchComputeBackend',
-]
+""" This file is generated for backward compatibility.
+If you are using xbarray >= 0.0.1a9, please import from `xbarray.backends.pytorch` instead.
+"""
+from .backends.pytorch import *

xbarray/transformations/pointcloud/__init__.py

@@ -0,0 +1 @@
+from .base import *

xbarray/transformations/pointcloud/base.py

@@ -0,0 +1,185 @@
+from typing import Optional
+from xbarray.backends.base import ComputeBackend, BArrayType, BDeviceType, BDtypeType, BRNGType
+
+__all__ = [
+    "pixel_coordinate_and_depth_to_world",
+    "depth_image_to_world",
+    "world_to_pixel_coordinate_and_depth",
+    "world_to_depth",
+]
+
+def pixel_coordinate_and_depth_to_world(
+    backend : ComputeBackend,
+    pixel_coordinates : BArrayType, 
+    depth : BArrayType,
+    intrinsic_matrix : BArrayType,
+    extrinsic_matrix : BArrayType
+) -> BArrayType:
+    """
+    Convert pixel coordinates and depth to world coordinates.
+    Args:
+        backend (ComputeBackend): The compute backend to use.
+        pixel_coordinates (BArrayType): The pixel coordinates of shape (..., N, 2).
+        depth (BArrayType): The depth values of shape (..., N). Assume invalid depth is either nan or <= 0.
+        intrinsic_matrix (BArrayType): The camera intrinsic matrix of shape (..., 3, 3).
+        extrinsic_matrix (BArrayType): The camera extrinsic matrix of shape (..., 3, 4) or (..., 4, 4).
+    Returns:
+        BArrayType: The world coordinates of shape (..., N, 4). The last dimension is (x, y, z, valid_mask).
+    """
+    xs = pixel_coordinates[..., 0]  # (..., N)
+    ys = pixel_coordinates[..., 1]  # (..., N)
+    xs_norm = (xs - intrinsic_matrix[..., None, 0, 2]) / intrinsic_matrix[..., None, 0, 0]  # (..., N)
+    ys_norm = (ys - intrinsic_matrix[..., None, 1, 2]) / intrinsic_matrix[..., None, 1, 1]  # (..., N)
+
+    camera_coords = backend.stack([
+        xs_norm,
+        ys_norm,
+        backend.ones_like(depth)
+    ], dim=-1) # (..., N, 3)
+    camera_coords *= depth[..., None]  # (..., N, 3)
+
+    R = extrinsic_matrix[..., :3, :3]  # (..., 3, 3)
+    t = extrinsic_matrix[..., :3, 3]  # (..., 3)
+
+    shifted_camera_coords = camera_coords - t[..., None, :]  # (..., N, 3)
+    world_coords = backend.matmul(shifted_camera_coords, R) # (..., N, 3)
+
+    valid_depth_mask = backend.logical_not(backend.logical_or(
+        backend.isnan(depth),
+        depth <= 0
+    )) # (..., N)
+    return backend.concat([
+        world_coords,
+        valid_depth_mask[..., None]
+    ], dim=-1) # (..., N, 4)
+
+def depth_image_to_world(
+    backend : ComputeBackend,
+    depth_image : BArrayType,
+    intrinsic_matrix : BArrayType,
+    extrinsic_matrix : BArrayType
+) -> BArrayType:
+    """
+    Convert a depth image to world coordinates.
+    Args:
+        backend (ComputeBackend): The compute backend to use.
+        depth_image (BArrayType): The depth image of shape (..., H, W).
+        intrinsic_matrix (BArrayType): The camera intrinsic matrix of shape (..., 3, 3).
+        extrinsic_matrix (BArrayType): The camera extrinsic matrix of shape (..., 3, 4) or (..., 4, 4).
+    Returns:
+        BArrayType: The world coordinates of shape (..., H, W, 4). The last dimension is (x, y, z, valid_mask).
+    """
+    H, W = depth_image.shape[-2:]
+    ys, xs = backend.meshgrid(
+        backend.arange(H, device=backend.device(depth_image), dtype=depth_image.dtype),
+        backend.arange(W, device=backend.device(depth_image), dtype=depth_image.dtype),
+        indexing='ij'
+    ) # (H, W), (H, W)
+    pixel_coordinates = backend.stack([xs, ys], dim=-1) # (H, W, 2)
+    pixel_coordinates = backend.reshape(pixel_coordinates, [1] * (len(depth_image.shape) - 2) + [H * W, 2]) # (..., H * W, 2)
+    world_coords = pixel_coordinate_and_depth_to_world(
+        backend,
+        pixel_coordinates,
+        depth_image.reshape(depth_image.shape[:-2] + [H * W]), # (..., H * W)
+        intrinsic_matrix,
+        extrinsic_matrix
+    ) # (..., H * W, 4)
+    world_coords = backend.reshape(world_coords, depth_image.shape[:-2] + [H, W, 4]) # (..., H, W, 4)
+    return world_coords
+
+def world_to_pixel_coordinate_and_depth(
+    backend : ComputeBackend,
+    world_coords : BArrayType,
+    intrinsic_matrix : BArrayType,
+    extrinsic_matrix : Optional[BArrayType] = None
+) -> BArrayType:
+    """
+    Convert world coordinates to pixel coordinates and depth.
+    Args:
+        backend (ComputeBackend): The compute backend to use.
+        world_coords (BArrayType): The world coordinates of shape (..., N, 3) or (..., N, 4). If the last dimension is 4, the last element is treated as a valid mask.
+        intrinsic_matrix (BArrayType): The camera intrinsic matrix of shape (..., 3, 3).
+        extrinsic_matrix (Optional[BArrayType]): The camera extrinsic matrix of shape (..., 3, 4) or (..., 4, 4). If None, assume identity matrix.
+    Returns:
+        BArrayType: The pixel coordinates xy of shape (..., N, 2). 
+        BArrayType: The depth values of shape (..., N). Invalid points (where valid mask is False) will have depth 0.
+    """
+    if world_coords.shape[-1] == 3:
+        world_coords_h = backend.pad_dim(
+            world_coords,
+            dim=-1,
+            value=0
+        )
+    else:
+        assert world_coords.shape[-1] == 4
+        world_coords_h = world_coords
+    
+    if extrinsic_matrix is not None:
+        camera_coords = backend.matmul(
+            extrinsic_matrix, # (..., 3, 4) or (..., 4, 4)
+            backend.matrix_transpose(world_coords_h) # (..., 4, N)
+        ) # (..., 3, N) or (..., 4, N)
+        camera_coords = backend.matrix_transpose(camera_coords) # (..., N, 3) or (..., N, 4)
+        if camera_coords.shape[-1] == 4:
+            camera_coords = camera_coords[..., :3] / camera_coords[..., 3:4]
+    else:
+        camera_coords = world_coords_h[..., :3] # (..., N, 3)
+    
+    point_px_homogeneous = backend.matmul(
+        intrinsic_matrix, # (..., 3, 3)
+        backend.matrix_transpose(camera_coords) # (..., 3, N)
+    ) # (..., 3, N)
+    point_px_homogeneous = backend.matrix_transpose(point_px_homogeneous) # (..., N, 3)
+    point_px = point_px_homogeneous[..., :2] / point_px_homogeneous[..., 2:3] # (..., N, 2)
+
+    depth = camera_coords[..., 2] # (..., N)
+    depth_valid = depth > 0
+    depth = backend.where(depth_valid, depth, 0)
+    point_px = backend.where(
+        depth_valid[..., None],
+        point_px,
+        0
+    )
+    return point_px, depth
+
+
+def world_to_depth(
+    backend : ComputeBackend,
+    world_coords : BArrayType,
+    extrinsic_matrix : Optional[BArrayType] = None
+) -> BArrayType:
+    """
+    Convert world coordinates to pixel coordinates and depth.
+    Args:
+        backend (ComputeBackend): The compute backend to use.
+        world_coords (BArrayType): The world coordinates of shape (..., N, 3) or (..., N, 4). If the last dimension is 4, the last element is treated as a valid mask.
+        extrinsic_matrix (Optional[BArrayType]): The camera extrinsic matrix of shape (..., 3, 4) or (..., 4, 4). If None, assume identity matrix.
+    Returns:
+        BArrayType: The depth values of shape (..., N). Invalid points (where valid mask is False) will have depth 0.
+    """
+    if world_coords.shape[-1] == 3:
+        world_coords_h = backend.pad_dim(
+            world_coords,
+            dim=-1,
+            value=0
+        )
+    else:
+        assert world_coords.shape[-1] == 4
+        world_coords_h = world_coords
+    
+    if extrinsic_matrix is not None:
+        camera_coords = backend.matmul(
+            extrinsic_matrix, # (..., 3, 4) or (..., 4, 4)
+            backend.matrix_transpose(world_coords_h) # (..., 4, N)
+        ) # (..., 3, N) or (..., 4, N)
+        camera_coords = backend.matrix_transpose(camera_coords) # (..., N, 3) or (..., N, 4)
+        if camera_coords.shape[-1] == 4:
+            camera_coords = camera_coords[..., :3] / camera_coords[..., 3:4]
+    else:
+        camera_coords = world_coords_h[..., :3] # (..., N, 3)
+    
+    depth = camera_coords[..., 2] # (..., N)
+    depth_valid = depth > 0
+    depth = backend.where(depth_valid, depth, 0)
+    return depth
+

xbarray/transformations/pointcloud/jax.py

@@ -0,0 +1,15 @@
+from . import base as base_impl
+from functools import partial
+from xbarray.backends.jax import JaxComputeBackend as BindingBackend
+
+__all__ = [
+    "pixel_coordinate_and_depth_to_world",
+    "depth_image_to_world",
+    "world_to_pixel_coordinate_and_depth",
+    "world_to_depth",
+]
+
+pixel_coordinate_and_depth_to_world = partial(base_impl.pixel_coordinate_and_depth_to_world, BindingBackend)
+depth_image_to_world = partial(base_impl.depth_image_to_world, BindingBackend)
+world_to_pixel_coordinate_and_depth = partial(base_impl.world_to_pixel_coordinate_and_depth, BindingBackend)
+world_to_depth = partial(base_impl.world_to_depth, BindingBackend)

xbarray/transformations/pointcloud/numpy.py

@@ -0,0 +1,15 @@
+from . import base as base_impl
+from functools import partial
+from xbarray.backends.numpy import NumpyComputeBackend as BindingBackend
+
+__all__ = [
+    "pixel_coordinate_and_depth_to_world",
+    "depth_image_to_world",
+    "world_to_pixel_coordinate_and_depth",
+    "world_to_depth",
+]
+
+pixel_coordinate_and_depth_to_world = partial(base_impl.pixel_coordinate_and_depth_to_world, BindingBackend)
+depth_image_to_world = partial(base_impl.depth_image_to_world, BindingBackend)
+world_to_pixel_coordinate_and_depth = partial(base_impl.world_to_pixel_coordinate_and_depth, BindingBackend)
+world_to_depth = partial(base_impl.world_to_depth, BindingBackend)

xbarray/transformations/pointcloud/pytorch.py

@@ -0,0 +1,15 @@
+from . import base as base_impl
+from functools import partial
+from xbarray.backends.pytorch import PytorchComputeBackend as BindingBackend
+
+__all__ = [
+    "pixel_coordinate_and_depth_to_world",
+    "depth_image_to_world",
+    "world_to_pixel_coordinate_and_depth",
+    "world_to_depth",
+]
+
+pixel_coordinate_and_depth_to_world = partial(base_impl.pixel_coordinate_and_depth_to_world, BindingBackend)
+depth_image_to_world = partial(base_impl.depth_image_to_world, BindingBackend)
+world_to_pixel_coordinate_and_depth = partial(base_impl.world_to_pixel_coordinate_and_depth, BindingBackend)
+world_to_depth = partial(base_impl.world_to_depth, BindingBackend)

xbarray/transformations/rotation_conversions/__init__.py

@@ -0,0 +1 @@
+from .base import *