lsst.scarlet.lite.measure Namespace Reference

Functions
float	calculate_snr (Image images, Image variance, np.ndarray psfs, tuple[int, int] center)
None	conserve_flux (blend, bool mask_footprint=True, Image|None images=None)

Function Documentation

calculate_snr()

float lsst.scarlet.lite.measure.calculate_snr	(	Image	images,
		Image	variance,
		np.ndarray	psfs,
		tuple[int, int]	center )

Calculate the signal to noise for a point source

This is done by weighting the image with the PSF in each band
and dividing by the PSF weighted variance.

Parameters
----------
images:
    The 3D (bands, y, x) image containing the data.
variance:
    The variance of `images`.
psfs:
    The PSF in each band.
center:
    The center of the signal.

Returns
-------
snr:
    The signal to noise of the source.

Definition at line 30 of file measure.py.

) -> float:
    """Calculate the signal to noise for a point source
 
    This is done by weighting the image with the PSF in each band
    and dividing by the PSF weighted variance.
 
    Parameters
    ----------
    images:
        The 3D (bands, y, x) image containing the data.
    variance:
        The variance of `images`.
    psfs:
        The PSF in each band.
    center:
        The center of the signal.
 
    Returns
    -------
    snr:
        The signal to noise of the source.
    """
    py = psfs.shape[1] // 2
    px = psfs.shape[2] // 2
    bbox = Box(psfs[0].shape, origin=(-py + center[0], -px + center[1]))
    overlap = images.bbox & bbox
    noise = variance[overlap].data
    img = images[overlap].data
    _psfs = Image(psfs, bands=images.bands, yx0=cast(tuple[int, int], bbox.origin))[overlap].data
    numerator = img * _psfs
    denominator = (_psfs * noise) * _psfs
    return np.sum(numerator) / np.sqrt(np.sum(denominator))
 
 

conserve_flux()

None lsst.scarlet.lite.measure.conserve_flux	(		blend,
		bool	mask_footprint = True,
		Image | None	images = None )

Use the source models as templates to re-distribute flux
from the data

The source models are used as approximations to the data,
which redistribute the flux in the data according to the
ratio of the models for each source.
There is no return value for this function,
instead it adds (or modifies) a ``flux_weighted_image``
attribute to each the sources with the flux attributed to
that source.

Parameters
----------
blend:
    The blend that is being fit
mask_footprint:
    Whether or not to apply a mask for pixels with zero weight.

Definition at line 69 of file measure.py.

def conserve_flux(blend, mask_footprint: bool = True, images: Image | None = None) -> None:
    """Use the source models as templates to re-distribute flux
    from the data
 
    The source models are used as approximations to the data,
    which redistribute the flux in the data according to the
    ratio of the models for each source.
    There is no return value for this function,
    instead it adds (or modifies) a ``flux_weighted_image``
    attribute to each the sources with the flux attributed to
    that source.
 
    Parameters
    ----------
    blend:
        The blend that is being fit
    mask_footprint:
        Whether or not to apply a mask for pixels with zero weight.
    """
    observation = blend.observation
    py = observation.psfs.shape[-2] // 2
    px = observation.psfs.shape[-1] // 2
 
    if images is None:
        images = observation.images.copy()
        if mask_footprint:
            images.data[observation.weights.data == 0] = 0
        model = blend.get_model()
        bands = None
    else:
        bands = images.bands
        model = blend.get_model()[bands,]
    # Always convolve in real space to avoid FFT artifacts
    model = observation.convolve(model, mode="real")
    model.data[model.data < 0] = 0
 
    for src in blend.sources:
        if src.is_null:
            src.flux_weighted_image = Image.from_box(Box((0, 0)), bands=observation.bands)  # type: ignore
            continue
        src_model = src.get_model()
 
        # Grow the model to include the wings of the PSF
        src_box = src.bbox.grow((py, px))
        overlap = observation.bbox & src_box
        src_model = src_model.project(bbox=overlap)
        src_model = observation.convolve(src_model, mode="real")
        if bands is not None:
            src_model = src_model[bands,]
        src_model.data[src_model.data < 0] = 0
        numerator = src_model.data
        denominator = model[overlap].data
        cuts = denominator != 0
        ratio = np.zeros(numerator.shape, dtype=numerator.dtype)
        ratio[cuts] = numerator[cuts] / denominator[cuts]
        ratio[denominator == 0] = 0
        # sometimes numerical errors can cause a hot pixel to have a
        # slightly higher ratio than 1
        ratio[ratio > 1] = 1
        src.flux_weighted_image = src_model.copy_with(data=ratio) * images[overlap]