LSST Applications g042eb84c57+730a74494b,g04e9c324dd+8c5ae1fdc5,g134cb467dc+1f1e3e7524,g199a45376c+0ba108daf9,g1fd858c14a+fa7d31856b,g210f2d0738+f66ac109ec,g262e1987ae+83a3acc0e5,g29ae962dfc+d856a2cb1f,g2cef7863aa+aef1011c0b,g35bb328faa+8c5ae1fdc5,g3fd5ace14f+a1e0c9f713,g47891489e3+0d594cb711,g4d44eb3520+c57ec8f3ed,g4d7b6aa1c5+f66ac109ec,g53246c7159+8c5ae1fdc5,g56a1a4eaf3+fd7ad03fde,g64539dfbff+f66ac109ec,g67b6fd64d1+0d594cb711,g67fd3c3899+f66ac109ec,g6985122a63+0d594cb711,g74acd417e5+3098891321,g786e29fd12+668abc6043,g81db2e9a8d+98e2ab9f28,g87389fa792+8856018cbb,g89139ef638+0d594cb711,g8d7436a09f+80fda9ce03,g8ea07a8fe4+760ca7c3fc,g90f42f885a+033b1d468d,g97be763408+a8a29bda4b,g99822b682c+e3ec3c61f9,g9d5c6a246b+0d5dac0c3d,ga41d0fce20+9243b26dd2,gbf99507273+8c5ae1fdc5,gd7ef33dd92+0d594cb711,gdab6d2f7ff+3098891321,ge410e46f29+0d594cb711,geaed405ab2+c4bbc419c6,gf9a733ac38+8c5ae1fdc5,w.2025.38
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