lsst.scarlet.lite.observation Namespace Reference

Classes
class	Observation

Functions
np.ndarray	get_filter_coords (np.ndarray filter_values, tuple[int, int]|None center=None)
tuple[int, int, int, int]	get_filter_bounds (np.ndarray coords)
	convolve (np.ndarray image, np.ndarray psf, tuple[int, int, int, int] bounds)
Image	_set_image_like (np.ndarray|Image images, tuple|None bands=None, Box|None bbox=None)

Function Documentation

_set_image_like()

Image lsst.scarlet.lite.observation._set_image_like ( np.ndarray | Image images, tuple | None bands = None, Box | None bbox = None )

protected

Ensure that an image-like array is cast appropriately as an image

Parameters
----------
images:
    The multiband image-like array to cast as an Image.
    If it already has `bands` and `bbox` properties then it is returned
    with no modifications.
bands:
    The bands for the multiband-image.
    If `images` is a numpy array, this parameter is mandatory.
    If `images` is an `Image` and `bands` is not `None`,
    then `bands` is ignored.
bbox:
    Bounding box containing the image.
    If `images` is a numpy array, this parameter is mandatory.
    If `images` is an `Image` and `bbox` is not `None`,
    then `bbox` is ignored.

Returns
-------
images: Image
    The input images converted into an image.

Definition at line 131 of file observation.py.

def _set_image_like(images: np.ndarray | Image, bands: tuple | None = None, bbox: Box | None = None) -> Image:
    """Ensure that an image-like array is cast appropriately as an image
 
    Parameters
    ----------
    images:
        The multiband image-like array to cast as an Image.
        If it already has `bands` and `bbox` properties then it is returned
        with no modifications.
    bands:
        The bands for the multiband-image.
        If `images` is a numpy array, this parameter is mandatory.
        If `images` is an `Image` and `bands` is not `None`,
        then `bands` is ignored.
    bbox:
        Bounding box containing the image.
        If `images` is a numpy array, this parameter is mandatory.
        If `images` is an `Image` and `bbox` is not `None`,
        then `bbox` is ignored.
 
    Returns
    -------
    images: Image
        The input images converted into an image.
    """
    if isinstance(images, Image):
        # This is already an image
        if bbox is not None and images.bbox != bbox:
            raise ValueError(f"Bounding boxes {images.bbox} and {bbox} do not agree")
        return images
 
    if bbox is None:
        bbox = Box(images.shape[-2:])
    return Image(images, bands=bands, yx0=cast(tuple[int, int], bbox.origin))
 
 

convolve()

lsst.scarlet.lite.observation.convolve	(	np.ndarray	image,
		np.ndarray	psf,
		tuple[int, int, int, int]	bounds )

Convolve an image with a PSF in real space

Parameters
----------
image:
    The multi-band image to convolve.
psf:
    The psf to convolve the image with.
bounds:
    The filter bounds required by the ``apply_filter`` C++ method,
    usually obtained by calling `get_filter_bounds`.

Definition at line 100 of file observation.py.

def convolve(image: np.ndarray, psf: np.ndarray, bounds: tuple[int, int, int, int]):
    """Convolve an image with a PSF in real space
 
    Parameters
    ----------
    image:
        The multi-band image to convolve.
    psf:
        The psf to convolve the image with.
    bounds:
        The filter bounds required by the ``apply_filter`` C++ method,
        usually obtained by calling `get_filter_bounds`.
    """
    from lsst.scarlet.lite.operators_pybind11 import apply_filter  # type: ignore
 
    result = np.empty(image.shape, dtype=image.dtype)
    for band in range(len(image)):
        img = image[band]
 
        apply_filter(
            img,
            psf[band].reshape(-1),
            bounds[0],
            bounds[1],
            bounds[2],
            bounds[3],
            result[band],
        )
    return result
 
 

get_filter_bounds()

tuple[int, int, int, int] lsst.scarlet.lite.observation.get_filter_bounds

(

np.ndarray

coords

)

Get the slices in x and y to apply a filter

Parameters
----------
coords:
    The coordinates of the filter,
    defined by `get_filter_coords`.

Returns
-------
y_start, y_end, x_start, x_end:
    The start and end of each slice that is passed to `apply_filter`.

Definition at line 76 of file observation.py.

def get_filter_bounds(coords: np.ndarray) -> tuple[int, int, int, int]:
    """Get the slices in x and y to apply a filter
 
    Parameters
    ----------
    coords:
        The coordinates of the filter,
        defined by `get_filter_coords`.
 
    Returns
    -------
    y_start, y_end, x_start, x_end:
        The start and end of each slice that is passed to `apply_filter`.
    """
    z = np.zeros((len(coords),), dtype=int)
    # Set the y slices
    y_start = np.max([z, coords[:, 0]], axis=0)
    y_end = -np.min([z, coords[:, 0]], axis=0)
    # Set the x slices
    x_start = np.max([z, coords[:, 1]], axis=0)
    x_end = -np.min([z, coords[:, 1]], axis=0)
    return y_start, y_end, x_start, x_end
 
 

get_filter_coords()

np.ndarray lsst.scarlet.lite.observation.get_filter_coords	(	np.ndarray	filter_values,
		tuple[int, int] | None	center = None )

Create filter coordinate grid needed for the apply filter function

Parameters
----------
filter_values:
    The 2D array of the filter to apply.
center:
    The center (y,x) of the filter. If `center` is `None` then
    `filter_values` must have an odd number of rows and columns
    and the center will be set to the center of `filter_values`.

Returns
-------
coords:
    The coordinates of the pixels in `filter_values`,
    where the coordinates of the `center` pixel are `(0,0)`.

Definition at line 38 of file observation.py.

def get_filter_coords(filter_values: np.ndarray, center: tuple[int, int] | None = None) -> np.ndarray:
    """Create filter coordinate grid needed for the apply filter function
 
    Parameters
    ----------
    filter_values:
        The 2D array of the filter to apply.
    center:
        The center (y,x) of the filter. If `center` is `None` then
        `filter_values` must have an odd number of rows and columns
        and the center will be set to the center of `filter_values`.
 
    Returns
    -------
    coords:
        The coordinates of the pixels in `filter_values`,
        where the coordinates of the `center` pixel are `(0,0)`.
    """
    if filter_values.ndim != 2:
        raise ValueError("`filter_values` must be 2D")
    if center is None:
        if filter_values.shape[0] % 2 == 0 or filter_values.shape[1] % 2 == 0:
            msg = """Ambiguous center of the `filter_values` array,
                     you must use a `filter_values` array
                     with an odd number of rows and columns or
                     calculate `coords` on your own."""
            raise ValueError(msg)
        center = tuple([filter_values.shape[0] // 2, filter_values.shape[1] // 2])  # type: ignore
    center = cast(tuple[int, int], center)
    x = np.arange(filter_values.shape[1])
    y = np.arange(filter_values.shape[0])
    x, y = np.meshgrid(x, y)
    x -= center[1]
    y -= center[0]
    coords = np.dstack([y, x])
    return coords