lsst.scarlet.lite.operators Namespace Reference

Classes
class	Monotonicity

Functions
np.ndarray	prox_connected (np.ndarray morph, Sequence[Sequence[int]] centers)
tuple[int, int]	get_peak (np.ndarray image, tuple[int, int] center, int radius=1)
tuple[np.ndarray, np.ndarray, tuple[int, int, int, int]]	prox_monotonic_mask (np.ndarray x, tuple[int, int] center, int center_radius=1, float variance=0.0, int max_iter=3)
np.ndarray	uncentered_operator (np.ndarray x, Callable func, tuple[int, int]|None center=None, float|None fill=None, **kwargs)
	prox_sdss_symmetry (np.ndarray x)
np.ndarray	prox_uncentered_symmetry (np.ndarray x, tuple[int, int]|None center=None, float|None fill=None)

Function Documentation

get_peak()

tuple[int, int] lsst.scarlet.lite.operators.get_peak	(	np.ndarray	image,
		tuple[int, int]	center,
		int	radius = 1 )

Search around a location for the maximum flux

For monotonicity it is important to start at the brightest pixel
in the center of the source. This may be off by a pixel or two,
so we search for the correct center before applying
monotonic_tree.

Parameters
----------
image:
    The image of the source.
center:
    The suggested center of the source.
radius:
    The number of pixels around the `center` to search
    for a higher flux value.

Returns
-------
new_center:
    The true center of the source.

Definition at line 255 of file operators.py.

def get_peak(image: np.ndarray, center: tuple[int, int], radius: int = 1) -> tuple[int, int]:
    """Search around a location for the maximum flux
 
    For monotonicity it is important to start at the brightest pixel
    in the center of the source. This may be off by a pixel or two,
    so we search for the correct center before applying
    monotonic_tree.
 
    Parameters
    ----------
    image:
        The image of the source.
    center:
        The suggested center of the source.
    radius:
        The number of pixels around the `center` to search
        for a higher flux value.
 
    Returns
    -------
    new_center:
        The true center of the source.
    """
    cy, cx = int(center[0]), int(center[1])
    y0 = np.max([cy - radius, 0])
    x0 = np.max([cx - radius, 0])
    y_slice = slice(y0, cy + radius + 1)
    x_slice = slice(x0, cx + radius + 1)
    subset = image[y_slice, x_slice]
    center = cast(tuple[int, int], np.unravel_index(np.argmax(subset), subset.shape))
    return center[0] + y0, center[1] + x0
 
 

prox_connected()

np.ndarray lsst.scarlet.lite.operators.prox_connected	(	np.ndarray	morph,
		Sequence[Sequence[int]]	centers )

Remove all pixels not connected to the center of a source.

Parameters
----------
morph:
    The morphology that is being constrained.
centers:
    The `(cy, cx)` center of any sources that all pixels must be
    connected to.

Returns
-------
result:
    The morphology with all pixels that are not connected to a center
    postion set to zero.

Definition at line 11 of file operators.py.

def prox_connected(morph: np.ndarray, centers: Sequence[Sequence[int]]) -> np.ndarray:
    """Remove all pixels not connected to the center of a source.
 
    Parameters
    ----------
    morph:
        The morphology that is being constrained.
    centers:
        The `(cy, cx)` center of any sources that all pixels must be
        connected to.
 
    Returns
    -------
    result:
        The morphology with all pixels that are not connected to a center
        postion set to zero.
    """
    result = np.zeros(morph.shape, dtype=bool)
 
    for center in centers:
        unchecked = np.ones(morph.shape, dtype=bool)
        cy, cx = center
        cy = int(cy)
        cx = int(cx)
        bounds = np.array([cy, cy, cx, cx]).astype(np.int32)
        # Update the result in place with the pixels connected to this center
        get_connected_pixels(cy, cx, morph, unchecked, result, bounds, 0)
 
    return result * morph
 
 

prox_monotonic_mask()

tuple[np.ndarray, np.ndarray, tuple[int, int, int, int]] lsst.scarlet.lite.operators.prox_monotonic_mask	(	np.ndarray	x,
		tuple[int, int]	center,
		int	center_radius = 1,
		float	variance = 0.0,
		int	max_iter = 3 )

Apply monotonicity from any path from the center

Parameters
----------
x:
    The input image that the mask is created for.
center:
    The location of the center of the mask.
center_radius:
    Radius from the center pixel to search for a better center
    (ie. a pixel in `X` with higher flux than the pixel given by
     `center`).
    If `center_radius == 0` then the `center` pixel is assumed
    to be correct.
variance:
    The average variance in the image.
    This is used to allow pixels to be non-monotonic up to `variance`,
    so setting `variance=0` will force strict monotonicity in the mask.
max_iter:
    Maximum number of iterations to interpolate non-monotonic pixels.

Returns
-------
valid:
    Boolean array of pixels that are monotonic.
model:
    The model with invalid pixels masked out.
bounds:
    The bounds of the valid monotonic pixels.

Definition at line 288 of file operators.py.

) -> tuple[np.ndarray, np.ndarray, tuple[int, int, int, int]]:
    """Apply monotonicity from any path from the center
 
    Parameters
    ----------
    x:
        The input image that the mask is created for.
    center:
        The location of the center of the mask.
    center_radius:
        Radius from the center pixel to search for a better center
        (ie. a pixel in `X` with higher flux than the pixel given by
         `center`).
        If `center_radius == 0` then the `center` pixel is assumed
        to be correct.
    variance:
        The average variance in the image.
        This is used to allow pixels to be non-monotonic up to `variance`,
        so setting `variance=0` will force strict monotonicity in the mask.
    max_iter:
        Maximum number of iterations to interpolate non-monotonic pixels.
 
    Returns
    -------
    valid:
        Boolean array of pixels that are monotonic.
    model:
        The model with invalid pixels masked out.
    bounds:
        The bounds of the valid monotonic pixels.
    """
    from lsst.scarlet.lite.operators_pybind11 import (
        get_valid_monotonic_pixels,
        linear_interpolate_invalid_pixels,
    )
 
    if center_radius > 0:
        i, j = get_peak(x, center, center_radius)
    else:
        i, j = int(np.round(center[0])), int(np.round(center[1]))
    unchecked = np.ones(x.shape, dtype=bool)
    unchecked[i, j] = False
    orphans = np.zeros(x.shape, dtype=bool)
    # This is the bounding box of the result
    bounds = np.array([i, i, j, j], dtype=np.int32)
    # Get all of the monotonic pixels
    get_valid_monotonic_pixels(i, j, x, unchecked, orphans, variance, bounds, 0)
    # Set the initial model to the exact input in the valid pixels
    model = x.copy()
 
    it = 0
 
    while np.sum(orphans & unchecked) > 0 and it < max_iter:
        it += 1
        all_i, all_j = np.where(orphans)
        linear_interpolate_invalid_pixels(all_i, all_j, unchecked, model, orphans, variance, True, bounds)
    valid = ~unchecked & ~orphans
    # Clear all of the invalid pixels from the input image
    model = model * valid
    return valid, model, tuple(bounds)  # type: ignore
 
 

prox_sdss_symmetry()

lsst.scarlet.lite.operators.prox_sdss_symmetry

(

np.ndarray

x

)

SDSS/HSC symmetry operator

This function uses the *minimum* of the two
symmetric pixels in the update.

Parameters
----------
x:
    The array to make symmetric.

Returns
-------
result:
    The updated `x`.

Definition at line 423 of file operators.py.

def prox_sdss_symmetry(x: np.ndarray):
    """SDSS/HSC symmetry operator
 
    This function uses the *minimum* of the two
    symmetric pixels in the update.
 
    Parameters
    ----------
    x:
        The array to make symmetric.
 
    Returns
    -------
    result:
        The updated `x`.
    """
    symmetric = np.fliplr(np.flipud(x))
    x[:] = np.min([x, symmetric], axis=0)
    return x
 
 

prox_uncentered_symmetry()

np.ndarray lsst.scarlet.lite.operators.prox_uncentered_symmetry	(	np.ndarray	x,
		tuple[int, int] | None	center = None,
		float | None	fill = None )

Symmetry with off-center peak

Symmetrize X for all pixels with a symmetric partner.

Parameters
----------
x:
    The parameter to update.
center:
    The center pixel coordinates to apply the symmetry operator.
fill:
    The value to fill the region that cannot be made symmetric.
    When `fill` is `None` then the region of `X` that is not symmetric
    is not constrained.

Returns
-------
result:
    The update function based on the specified parameters.

Definition at line 444 of file operators.py.

) -> np.ndarray:
    """Symmetry with off-center peak
 
    Symmetrize X for all pixels with a symmetric partner.
 
    Parameters
    ----------
    x:
        The parameter to update.
    center:
        The center pixel coordinates to apply the symmetry operator.
    fill:
        The value to fill the region that cannot be made symmetric.
        When `fill` is `None` then the region of `X` that is not symmetric
        is not constrained.
 
    Returns
    -------
    result:
        The update function based on the specified parameters.
    """
    return uncentered_operator(x, prox_sdss_symmetry, center, fill=fill)

uncentered_operator()

np.ndarray lsst.scarlet.lite.operators.uncentered_operator	(	np.ndarray	x,
		Callable	func,
		tuple[int, int] | None	center = None,
		float | None	fill = None,
		**	kwargs )

Only apply the operator on a centered patch

In some cases, for example symmetry, an operator might not make
sense outside of a centered box. This operator only updates
the portion of `X` inside the centered region.

Parameters
----------
x:
    The parameter to update.
func:
    The function (or operator) to apply to `x`.
center:
    The location of the center of the sub-region to
    apply `func` to `x`.
fill:
    The value to fill the region outside of centered
    `sub-region`, for example `0`. If `fill` is `None`
    then only the subregion is updated and the rest of
    `x` remains unchanged.

Returns
-------
result:
    `x`, with an operator applied based on the shifted center.

Definition at line 356 of file operators.py.

) -> np.ndarray:
    """Only apply the operator on a centered patch
 
    In some cases, for example symmetry, an operator might not make
    sense outside of a centered box. This operator only updates
    the portion of `X` inside the centered region.
 
    Parameters
    ----------
    x:
        The parameter to update.
    func:
        The function (or operator) to apply to `x`.
    center:
        The location of the center of the sub-region to
        apply `func` to `x`.
    fill:
        The value to fill the region outside of centered
        `sub-region`, for example `0`. If `fill` is `None`
        then only the subregion is updated and the rest of
        `x` remains unchanged.
 
    Returns
    -------
    result:
        `x`, with an operator applied based on the shifted center.
    """
    if center is None:
        py, px = cast(tuple[int, int], np.unravel_index(np.argmax(x), x.shape))
    else:
        py, px = center
    cy, cx = np.array(x.shape) // 2
 
    if py == cy and px == cx:
        return func(x, **kwargs)
 
    dy = int(2 * (py - cy))
    dx = int(2 * (px - cx))
    if not x.shape[0] % 2:
        dy += 1
    if not x.shape[1] % 2:
        dx += 1
    if dx < 0:
        xslice = slice(None, dx)
    else:
        xslice = slice(dx, None)
    if dy < 0:
        yslice = slice(None, dy)
    else:
        yslice = slice(dy, None)
 
    if fill is not None:
        _x = np.ones(x.shape, x.dtype) * fill
        _x[yslice, xslice] = func(x[yslice, xslice], **kwargs)
        x[:] = _x
    else:
        x[yslice, xslice] = func(x[yslice, xslice], **kwargs)
 
    return x