lsst.scarlet.lite.detect Namespace Reference

Classes
class	Footprint

Functions
Box	bounds_to_bbox (tuple[int, int, int, int] bounds)
Image	footprints_to_image (Sequence[Footprint] footprints, tuple[int, int] shape)
np.ndarray	get_wavelets (np.ndarray images, np.ndarray variance, int|None scales=None)
np.ndarray	get_detect_wavelets (np.ndarray images, np.ndarray variance, int scales=3)

Variables
	logger = logging.getLogger("scarlet.detect")

Function Documentation

bounds_to_bbox()

Box lsst.scarlet.lite.detect.bounds_to_bbox

(

tuple[int, int, int, int]

bounds

)

Convert the bounds of a Footprint into a Box

Notes
-----
Unlike slices, the bounds are _inclusive_ of the end points.

Parameters
----------
bounds:
    The bounds of the `Footprint` as a `tuple` of
    ``(bottom, top, left, right)``.
Returns
-------
result:
    The `Box` created from the bounds

Definition at line 38 of file detect.py.

def bounds_to_bbox(bounds: tuple[int, int, int, int]) -> Box:
    """Convert the bounds of a Footprint into a Box
 
    Notes
    -----
    Unlike slices, the bounds are _inclusive_ of the end points.
 
    Parameters
    ----------
    bounds:
        The bounds of the `Footprint` as a `tuple` of
        ``(bottom, top, left, right)``.
    Returns
    -------
    result:
        The `Box` created from the bounds
    """
    return Box(
        (bounds[1] + 1 - bounds[0], bounds[3] + 1 - bounds[2]),
        origin=(bounds[0], bounds[2]),
    )
 
 
@continue_class

footprints_to_image()

Image lsst.scarlet.lite.detect.footprints_to_image	(	Sequence[Footprint]	footprints,
		tuple[int, int]	shape )

Convert a set of scarlet footprints to a pixelized image.

Parameters
----------
footprints:
    The footprints to convert into an image.
shape:
    The shape of the image that is created from the footprints.

Returns
-------
result:
    The image created from the footprints.

Definition at line 114 of file detect.py.

def footprints_to_image(footprints: Sequence[Footprint], shape: tuple[int, int]) -> Image:
    """Convert a set of scarlet footprints to a pixelized image.
 
    Parameters
    ----------
    footprints:
        The footprints to convert into an image.
    shape:
        The shape of the image that is created from the footprints.
 
    Returns
    -------
    result:
        The image created from the footprints.
    """
    result = Image.from_box(Box(shape), dtype=int)
    for k, footprint in enumerate(footprints):
        bbox = bounds_to_bbox(footprint.bounds)
        fp_image = Image(footprint.data, yx0=cast(tuple[int, int], bbox.origin))
        result = result + fp_image * (k + 1)
    return result
 
 

get_detect_wavelets()

np.ndarray lsst.scarlet.lite.detect.get_detect_wavelets	(	np.ndarray	images,
		np.ndarray	variance,
		int	scales = 3 )

Get an array of wavelet coefficents to use for detection

Parameters
----------
images:
    The array of images with shape `(bands, Ny, Nx)` for which to
    calculate wavelet coefficients.
variance:
    An array of variances with the same shape as `images`.
scales:
    The maximum number of wavelet scales to use.
    Note that the result will have `scales+1` total arrays,
    where the last set of coefficients is the image of all
    flux with frequency greater than the last wavelet scale.

Returns
-------
starlets:
    The array of wavelet coefficients for pixels with siignificant
    amplitude in each scale.

Definition at line 175 of file detect.py.

def get_detect_wavelets(images: np.ndarray, variance: np.ndarray, scales: int = 3) -> np.ndarray:
    """Get an array of wavelet coefficents to use for detection
 
    Parameters
    ----------
    images:
        The array of images with shape `(bands, Ny, Nx)` for which to
        calculate wavelet coefficients.
    variance:
        An array of variances with the same shape as `images`.
    scales:
        The maximum number of wavelet scales to use.
        Note that the result will have `scales+1` total arrays,
        where the last set of coefficients is the image of all
        flux with frequency greater than the last wavelet scale.
 
    Returns
    -------
    starlets:
        The array of wavelet coefficients for pixels with siignificant
        amplitude in each scale.
    """
    sigma = np.median(np.sqrt(variance))
    # Create the wavelet coefficients for the significant pixels
    detect = np.sum(images, axis=0)
    _coeffs = starlet_transform(detect, scales=scales)
    support = get_multiresolution_support(
        image=detect,
        starlets=_coeffs,
        sigma=sigma,  # type: ignore
        sigma_scaling=3,
        epsilon=1e-1,
        max_iter=20,
    )
    return (support * _coeffs).astype(images.dtype)

get_wavelets()

np.ndarray lsst.scarlet.lite.detect.get_wavelets	(	np.ndarray	images,
		np.ndarray	variance,
		int | None	scales = None )

Calculate wavelet coefficents given a set of images and their variances

Parameters
----------
images:
    The array of images with shape `(bands, Ny, Nx)` for which to
    calculate wavelet coefficients.
variance:
    An array of variances with the same shape as `images`.
scales:
    The maximum number of wavelet scales to use.

Returns
-------
coeffs:
    The array of coefficents with shape `(scales+1, bands, Ny, Nx)`.
    Note that the result has `scales+1` total arrays,
    since the last set of coefficients is the image of all
    flux with frequency greater than the last wavelet scale.

Definition at line 137 of file detect.py.

def get_wavelets(images: np.ndarray, variance: np.ndarray, scales: int | None = None) -> np.ndarray:
    """Calculate wavelet coefficents given a set of images and their variances
 
    Parameters
    ----------
    images:
        The array of images with shape `(bands, Ny, Nx)` for which to
        calculate wavelet coefficients.
    variance:
        An array of variances with the same shape as `images`.
    scales:
        The maximum number of wavelet scales to use.
 
    Returns
    -------
    coeffs:
        The array of coefficents with shape `(scales+1, bands, Ny, Nx)`.
        Note that the result has `scales+1` total arrays,
        since the last set of coefficients is the image of all
        flux with frequency greater than the last wavelet scale.
    """
    sigma = np.median(np.sqrt(variance), axis=(1, 2))
    # Create the wavelet coefficients for the significant pixels
    coeffs = []
    for b, image in enumerate(images):
        _coeffs = starlet_transform(image, scales=scales)
        support = get_multiresolution_support(
            image=image,
            starlets=_coeffs,
            sigma=sigma[b],
            sigma_scaling=3,
            epsilon=1e-1,
            max_iter=20,
        )
        coeffs.append((support * _coeffs).astype(images.dtype))
    return np.array(coeffs)
 
 

Variable Documentation

logger

lsst.scarlet.lite.detect.logger = logging.getLogger("scarlet.detect")

Definition at line 35 of file detect.py.