LSST Applications g04e9c324dd+8c5ae1fdc5,g134cb467dc+b203dec576,g18429d2f64+358861cd2c,g199a45376c+0ba108daf9,g1fd858c14a+dd066899e3,g262e1987ae+ebfced1d55,g29ae962dfc+72fd90588e,g2cef7863aa+aef1011c0b,g35bb328faa+8c5ae1fdc5,g3fd5ace14f+b668f15bc5,g4595892280+3897dae354,g47891489e3+abcf9c3559,g4d44eb3520+fb4ddce128,g53246c7159+8c5ae1fdc5,g67b6fd64d1+abcf9c3559,g67fd3c3899+1f72b5a9f7,g74acd417e5+cb6b47f07b,g786e29fd12+668abc6043,g87389fa792+8856018cbb,g89139ef638+abcf9c3559,g8d7436a09f+bcf525d20c,g8ea07a8fe4+9f5ccc88ac,g90f42f885a+6054cc57f1,g97be763408+06f794da49,g9dd6db0277+1f72b5a9f7,ga681d05dcb+7e36ad54cd,gabf8522325+735880ea63,gac2eed3f23+abcf9c3559,gb89ab40317+abcf9c3559,gbf99507273+8c5ae1fdc5,gd8ff7fe66e+1f72b5a9f7,gdab6d2f7ff+cb6b47f07b,gdc713202bf+1f72b5a9f7,gdfd2d52018+8225f2b331,ge365c994fd+375fc21c71,ge410e46f29+abcf9c3559,geaed405ab2+562b3308c0,gf9a733ac38+8c5ae1fdc5,w.2025.35
LSST Data Management Base Package
Loading...
Searching...
No Matches
lsst.scarlet.lite.observation Namespace Reference

Classes

class  Observation
 

Functions

np.ndarray get_filter_coords (np.ndarray filter_values, tuple[int, int]|None center=None)
 
tuple[int, int, int, int] get_filter_bounds (np.ndarray coords)
 
 convolve (np.ndarray image, np.ndarray psf, tuple[int, int, int, int] bounds)
 
Image _set_image_like (np.ndarray|Image images, tuple|None bands=None, Box|None bbox=None)
 

Function Documentation

◆ _set_image_like()

Image lsst.scarlet.lite.observation._set_image_like ( np.ndarray | Image images,
tuple | None bands = None,
Box | None bbox = None )
protected
Ensure that an image-like array is cast appropriately as an image

Parameters
----------
images:
    The multiband image-like array to cast as an Image.
    If it already has `bands` and `bbox` properties then it is returned
    with no modifications.
bands:
    The bands for the multiband-image.
    If `images` is a numpy array, this parameter is mandatory.
    If `images` is an `Image` and `bands` is not `None`,
    then `bands` is ignored.
bbox:
    Bounding box containing the image.
    If `images` is a numpy array, this parameter is mandatory.
    If `images` is an `Image` and `bbox` is not `None`,
    then `bbox` is ignored.

Returns
-------
images: Image
    The input images converted into an image.

Definition at line 130 of file observation.py.

130def _set_image_like(images: np.ndarray | Image, bands: tuple | None = None, bbox: Box | None = None) -> Image:
131 """Ensure that an image-like array is cast appropriately as an image
132
133 Parameters
134 ----------
135 images:
136 The multiband image-like array to cast as an Image.
137 If it already has `bands` and `bbox` properties then it is returned
138 with no modifications.
139 bands:
140 The bands for the multiband-image.
141 If `images` is a numpy array, this parameter is mandatory.
142 If `images` is an `Image` and `bands` is not `None`,
143 then `bands` is ignored.
144 bbox:
145 Bounding box containing the image.
146 If `images` is a numpy array, this parameter is mandatory.
147 If `images` is an `Image` and `bbox` is not `None`,
148 then `bbox` is ignored.
149
150 Returns
151 -------
152 images: Image
153 The input images converted into an image.
154 """
155 if isinstance(images, Image):
156 # This is already an image
157 if bbox is not None and images.bbox != bbox:
158 raise ValueError(f"Bounding boxes {images.bbox} and {bbox} do not agree")
159 return images
160
161 if bbox is None:
162 bbox = Box(images.shape[-2:])
163 return Image(images, bands=bands, yx0=cast(tuple[int, int], bbox.origin))
164
165

◆ convolve()

lsst.scarlet.lite.observation.convolve ( np.ndarray image,
np.ndarray psf,
tuple[int, int, int, int] bounds )
Convolve an image with a PSF in real space

Parameters
----------
image:
    The multi-band image to convolve.
psf:
    The psf to convolve the image with.
bounds:
    The filter bounds required by the ``apply_filter`` C++ method,
    usually obtained by calling `get_filter_bounds`.

Definition at line 99 of file observation.py.

99def convolve(image: np.ndarray, psf: np.ndarray, bounds: tuple[int, int, int, int]):
100 """Convolve an image with a PSF in real space
101
102 Parameters
103 ----------
104 image:
105 The multi-band image to convolve.
106 psf:
107 The psf to convolve the image with.
108 bounds:
109 The filter bounds required by the ``apply_filter`` C++ method,
110 usually obtained by calling `get_filter_bounds`.
111 """
112 from lsst.scarlet.lite.operators_pybind11 import apply_filter # type: ignore
113
114 result = np.empty(image.shape, dtype=image.dtype)
115 for band in range(len(image)):
116 img = image[band]
117
119 img,
120 psf[band].reshape(-1),
121 bounds[0],
122 bounds[1],
123 bounds[2],
124 bounds[3],
125 result[band],
126 )
127 return result
128
129
void apply_filter(Eigen::Ref< const M > image, Eigen::Ref< const V > values, Eigen::Ref< const IndexVector > y_start, Eigen::Ref< const IndexVector > y_end, Eigen::Ref< const IndexVector > x_start, Eigen::Ref< const IndexVector > x_end, Eigen::Ref< M, 0, Eigen::Stride< Eigen::Dynamic, Eigen::Dynamic > > result)

◆ get_filter_bounds()

tuple[int, int, int, int] lsst.scarlet.lite.observation.get_filter_bounds ( np.ndarray coords)
Get the slices in x and y to apply a filter

Parameters
----------
coords:
    The coordinates of the filter,
    defined by `get_filter_coords`.

Returns
-------
y_start, y_end, x_start, x_end:
    The start and end of each slice that is passed to `apply_filter`.

Definition at line 75 of file observation.py.

75def get_filter_bounds(coords: np.ndarray) -> tuple[int, int, int, int]:
76 """Get the slices in x and y to apply a filter
77
78 Parameters
79 ----------
80 coords:
81 The coordinates of the filter,
82 defined by `get_filter_coords`.
83
84 Returns
85 -------
86 y_start, y_end, x_start, x_end:
87 The start and end of each slice that is passed to `apply_filter`.
88 """
89 z = np.zeros((len(coords),), dtype=int)
90 # Set the y slices
91 y_start = np.max([z, coords[:, 0]], axis=0)
92 y_end = -np.min([z, coords[:, 0]], axis=0)
93 # Set the x slices
94 x_start = np.max([z, coords[:, 1]], axis=0)
95 x_end = -np.min([z, coords[:, 1]], axis=0)
96 return y_start, y_end, x_start, x_end
97
98

◆ get_filter_coords()

np.ndarray lsst.scarlet.lite.observation.get_filter_coords ( np.ndarray filter_values,
tuple[int, int] | None center = None )
Create filter coordinate grid needed for the apply filter function

Parameters
----------
filter_values:
    The 2D array of the filter to apply.
center:
    The center (y,x) of the filter. If `center` is `None` then
    `filter_values` must have an odd number of rows and columns
    and the center will be set to the center of `filter_values`.

Returns
-------
coords:
    The coordinates of the pixels in `filter_values`,
    where the coordinates of the `center` pixel are `(0,0)`.

Definition at line 38 of file observation.py.

38def get_filter_coords(filter_values: np.ndarray, center: tuple[int, int] | None = None) -> np.ndarray:
39 """Create filter coordinate grid needed for the apply filter function
40
41 Parameters
42 ----------
43 filter_values:
44 The 2D array of the filter to apply.
45 center:
46 The center (y,x) of the filter. If `center` is `None` then
47 `filter_values` must have an odd number of rows and columns
48 and the center will be set to the center of `filter_values`.
49
50 Returns
51 -------
52 coords:
53 The coordinates of the pixels in `filter_values`,
54 where the coordinates of the `center` pixel are `(0,0)`.
55 """
56 if filter_values.ndim != 2:
57 raise ValueError("`filter_values` must be 2D")
58 if center is None:
59 if filter_values.shape[0] % 2 == 0 or filter_values.shape[1] % 2 == 0:
60 msg = """Ambiguous center of the `filter_values` array,
61 you must use a `filter_values` array
62 with an odd number of rows and columns or
63 calculate `coords` on your own."""
64 raise ValueError(msg)
65 center = tuple([filter_values.shape[0] // 2, filter_values.shape[1] // 2]) # type: ignore
66 x = np.arange(filter_values.shape[1])
67 y = np.arange(filter_values.shape[0])
68 x, y = np.meshgrid(x, y)
69 x -= center[1]
70 y -= center[0]
71 coords = np.dstack([y, x])
72 return coords
73
74