Inheritance diagram for lsst.scarlet.lite.observation.Observation:

Public Member Functions
	__init__ (self, np.ndarray\|Image images, np.ndarray\|Image variance, np.ndarray\|Image weights, np.ndarray psfs, np.ndarray\|None model_psf=None, np.ndarray\|None noise_rms=None, Box\|None bbox=None, tuple\|None bands=None, int padding=3, str convolution_mode="fft")

tuple	bands (self)

Box	bbox (self)

Image	convolve (self, Image image, str\|None mode=None, bool grad=False)

float	log_likelihood (self, Image model)

tuple[int, int, int]	shape (self)

int	n_bands (self)

npt.DTypeLike	dtype (self)

tuple[int, int, int, int]	convolution_bounds (self)

Static Public Member Functions
Observation	empty (tuple[Any] bands, np.ndarray psfs, np.ndarray model_psf, Box bbox, npt.DTypeLike dtype)

Public Attributes
	images = images

	variance = _set_image_like(variance, bands, bbox)

	weights = _set_image_like(weights, bands, bbox)

	psfs = psfs

	mode = convolution_mode

	noise_rms = noise_rms

	model_psf = model_psf

	padding = padding

Fourier\|None	diff_kernel = cast(Fourier, match_kernel(psfs, model_psf, padding=padding))

Fourier\|None	grad_kernel = Fourier(diff_img[:, ::-1, ::-1])

Protected Attributes
tuple[int, int, int, int]\|None	_convolution_bounds = None

Detailed Description

A single observation

This class contains all of the observed images and derived
properties, like PSFs, variance map, and weight maps,
required for most optimizers.
This includes methods to match a scarlet model PSF to the oberved PSF
in each band.

Notes
-----
This is effectively a combination of the `Observation` and
`Renderer` class from scarlet main, greatly simplified due
to the assumptions that the observations are all resampled
onto the same pixel grid and that the `images` contain all
of the information for all of the model bands.

Parameters
----------
images:
    (bands, y, x) array of observed images.
variance:
    (bands, y, x) array of variance for each image pixel.
weights:
    (bands, y, x) array of weights to use when calculate the
    likelihood of each pixel.
psfs:
    (bands, y, x) array of the PSF image in each band.
model_psf:
    (bands, y, x) array of the model PSF image in each band.
    If `model_psf` is `None` then convolution is performed,
    which should only be done when the observation is a
    PSF matched coadd, and the scarlet model has the same PSF.
noise_rms:
    Per-band average noise RMS. If `noise_rms` is `None` then the mean
    of the sqrt of the variance is used.
bbox:
    The bounding box containing the model. If `bbox` is `None` then
    a `Box` is created that is the shape of `images` with an origin
    at `(0, 0)`.
padding:
    Padding to use when performing an FFT convolution.
convolution_mode:
    The method of convolution. This should be either "fft" or "real".

Definition at line 166 of file observation.py.

Constructor & Destructor Documentation

◆ init()

lsst.scarlet.lite.observation.Observation.__init__	(		self,
		np.ndarray \| Image	images,
		np.ndarray \| Image	variance,
		np.ndarray \| Image	weights,
		np.ndarray	psfs,
		np.ndarray \| None	model_psf = None,
		np.ndarray \| None	noise_rms = None,
		Box \| None	bbox = None,
		tuple \| None	bands = None,
		int	padding = 3,
		str	convolution_mode = "fft" )

Definition at line 212 of file observation.py.

    ):
        # Convert the images to a multi-band `Image` and use the resulting
        # bbox and bands.
        images = _set_image_like(images, bands, bbox)
        bands = images.bands
        bbox = images.bbox
        self.images = images
        self.variance = _set_image_like(variance, bands, bbox)
        self.weights = _set_image_like(weights, bands, bbox)
        # make sure that the images and psfs have the same dtype
        if psfs.dtype != images.dtype:
            psfs = psfs.astype(images.dtype)
        self.psfs = psfs
 
        if convolution_mode not in [
            "fft",
            "real",
        ]:
            raise ValueError("convolution_mode must be either 'fft' or 'real'")
        self.mode = convolution_mode
        if noise_rms is None:
            noise_rms = np.array(np.mean(np.sqrt(variance.data), axis=(1, 2)))
        self.noise_rms = noise_rms
 
        # Create a difference kernel to convolve the model to the PSF
        # in each band
        self.model_psf = model_psf
        self.padding = padding
        if model_psf is not None:
            if model_psf.dtype != images.dtype:
                self.model_psf = model_psf.astype(images.dtype)
            self.diff_kernel: Fourier | None = cast(Fourier, match_kernel(psfs, model_psf, padding=padding))
            # The gradient of a convolution is another convolution,
            # but with the flipped and transposed kernel.
            diff_img = self.diff_kernel.image
            self.grad_kernel: Fourier | None = Fourier(diff_img[:, ::-1, ::-1])
        else:
            self.diff_kernel = None
            self.grad_kernel = None
 
        self._convolution_bounds: tuple[int, int, int, int] | None = None
 

Member Function Documentation

◆ bands()

tuple lsst.scarlet.lite.observation.Observation.bands ( self )

The bands in the observations.

Definition at line 267 of file observation.py.

    def bands(self) -> tuple:
        """The bands in the observations."""
        return self.images.bands
 

◆ bbox()

Box lsst.scarlet.lite.observation.Observation.bbox ( self )

The bounding box for the full observation.

Definition at line 272 of file observation.py.

    def bbox(self) -> Box:
        """The bounding box for the full observation."""
        return self.images.bbox
 

◆ convolution_bounds()

tuple[int, int, int, int] lsst.scarlet.lite.observation.Observation.convolution_bounds ( self )

Build the slices needed for convolution in real space

Definition at line 367 of file observation.py.

    def convolution_bounds(self) -> tuple[int, int, int, int]:
        """Build the slices needed for convolution in real space"""
        if self._convolution_bounds is None:
            coords = get_filter_coords(cast(Fourier, self.diff_kernel).image[0])
            self._convolution_bounds = get_filter_bounds(coords.reshape(-1, 2))
        return self._convolution_bounds
 

◆ convolve()

Image lsst.scarlet.lite.observation.Observation.convolve	(		self,
		Image	image,
		str \| None	mode = None,
		bool	grad = False )

Convolve the model into the observed seeing in each band.

Parameters
----------
image:
    The 3D image to convolve.
mode:
    The convolution mode to use.
    This should be "real" or "fft" or `None`,
    where `None` will use the default `convolution_mode`
    specified during init.
grad:
    Whether this is a backward gradient convolution
    (`grad==True`) or a pure convolution with the PSF.

Returns
-------
result:
    The convolved image.

Reimplemented in lsst.scarlet.lite.models.fit_psf.FittedPsfObservation.

Definition at line 276 of file observation.py.

    def convolve(self, image: Image, mode: str | None = None, grad: bool = False) -> Image:
        """Convolve the model into the observed seeing in each band.
 
        Parameters
        ----------
        image:
            The 3D image to convolve.
        mode:
            The convolution mode to use.
            This should be "real" or "fft" or `None`,
            where `None` will use the default `convolution_mode`
            specified during init.
        grad:
            Whether this is a backward gradient convolution
            (`grad==True`) or a pure convolution with the PSF.
 
        Returns
        -------
        result:
            The convolved image.
        """
        if grad:
            kernel = self.grad_kernel
        else:
            kernel = self.diff_kernel
 
        if kernel is None:
            return image
 
        if mode is None:
            mode = self.mode
        if mode == "fft":
            result = fft_convolve(
                Fourier(image.data),
                kernel,
                axes=(1, 2),
                return_fourier=False,
            )
        elif mode == "real":
            dy = image.shape[1] - kernel.image.shape[1]
            dx = image.shape[2] - kernel.image.shape[2]
            if dy < 0 or dx < 0:
                # The image needs to be padded because it is smaller than
                # the psf kernel
                _image = image.data
                newshape = list(_image.shape)
                if dy < 0:
                    newshape[1] += kernel.image.shape[1] - image.shape[1]
                if dx < 0:
                    newshape[2] += kernel.image.shape[2] - image.shape[2]
                _image = _pad(_image, newshape)
                result = convolve(_image, kernel.image, self.convolution_bounds)
                result = centered(result, image.data.shape)  # type: ignore
            else:
                result = convolve(image.data, kernel.image, self.convolution_bounds)
        else:
            raise ValueError(f"mode must be either 'fft' or 'real', got {mode}")
        return Image(cast(np.ndarray, result), bands=image.bands, yx0=image.yx0)
 

◆ dtype()

npt.DTypeLike lsst.scarlet.lite.observation.Observation.dtype ( self )

The dtype of the observation is the dtype of the images

Definition at line 362 of file observation.py.

    def dtype(self) -> npt.DTypeLike:
        """The dtype of the observation is the dtype of the images"""
        return self.images.dtype
 

◆ empty()

Observation lsst.scarlet.lite.observation.Observation.empty	(	tuple[Any]	bands,
		np.ndarray	psfs,
		np.ndarray	model_psf,
		Box	bbox,
		npt.DTypeLike	dtype )

static

Definition at line 375 of file observation.py.

    ) -> Observation:
        dummy_image = np.zeros((len(bands),) + bbox.shape, dtype=dtype)
 
        return Observation(
            images=dummy_image,
            variance=dummy_image,
            weights=dummy_image,
            psfs=psfs,
            model_psf=model_psf,
            noise_rms=np.zeros((len(bands),), dtype=dtype),
            bbox=bbox,
            bands=bands,
            convolution_mode="real",
        )

◆ log_likelihood()

float lsst.scarlet.lite.observation.Observation.log_likelihood	(		self,
		Image	model )

Calculate the log likelihood of the given model

Parameters
----------
model:
    Model to compare with the observed images.

Returns
-------
result:
    The log-likelihood of the given model.

Definition at line 335 of file observation.py.

    def log_likelihood(self, model: Image) -> float:
        """Calculate the log likelihood of the given model
 
        Parameters
        ----------
        model:
            Model to compare with the observed images.
 
        Returns
        -------
        result:
            The log-likelihood of the given model.
        """
        result = 0.5 * -np.sum((self.weights * (self.images - model) ** 2).data)
        return result
 

◆ n_bands()

int lsst.scarlet.lite.observation.Observation.n_bands ( self )

The number of bands in the observation

Definition at line 357 of file observation.py.

    def n_bands(self) -> int:
        """The number of bands in the observation"""
        return self.images.shape[0]
 

◆ shape()

tuple[int, int, int] lsst.scarlet.lite.observation.Observation.shape ( self )

The shape of the images, variance, etc.

Definition at line 352 of file observation.py.

    def shape(self) -> tuple[int, int, int]:
        """The shape of the images, variance, etc."""
        return cast(tuple[int, int, int], self.images.shape)
 

Member Data Documentation

◆ _convolution_bounds

tuple[int, int, int, int] | None lsst.scarlet.lite.observation.Observation._convolution_bounds = None

protected

Definition at line 264 of file observation.py.

◆ diff_kernel

Fourier | None lsst.scarlet.lite.observation.Observation.diff_kernel = cast(Fourier, match_kernel(psfs, model_psf, padding=padding))

Definition at line 255 of file observation.py.

◆ grad_kernel

Fourier | None lsst.scarlet.lite.observation.Observation.grad_kernel = Fourier(diff_img[:, ::-1, ::-1])

Definition at line 259 of file observation.py.

◆ images

lsst.scarlet.lite.observation.Observation.images = images

Definition at line 230 of file observation.py.

◆ mode

lsst.scarlet.lite.observation.Observation.mode = convolution_mode

Definition at line 243 of file observation.py.

◆ model_psf

lsst.scarlet.lite.observation.Observation.model_psf = model_psf

Definition at line 250 of file observation.py.

◆ noise_rms

lsst.scarlet.lite.observation.Observation.noise_rms = noise_rms

Definition at line 246 of file observation.py.

◆ padding

lsst.scarlet.lite.observation.Observation.padding = padding

Definition at line 251 of file observation.py.

◆ psfs

lsst.scarlet.lite.observation.Observation.psfs = psfs

Definition at line 236 of file observation.py.

◆ variance

lsst.scarlet.lite.observation.Observation.variance = _set_image_like(variance, bands, bbox)

Definition at line 231 of file observation.py.

◆ weights

lsst.scarlet.lite.observation.Observation.weights = _set_image_like(weights, bands, bbox)

Definition at line 232 of file observation.py.

The documentation for this class was generated from the following file:

/j/snowflake/release/lsstsw/stack/lsst-scipipe-10.0.0/Linux64/scarlet_lite/gd9a9a58781+fcb1d3bbc8/python/lsst/scarlet/lite/observation.py

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Attributes