lsst.scarlet.lite.operators.Monotonicity Class Reference

Public Member Functions
	__init__ (self, tuple[int, int] shape, npt.DTypeLike dtype=float, bool auto_update=True, int fit_radius=1)
tuple[int, int]	shape (self)
tuple[int, int]	center (self)
	update (self, tuple[int, int] shape)
	check_size (self, tuple[int, int] shape, tuple[int, int] center, bool update=True)
np.ndarray	__call__ (self, np.ndarray image, tuple[int, int] center)

Public Attributes
	dtype
	auto_update
	fit_radius
	weights
	distance
	sizes

Detailed Description

Class to implement Monotonicity

Callable class that applies monotonicity as a pseudo proximal
operator (actually a projection operator) to *a* radially
monotonic solution.

Notes
-----
This differs from monotonicity in the main scarlet branch because
this stores a single monotonicity operator to set the weights for all
of the pixels up to the size of the largest shape expected,
and only needs to be created once _per blend_, as opposed to
once _per source_..
This class is then called with the source morphology
to make monotonic and the location of the "center" of the image,
and the full weight matrix is sliced accordingly.

Parameters
----------
shape:
    The shape of the full operator.
    This must be larger than the largest possible object size
    in the blend.
dtype:
    The numpy ``dtype`` of the output image.
auto_update:
    If ``True`` the operator will update its shape if a image is
    too big to fit in the current operator.
fit_radius:
    Pixels within `fit_radius` of the center of the array to make
    monotonic are checked to see if they have more flux than the center
    pixel. If they do, the pixel with larger flux is used as the center.

Definition at line 42 of file operators.py.

Constructor & Destructor Documentation

__init__()

lsst.scarlet.lite.operators.Monotonicity.__init__	(		self,
		tuple[int, int]	shape,
		npt.DTypeLike	dtype = float,
		bool	auto_update = True,
		int	fit_radius = 1 )

Definition at line 77 of file operators.py.

    ):
        # Initialize defined variables
        self.weights: np.ndarray | None = None
        self.distance: np.ndarray | None = None
        self.sizes: tuple[int, int, int, int] | None = None
        self.dtype = dtype
        self.auto_update = auto_update
        self.fit_radius = fit_radius
        self.update(shape)
 

Member Function Documentation

__call__()

np.ndarray lsst.scarlet.lite.operators.Monotonicity.__call__	(		self,
		np.ndarray	image,
		tuple[int, int]	center )

Make an input image monotonic about a center pixel

Parameters
----------
image:
    The image to make monotonic.
center:
    The ``(y, x)`` location _in image coordinates_ to make the
    center of the monotonic region.

Returns
-------
result:
    The input image is updated in place, but also returned from this
    method.

Definition at line 214 of file operators.py.

    def __call__(self, image: np.ndarray, center: tuple[int, int]) -> np.ndarray:
        """Make an input image monotonic about a center pixel
 
        Parameters
        ----------
        image:
            The image to make monotonic.
        center:
            The ``(y, x)`` location _in image coordinates_ to make the
            center of the monotonic region.
 
        Returns
        -------
        result:
            The input image is updated in place, but also returned from this
            method.
        """
        # Check for a better center
        center = get_peak(image, center, self.fit_radius)
 
        # Check that the operator can fit the image
        self.check_size(cast(tuple[int, int], image.shape), center, self.auto_update)
 
        # Create the bounding box to slice the weights and distance as needed
        cy, cx = self.center
        py, px = center
        bbox = Box((9,) + image.shape, origin=(0, cy - py, cx - px))
        weights = cast(np.ndarray, self.weights)[bbox.slices]
        indices = np.argsort(cast(np.ndarray, self.distance)[bbox.slices[1:]].flatten())
        coords = np.unravel_index(indices, image.shape)
 
        # Pad the image by 1 so that we don't have to worry about
        # weights on the edges.
        result_shape = (image.shape[0] + 2, image.shape[1] + 2)
        result = np.zeros(result_shape, dtype=image.dtype)
        result[1:-1, 1:-1] = image
        new_monotonicity(coords[0], coords[1], [w for w in weights], result)
        image[:] = result[1:-1, 1:-1]
        return image
 
 

center()

tuple[int, int] lsst.scarlet.lite.operators.Monotonicity.center

(

self

)

The center of the full operator

Returns
-------
result:
    The center of the full operator.

Definition at line 105 of file operators.py.

    def center(self) -> tuple[int, int]:
        """The center of the full operator
 
        Returns
        -------
        result:
            The center of the full operator.
        """
        shape = self.shape
        cx = (shape[1] - 1) // 2
        cy = (shape[0] - 1) // 2
        return cy, cx
 

check_size()

lsst.scarlet.lite.operators.Monotonicity.check_size	(		self,
		tuple[int, int]	shape,
		tuple[int, int]	center,
		bool	update = True )

Check to see if the operator can be applied

Parameters
----------
shape:
    The shape of the image to apply monotonicity.
center:
    The location (in `shape`) of the point where the monotonicity will
    be taken from.
update:
    When ``True`` the operator will update itself so that an image
    with shape `shape` can be made monotonic about the `center`.

Raises
------
ValueError:
    Raised when an array with shape `shape` does not fit in the
    current operator and `update` is `False`.

Definition at line 186 of file operators.py.

    def check_size(self, shape: tuple[int, int], center: tuple[int, int], update: bool = True):
        """Check to see if the operator can be applied
 
        Parameters
        ----------
        shape:
            The shape of the image to apply monotonicity.
        center:
            The location (in `shape`) of the point where the monotonicity will
            be taken from.
        update:
            When ``True`` the operator will update itself so that an image
            with shape `shape` can be made monotonic about the `center`.
 
        Raises
        ------
        ValueError:
            Raised when an array with shape `shape` does not fit in the
            current operator and `update` is `False`.
        """
        sizes = np.array(tuple(center) + (shape[0] - center[0], shape[1] - center[1]))
        if np.any(sizes > self.sizes):
            if update:
                size = 2 * np.max(sizes) + 1
                self.update((size, size))
            else:
                raise ValueError(f"Cannot apply monotonicity to image with shape {shape} at {center}")
 

shape()

tuple[int, int] lsst.scarlet.lite.operators.Monotonicity.shape

(

self

)

The 2D shape of the largest component that can be made monotonic

Returns
-------
result:
    The shape of the oeprator.

Definition at line 94 of file operators.py.

    def shape(self) -> tuple[int, int]:
        """The 2D shape of the largest component that can be made monotonic
 
        Returns
        -------
        result:
            The shape of the oeprator.
        """
        return cast(tuple[int, int], cast(np.ndarray, self.weights).shape[1:])
 

update()

lsst.scarlet.lite.operators.Monotonicity.update	(		self,
		tuple[int, int]	shape )

Update the operator with a new shape

Parameters
----------
shape:
    The new shape

Definition at line 118 of file operators.py.

    def update(self, shape: tuple[int, int]):
        """Update the operator with a new shape
 
        Parameters
        ----------
        shape:
            The new shape
        """
        if len(shape) != 2:
            msg = f"Monotonicity is a 2D operator but received shape with {len(shape)} dimensions"
            raise ValueError(msg)
        if shape[0] % 2 == 0 or shape[1] % 2 == 0:
            raise ValueError(f"The shape must be odd, got {shape}")
        # Use the center of the operator as the center
        # and calculate the distance to each pixel from the center
        cx = (shape[1] - 1) // 2
        cy = (shape[0] - 1) // 2
        x = np.arange(shape[1], dtype=self.dtype) - cx
        y = np.arange(shape[0], dtype=self.dtype) - cy
        x, y = np.meshgrid(x, y)
        distance = np.sqrt(x**2 + y**2)
 
        # Calculate the distance from each pixel to its 8 nearest neighbors
        neighbor_dist = np.zeros((9,) + distance.shape, dtype=self.dtype)
        neighbor_dist[0, 1:, 1:] = distance[1:, 1:] - distance[:-1, :-1]
        neighbor_dist[1, 1:, :] = distance[1:, :] - distance[:-1, :]
        neighbor_dist[2, 1:, :-1] = distance[1:, :-1] - distance[:-1, 1:]
        neighbor_dist[3, :, 1:] = distance[:, 1:] - distance[:, :-1]
 
        # For the center pixel, set the distance to 1 just so that it is
        # non-zero
        neighbor_dist[4, cy, cx] = 1
        neighbor_dist[5, :, :-1] = distance[:, :-1] - distance[:, 1:]
        neighbor_dist[6, :-1, 1:] = distance[:-1, 1:] - distance[1:, :-1]
        neighbor_dist[7, :-1, :] = distance[:-1, :] - distance[1:, :]
        neighbor_dist[8, :-1, :-1] = distance[:-1, :-1] - distance[1:, 1:]
 
        # Calculate the difference in angle to the center
        # from each pixel to its 8 nearest neighbors
        angles = np.arctan2(y, x)
        angle_diff = np.zeros((9,) + angles.shape, dtype=self.dtype)
        angle_diff[0, 1:, 1:] = angles[1:, 1:] - angles[:-1, :-1]
        angle_diff[1, 1:, :] = angles[1:, :] - angles[:-1, :]
        angle_diff[2, 1:, :-1] = angles[1:, :-1] - angles[:-1, 1:]
        angle_diff[3, :, 1:] = angles[:, 1:] - angles[:, :-1]
        # For the center pixel, on the center will have a non-zero cosine,
        # which is used as the weight.
        angle_diff[4] = 1
        angle_diff[4, cy, cx] = 0
        angle_diff[5, :, :-1] = angles[:, :-1] - angles[:, 1:]
        angle_diff[6, :-1, 1:] = angles[:-1, 1:] - angles[1:, :-1]
        angle_diff[7, :-1, :] = angles[:-1, :] - angles[1:, :]
        angle_diff[8, :-1, :-1] = angles[:-1, :-1] - angles[1:, 1:]
 
        # Use cos(theta) to set the weights, then normalize
        # This gives more weight to neighboring pixels that are more closely
        # aligned with the vector pointing toward the center.
        weights = np.cos(angle_diff)
        weights[neighbor_dist <= 0] = 0
        # Adjust for the discontinuity at theta = 2pi
        weights[weights < 0] = -weights[weights < 0]
        weights = weights / np.sum(weights, axis=0)[None, :, :]
 
        # Store the parameters needed later
        self.weights = weights
        self.distance = distance
        self.sizes = (cy, cx, shape[0] - cy, shape[1] - cx)
 

Member Data Documentation

auto_update

lsst.scarlet.lite.operators.Monotonicity.auto_update

Definition at line 89 of file operators.py.

distance

lsst.scarlet.lite.operators.Monotonicity.distance

Definition at line 183 of file operators.py.

dtype

lsst.scarlet.lite.operators.Monotonicity.dtype

Definition at line 88 of file operators.py.

fit_radius

lsst.scarlet.lite.operators.Monotonicity.fit_radius

Definition at line 90 of file operators.py.

sizes

lsst.scarlet.lite.operators.Monotonicity.sizes

Definition at line 184 of file operators.py.

weights

lsst.scarlet.lite.operators.Monotonicity.weights

Definition at line 102 of file operators.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/scarlet_lite/gae0086650b+585e252eca/python/lsst/scarlet/lite/operators.py