Functions
np.ndarray	integrated_gaussian_value (np.ndarray x, float sigma)

np.ndarray	integrated_circular_gaussian (np.ndarray\|None x=None, np.ndarray\|None y=None, float sigma=0.8)

	get_circle_mask (int diameter, npt.DTypeLike dtype=np.float64)

	is_attribute_safe_to_transfer (name, value)

	continue_class (cls)

Variables
	ScalarLike = bool \| int \| float \| complex

tuple	ScalarTypes = (bool, int, float, complex)

	sqrt2 = np.sqrt(2)

	sqrt_pi = np.sqrt(np.pi)

	INTRINSIC_SPECIAL_ATTRIBUTES

Function Documentation

◆ continue_class()

lsst.scarlet.lite.utils.continue_class ( cls )

Re-open the decorated class, adding any new definitions into the
original.
For example:
.. code-block:: python
    class Foo:
        pass
    @continueClass
    class Foo:
        def run(self):
            return None
is equivalent to:
.. code-block:: python
    class Foo:
        def run(self):
            return None
.. warning::
    Python's built-in `super` function does not behave properly in classes
    decorated with `continue_class`.  Base class methods must be invoked
    directly using their explicit types instead.

This is copied directly from lsst.utils. If any additional functions are
used from that repo we should remove this function and make lsst.utils
a dependency. But for now, it is easier to copy this single wrapper
than to include lsst.utils and all of its dependencies.

Definition at line 161 of file utils.py.

def continue_class(cls):
    """Re-open the decorated class, adding any new definitions into the
    original.
    For example:
    .. code-block:: python
        class Foo:
            pass
        @continueClass
        class Foo:
            def run(self):
                return None
    is equivalent to:
    .. code-block:: python
        class Foo:
            def run(self):
                return None
    .. warning::
        Python's built-in `super` function does not behave properly in classes
        decorated with `continue_class`.  Base class methods must be invoked
        directly using their explicit types instead.
 
    This is copied directly from lsst.utils. If any additional functions are
    used from that repo we should remove this function and make lsst.utils
    a dependency. But for now, it is easier to copy this single wrapper
    than to include lsst.utils and all of its dependencies.
    """
    orig = getattr(sys.modules[cls.__module__], cls.__name__)
    for name in dir(cls):
        # Common descriptors like classmethod and staticmethod can only be
        # accessed without invoking their magic if we use __dict__; if we use
        # getattr on those we'll get e.g. a bound method instance on the dummy
        # class rather than a classmethod instance we can put on the target
        # class.
        attr = cls.__dict__.get(name, None) or getattr(cls, name)
        if is_attribute_safe_to_transfer(name, attr):
            setattr(orig, name, attr)
    return orig

◆ get_circle_mask()

lsst.scarlet.lite.utils.get_circle_mask	(	int	diameter,
		npt.DTypeLike	dtype = np.float64 )

Get a boolean image of a circle

Parameters
----------
diameter:
    The diameter of the circle and width
    of the image.
dtype:
    The `dtype` of the image.

Returns
-------
circle:
    A boolean array with ones for the pixels with centers
    inside of the circle and zeros
    outside of the circle.

Definition at line 97 of file utils.py.

def get_circle_mask(diameter: int, dtype: npt.DTypeLike = np.float64):
    """Get a boolean image of a circle
 
    Parameters
    ----------
    diameter:
        The diameter of the circle and width
        of the image.
    dtype:
        The `dtype` of the image.
 
    Returns
    -------
    circle:
        A boolean array with ones for the pixels with centers
        inside of the circle and zeros
        outside of the circle.
    """
    c = (diameter - 1) / 2
    # The center of the circle and its radius are
    # off by half a pixel for circles with
    # even numbered diameter
    if diameter % 2 == 0:
        radius = diameter / 2
    else:
        radius = c
    x = np.arange(diameter)
    x, y = np.meshgrid(x, x)
    r = np.sqrt((x - c) ** 2 + (y - c) ** 2)
 
    circle = np.ones((diameter, diameter), dtype=dtype)
    circle[r > radius] = 0
    return circle
 
 

◆ integrated_circular_gaussian()

np.ndarray lsst.scarlet.lite.utils.integrated_circular_gaussian	(	np.ndarray \| None	x = None,
		np.ndarray \| None	y = None,
		float	sigma = 0.8 )

Create a circular Gaussian that is integrated over pixels

This is typically used for the model PSF,
working well with the default parameters.

Parameters
----------
x, y:
    The x,y-coordinates to evaluate the integrated Gaussian.
    If `X` and `Y` are `None` then they will both be given the
    default value `numpy.arange(-7, 8)`, resulting in a
    `15x15` centered image.
sigma:
    The standard deviation of the Gaussian.

Returns
-------
image:
    A Gaussian function integrated over `X` and `Y`.

Definition at line 57 of file utils.py.

) -> np.ndarray:
    """Create a circular Gaussian that is integrated over pixels
 
    This is typically used for the model PSF,
    working well with the default parameters.
 
    Parameters
    ----------
    x, y:
        The x,y-coordinates to evaluate the integrated Gaussian.
        If `X` and `Y` are `None` then they will both be given the
        default value `numpy.arange(-7, 8)`, resulting in a
        `15x15` centered image.
    sigma:
        The standard deviation of the Gaussian.
 
    Returns
    -------
    image:
        A Gaussian function integrated over `X` and `Y`.
    """
    if x is None:
        if y is None:
            x = np.arange(-7, 8)
            y = x
        else:
            raise ValueError(
                f"Either X and Y must be specified, or neither must be specified, got {x=} and {y=}"
            )
    elif y is None:
        raise ValueError(f"Either X and Y must be specified, or neither must be specified, got {x=} and {y=}")
 
    _x = integrated_gaussian_value(np.abs(x), sigma)[None, :]
    _y = integrated_gaussian_value(np.abs(y), sigma)[:, None]
    result = _x * _y
    return result / np.sum(result)
 
 

◆ integrated_gaussian_value()

np.ndarray lsst.scarlet.lite.utils.integrated_gaussian_value	(	np.ndarray	x,
		float	sigma )

A Gaussian function evaluated at `x`

Parameters
----------
x:
    The coordinates to evaluate the integrated Gaussian
    (ie. the centers of pixels).
sigma:
    The standard deviation of the Gaussian.

Returns
-------
gaussian:
    A Gaussian function integrated over `x`

Definition at line 36 of file utils.py.

def integrated_gaussian_value(x: np.ndarray, sigma: float) -> np.ndarray:
    """A Gaussian function evaluated at `x`
 
    Parameters
    ----------
    x:
        The coordinates to evaluate the integrated Gaussian
        (ie. the centers of pixels).
    sigma:
        The standard deviation of the Gaussian.
 
    Returns
    -------
    gaussian:
        A Gaussian function integrated over `x`
    """
    lhs = erfc((x - 0.5) / (sqrt2 * sigma))
    rhs = erfc((x + 0.5) / (sqrt2 * sigma))
    return sqrt_pi * 0.5 * sigma * (lhs - rhs)
 
 

◆ is_attribute_safe_to_transfer()

lsst.scarlet.lite.utils.is_attribute_safe_to_transfer	(		name,
			value )

Return True if an attribute is safe to monkeypatch-transfer to another
class.
This rejects special methods that are defined automatically for all
classes, leaving only those explicitly defined in a class decorated by
`continueClass` or registered with an instance of `TemplateMeta`.

Definition at line 147 of file utils.py.

def is_attribute_safe_to_transfer(name, value):
    """Return True if an attribute is safe to monkeypatch-transfer to another
    class.
    This rejects special methods that are defined automatically for all
    classes, leaving only those explicitly defined in a class decorated by
    `continueClass` or registered with an instance of `TemplateMeta`.
    """
    if name.startswith("__") and (
        value is getattr(object, name, None) or name in INTRINSIC_SPECIAL_ATTRIBUTES
    ):
        return False
    return True
 
 

Variable Documentation

◆ INTRINSIC_SPECIAL_ATTRIBUTES

lsst.scarlet.lite.utils.INTRINSIC_SPECIAL_ATTRIBUTES

Initial value:

=  frozenset(
    (
        "__qualname__",
        "__module__",
        "__metaclass__",
        "__dict__",
        "__weakref__",
        "__class__",
        "__subclasshook__",
        "__name__",
        "__doc__",
    )
)

Definition at line 132 of file utils.py.

◆ ScalarLike

lsst.scarlet.lite.utils.ScalarLike = bool | int | float | complex

Definition at line 28 of file utils.py.

◆ ScalarTypes

tuple lsst.scarlet.lite.utils.ScalarTypes = (bool, int, float, complex)

Definition at line 29 of file utils.py.

◆ sqrt2

lsst.scarlet.lite.utils.sqrt2 = np.sqrt(2)

Definition at line 32 of file utils.py.

◆ sqrt_pi

lsst.scarlet.lite.utils.sqrt_pi = np.sqrt(np.pi)

Definition at line 33 of file utils.py.

Functions

Variables