Public Member Functions
	__init__ (self, np.ndarray image, dict[Sequence[Sequence[int]], np.ndarray]\|None image_fft=None)

np.ndarray	image (self)

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

np.ndarray	fft (self, Sequence[int] fft_shape, int\|Sequence[int] axes)

int	__len__ (self)

Fourier	__getitem__ (self, int\|Sequence[int]\|slice index)

Static Public Member Functions
Fourier	from_fft (np.ndarray image_fft, Sequence[int] fft_shape, Sequence[int] image_shape, int\|Sequence[int]\|None axes=None, DTypeLike dtype=float)

Public Attributes
	image

Protected Attributes
	_fft

	_image

Detailed Description

An array that stores its Fourier Transform

The `Fourier` class is used for images that will make
use of their Fourier Transform multiple times.
In order to prevent numerical artifacts the same image
convolved with different images might require different
padding, so the FFT for each different shape is stored
in a dictionary.

Parameters
----------
image: np.ndarray
    The real space image.
image_fft: dict[Sequence[int], np.ndarray]
    A dictionary of {shape: fft_value} for which each different
    shape has a precalculated FFT.

Definition at line 220 of file fft.py.

Constructor & Destructor Documentation

◆ init()

lsst.scarlet.lite.fft.Fourier.__init__	(		self,
		np.ndarray	image,
		dict[Sequence[Sequence[int]], np.ndarray] \| None	image_fft = None )

Definition at line 239 of file fft.py.

    ):
        if image_fft is None:
            self._fft: dict[Sequence[Sequence[int]], np.ndarray] = {}
        else:
            self._fft = image_fft
        self._image = image
 

Member Function Documentation

◆ getitem()

Fourier lsst.scarlet.lite.fft.Fourier.__getitem__	(		self,
		int \| Sequence[int] \| slice	index )

Definition at line 347 of file fft.py.

    def __getitem__(self, index: int | Sequence[int] | slice) -> Fourier:
        # Make the index a tuple
        if isinstance(index, int):
            index = tuple([index])
 
        # Axes that are removed from the shape of the new object
        if isinstance(index, slice):
            removed = np.array([])
        else:
            removed = np.array([n for n, idx in enumerate(index) if idx is not None])
 
        # Create views into the fft transformed values, appropriately adjusting
        # the shapes for the new axes
 
        fft_kernels = {
            (
                tuple([s for idx, s in enumerate(key[0]) if key[0][idx] not in removed]),
                tuple([s for idx, s in enumerate(key[1]) if key[1][idx] not in removed]),
                tuple([s for idx, s in enumerate(key[2]) if key[2][idx] not in removed]),
            ): kernel[index]
            for key, kernel in self._fft.items()
        }
        # mpypy doesn't recognize that tuple[int, ...]
        # is a valid Sequence[int] for some reason
        return Fourier(self.image[index], fft_kernels)  # type: ignore
 
 

◆ len()

int lsst.scarlet.lite.fft.Fourier.__len__ ( self )

Length of the image

Definition at line 343 of file fft.py.

    def __len__(self) -> int:
        """Length of the image"""
        return len(self.image)
 

◆ fft()

np.ndarray lsst.scarlet.lite.fft.Fourier.fft	(		self,
		Sequence[int]	fft_shape,
		int \| Sequence[int]	axes )

The FFT of an image for a given `fft_shape` along desired `axes`

Parameters
----------
fft_shape:
    "Fast" shape of the image used to generate the FFT.
    This will be different than `image_fft.shape` if
    any of the dimensions are odd, since `np.fft.rfft`
    requires an even number of dimensions (for symmetry),
    so this tells `np.fft.irfft` how to go from
    complex k-space to real space.
axes:
    The dimension(s) of the array that will be transformed.

Definition at line 313 of file fft.py.

    def fft(self, fft_shape: Sequence[int], axes: int | Sequence[int]) -> np.ndarray:
        """The FFT of an image for a given `fft_shape` along desired `axes`
 
        Parameters
        ----------
        fft_shape:
            "Fast" shape of the image used to generate the FFT.
            This will be different than `image_fft.shape` if
            any of the dimensions are odd, since `np.fft.rfft`
            requires an even number of dimensions (for symmetry),
            so this tells `np.fft.irfft` how to go from
            complex k-space to real space.
        axes:
            The dimension(s) of the array that will be transformed.
        """
        if isinstance(axes, int):
            axes = (axes,)
        all_axes = range(len(self.image.shape))
        fft_key = (tuple(fft_shape), tuple(axes), tuple(all_axes))
 
        # If this is the first time calling `fft` for this shape,
        # generate the FFT.
        if fft_key not in self._fft:
            if len(fft_shape) != len(axes):
                msg = f"fft_shape self.axes must have the same number of dimensions, got {fft_shape}, {axes}"
                raise ValueError(msg)
            image = _pad(self.image, fft_shape, axes)
            self._fft[fft_key] = np.fft.rfftn(np.fft.ifftshift(image, axes), axes=axes)
        return self._fft[fft_key]
 

◆ from_fft()

Fourier lsst.scarlet.lite.fft.Fourier.from_fft	(	np.ndarray	image_fft,
		Sequence[int]	fft_shape,
		Sequence[int]	image_shape,
		int \| Sequence[int] \| None	axes = None,
		DTypeLike	dtype = float )

static

Generate a new Fourier object from an FFT dictionary

If the fft of an image has been generated but not its
real space image (for example when creating a convolution kernel),
this method can be called to create a new `Fourier` instance
from the k-space representation.

Parameters
----------
image_fft:
    The FFT of the image.
fft_shape:
    "Fast" shape of the image used to generate the FFT.
    This will be different than `image_fft.shape` if
    any of the dimensions are odd, since `np.fft.rfft`
    requires an even number of dimensions (for symmetry),
    so this tells `np.fft.irfft` how to go from
    complex k-space to real space.
image_shape:
    The shape of the image *before padding*.
    This will regenerate the image with the extra
    padding stripped.
axes:
    The dimension(s) of the array that will be transformed.

Returns
-------
result:
    A `Fourier` object generated from the FFT.

Definition at line 251 of file fft.py.

    ) -> Fourier:
        """Generate a new Fourier object from an FFT dictionary
 
        If the fft of an image has been generated but not its
        real space image (for example when creating a convolution kernel),
        this method can be called to create a new `Fourier` instance
        from the k-space representation.
 
        Parameters
        ----------
        image_fft:
            The FFT of the image.
        fft_shape:
            "Fast" shape of the image used to generate the FFT.
            This will be different than `image_fft.shape` if
            any of the dimensions are odd, since `np.fft.rfft`
            requires an even number of dimensions (for symmetry),
            so this tells `np.fft.irfft` how to go from
            complex k-space to real space.
        image_shape:
            The shape of the image *before padding*.
            This will regenerate the image with the extra
            padding stripped.
        axes:
            The dimension(s) of the array that will be transformed.
 
        Returns
        -------
        result:
            A `Fourier` object generated from the FFT.
        """
        if axes is None:
            axes = range(len(image_shape))
        if isinstance(axes, int):
            axes = [axes]
        all_axes = range(len(image_shape))
        image = np.fft.irfftn(image_fft, fft_shape, axes=axes).astype(dtype)
        # Shift the center of the image from the bottom left to the center
        image = np.fft.fftshift(image, axes=axes)
        # Trim the image to remove the padding added
        # to reduce fft artifacts
        image = centered(image, image_shape)
        key = (tuple(fft_shape), tuple(axes), tuple(all_axes))
 
        return Fourier(image, {key: image_fft})
 

◆ image()

np.ndarray lsst.scarlet.lite.fft.Fourier.image ( self )

The real space image

Definition at line 304 of file fft.py.

    def image(self) -> np.ndarray:
        """The real space image"""
        return self._image
 

◆ shape()

tuple[int, ...] lsst.scarlet.lite.fft.Fourier.shape ( self )

The shape of the real space image

Definition at line 309 of file fft.py.

    def shape(self) -> tuple[int, ...]:
        """The shape of the real space image"""
        return self._image.shape
 

Member Data Documentation

◆ _fft

lsst.scarlet.lite.fft.Fourier._fft

protected

Definition at line 247 of file fft.py.

◆ _image

lsst.scarlet.lite.fft.Fourier._image

protected

Definition at line 248 of file fft.py.

◆ image

lsst.scarlet.lite.fft.Fourier.image

Definition at line 345 of file fft.py.

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

/j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/scarlet_lite/g168dd56ebc+a8ce1bb630/python/lsst/scarlet/lite/fft.py

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Attributes