LSST Applications g063fba187b+eddd1b24d7,g0f08755f38+4a855ab515,g1653933729+a8ce1bb630,g168dd56ebc+a8ce1bb630,g1a2382251a+062a45aee3,g1dcb35cd9c+45d3fa5522,g20f6ffc8e0+4a855ab515,g217e2c1bcf+f55e51b560,g28da252d5a+7d8e536cc7,g2bbee38e9b+2d92fc7d83,g2bc492864f+2d92fc7d83,g3156d2b45e+6e55a43351,g32e5bea42b+625186cc6b,g347aa1857d+2d92fc7d83,g35bb328faa+a8ce1bb630,g3a166c0a6a+2d92fc7d83,g3e281a1b8c+c5dd892a6c,g3e8969e208+a8ce1bb630,g414038480c+5927e1bc1e,g41af890bb2+1af189bab1,g7af13505b9+7b6a50a2f8,g80478fca09+6174b7f182,g82479be7b0+5b71efbaf0,g858d7b2824+4a855ab515,g9125e01d80+a8ce1bb630,ga5288a1d22+61618a97c4,gb58c049af0+d64f4d3760,gc28159a63d+2d92fc7d83,gc5452a3dca+f4add4ffd5,gcab2d0539d+d9f5af7f69,gcf0d15dbbd+6c7e0a19ec,gda6a2b7d83+6c7e0a19ec,gdaeeff99f8+1711a396fd,ge79ae78c31+2d92fc7d83,gef2f8181fd+55fff6f525,gf0baf85859+c1f95f4921,gfa517265be+4a855ab515,gfa999e8aa5+17cd334064,w.2024.51
LSST Data Management Base Package
Loading...
Searching...
No Matches
Classes | Functions | Variables
lsst.scarlet.lite.detect Namespace Reference

Classes

class  Footprint
 

Functions

Box bounds_to_bbox (tuple[int, int, int, int] bounds)
 
Image footprints_to_image (Sequence[Footprint] footprints, Box bbox)
 
np.ndarray get_wavelets (np.ndarray images, np.ndarray variance, int|None scales=None, int generation=2)
 
np.ndarray get_detect_wavelets (np.ndarray images, np.ndarray variance, int scales=3)
 
list[Footprint] detect_footprints (np.ndarray images, np.ndarray variance, int scales=2, int generation=2, tuple[int, int]|None origin=None, float min_separation=4, int min_area=4, float peak_thresh=5, float footprint_thresh=5, bool find_peaks=True, bool remove_high_freq=True, int min_pixel_detect=1)
 

Variables

 logger = logging.getLogger("scarlet.detect")
 

Function Documentation

◆ bounds_to_bbox()

Box lsst.scarlet.lite.detect.bounds_to_bbox ( tuple[int, int, int, int] bounds) 
Convert the bounds of a Footprint into a Box

Notes
-----
Unlike slices, the bounds are _inclusive_ of the end points.

Parameters
----------
bounds:
    The bounds of the `Footprint` as a `tuple` of
    ``(bottom, top, left, right)``.
Returns
-------
result:
    The `Box` created from the bounds

Definition at line 43 of file detect.py.

43def bounds_to_bbox(bounds: tuple[int, int, int, int]) -> Box:
44 """Convert the bounds of a Footprint into a Box
45
46 Notes
47 -----
48 Unlike slices, the bounds are _inclusive_ of the end points.
49
50 Parameters
51 ----------
52 bounds:
53 The bounds of the `Footprint` as a `tuple` of
54 ``(bottom, top, left, right)``.
55 Returns
56 -------
57 result:
58 The `Box` created from the bounds
59 """
60 return Box(
61 (bounds[1] + 1 - bounds[0], bounds[3] + 1 - bounds[2]),
62 origin=(bounds[0], bounds[2]),
63 )
64
65
66@continue_class

◆ detect_footprints()

list[Footprint] lsst.scarlet.lite.detect.detect_footprints ( np.ndarray images,
np.ndarray variance,
int scales = 2,
int generation = 2,
tuple[int, int] | None origin = None,
float min_separation = 4,
int min_area = 4,
float peak_thresh = 5,
float footprint_thresh = 5,
bool find_peaks = True,
bool remove_high_freq = True,
int min_pixel_detect = 1 ) 
Detect footprints in an image

Parameters
----------
images:
    The array of images with shape `(bands, Ny, Nx)` for which to
    calculate wavelet coefficients.
variance:
    An array of variances with the same shape as `images`.
scales:
    The maximum number of wavelet scales to use.
    If `remove_high_freq` is `False`, then this argument is ignored.
generation:
    The generation of the starlet transform to use.
    If `remove_high_freq` is `False`, then this argument is ignored.
origin:
    The location (y, x) of the lower corner of the image.
min_separation:
    The minimum separation between peaks in pixels.
min_area:
    The minimum area of a footprint in pixels.
peak_thresh:
    The threshold for peak detection.
footprint_thresh:
    The threshold for footprint detection.
find_peaks:
    If `True`, then detect peaks in the detection image,
    otherwise only the footprints are returned.
remove_high_freq:
    If `True`, then remove high frequency wavelet coefficients
    before detecting peaks.
min_pixel_detect:
    The minimum number of bands that must be above the
    detection threshold for a pixel to be included in a footprint.

Definition at line 222 of file detect.py.

235) -> list[Footprint]:
236 """Detect footprints in an image
237
238 Parameters
239 ----------
240 images:
241 The array of images with shape `(bands, Ny, Nx)` for which to
242 calculate wavelet coefficients.
243 variance:
244 An array of variances with the same shape as `images`.
245 scales:
246 The maximum number of wavelet scales to use.
247 If `remove_high_freq` is `False`, then this argument is ignored.
248 generation:
249 The generation of the starlet transform to use.
250 If `remove_high_freq` is `False`, then this argument is ignored.
251 origin:
252 The location (y, x) of the lower corner of the image.
253 min_separation:
254 The minimum separation between peaks in pixels.
255 min_area:
256 The minimum area of a footprint in pixels.
257 peak_thresh:
258 The threshold for peak detection.
259 footprint_thresh:
260 The threshold for footprint detection.
261 find_peaks:
262 If `True`, then detect peaks in the detection image,
263 otherwise only the footprints are returned.
264 remove_high_freq:
265 If `True`, then remove high frequency wavelet coefficients
266 before detecting peaks.
267 min_pixel_detect:
268 The minimum number of bands that must be above the
269 detection threshold for a pixel to be included in a footprint.
270 """
271
272 if origin is None:
273 origin = (0, 0)
274 if remove_high_freq:
275 # Build the wavelet coefficients
276 wavelets = get_wavelets(
277 images,
278 variance,
279 scales=scales,
280 generation=generation,
281 )
282 # Remove the high frequency wavelets.
283 # This has the effect of preventing high frequency noise
284 # from interfering with the detection of peak positions.
285 wavelets[0] = 0
286 # Reconstruct the image from the remaining wavelet coefficients
287 _images = multiband_starlet_reconstruction(
288 wavelets,
289 generation=generation,
290 )
291 else:
292 _images = images
293 # Build a SNR weighted detection image
294 sigma = np.median(np.sqrt(variance), axis=(1, 2)) / 2
295 detection = np.sum(_images / sigma[:, None, None], axis=0)
296 if min_pixel_detect > 1:
297 mask = np.sum(images > 0, axis=0) >= min_pixel_detect
298 detection[~mask] = 0
299 # Detect peaks on the detection image
300 footprints = get_footprints(
301 detection,
302 min_separation,
303 min_area,
304 peak_thresh,
305 footprint_thresh,
306 find_peaks,
307 origin[0],
308 origin[1],
309 )
310
311 return footprints

◆ footprints_to_image()

Image lsst.scarlet.lite.detect.footprints_to_image ( Sequence[Footprint] footprints,
Box bbox ) 
Convert a set of scarlet footprints to a pixelized image.

Parameters
----------
footprints:
    The footprints to convert into an image.
box:
    The full box of the image that will contain the footprints.

Returns
-------
result:
    The image created from the footprints.

Definition at line 119 of file detect.py.

119def footprints_to_image(footprints: Sequence[Footprint], bbox: Box) -> Image:
120 """Convert a set of scarlet footprints to a pixelized image.
121
122 Parameters
123 ----------
124 footprints:
125 The footprints to convert into an image.
126 box:
127 The full box of the image that will contain the footprints.
128
129 Returns
130 -------
131 result:
132 The image created from the footprints.
133 """
134 result = Image.from_box(bbox, dtype=int)
135 for k, footprint in enumerate(footprints):
136 slices = overlapped_slices(result.bbox, footprint.bbox)
137 result.data[slices[0]] += footprint.data[slices[1]] * (k + 1)
138 return result
139
140

◆ get_detect_wavelets()

np.ndarray lsst.scarlet.lite.detect.get_detect_wavelets ( np.ndarray images,
np.ndarray variance,
int scales = 3 ) 
Get an array of wavelet coefficents to use for detection

Parameters
----------
images:
    The array of images with shape `(bands, Ny, Nx)` for which to
    calculate wavelet coefficients.
variance:
    An array of variances with the same shape as `images`.
scales:
    The maximum number of wavelet scales to use.
    Note that the result will have `scales+1` total arrays,
    where the last set of coefficients is the image of all
    flux with frequency greater than the last wavelet scale.

Returns
-------
starlets:
    The array of wavelet coefficients for pixels with siignificant
    amplitude in each scale.

Definition at line 185 of file detect.py.

185def get_detect_wavelets(images: np.ndarray, variance: np.ndarray, scales: int = 3) -> np.ndarray:
186 """Get an array of wavelet coefficents to use for detection
187
188 Parameters
189 ----------
190 images:
191 The array of images with shape `(bands, Ny, Nx)` for which to
192 calculate wavelet coefficients.
193 variance:
194 An array of variances with the same shape as `images`.
195 scales:
196 The maximum number of wavelet scales to use.
197 Note that the result will have `scales+1` total arrays,
198 where the last set of coefficients is the image of all
199 flux with frequency greater than the last wavelet scale.
200
201 Returns
202 -------
203 starlets:
204 The array of wavelet coefficients for pixels with siignificant
205 amplitude in each scale.
206 """
207 sigma = np.median(np.sqrt(variance))
208 # Create the wavelet coefficients for the significant pixels
209 detect = np.sum(images, axis=0)
210 _coeffs = starlet_transform(detect, scales=scales)
211 support = get_multiresolution_support(
212 image=detect,
213 starlets=_coeffs,
214 sigma=sigma, # type: ignore
215 sigma_scaling=3,
216 epsilon=1e-1,
217 max_iter=20,
218 )
219 return (support.support * _coeffs).astype(images.dtype)
220
221

◆ get_wavelets()

np.ndarray lsst.scarlet.lite.detect.get_wavelets ( np.ndarray images,
np.ndarray variance,
int | None scales = None,
int generation = 2 ) 
Calculate wavelet coefficents given a set of images and their variances

Parameters
----------
images:
    The array of images with shape `(bands, Ny, Nx)` for which to
    calculate wavelet coefficients.
variance:
    An array of variances with the same shape as `images`.
scales:
    The maximum number of wavelet scales to use.

Returns
-------
coeffs:
    The array of coefficents with shape `(scales+1, bands, Ny, Nx)`.
    Note that the result has `scales+1` total arrays,
    since the last set of coefficients is the image of all
    flux with frequency greater than the last wavelet scale.

Definition at line 141 of file detect.py.

146) -> np.ndarray:
147 """Calculate wavelet coefficents given a set of images and their variances
148
149 Parameters
150 ----------
151 images:
152 The array of images with shape `(bands, Ny, Nx)` for which to
153 calculate wavelet coefficients.
154 variance:
155 An array of variances with the same shape as `images`.
156 scales:
157 The maximum number of wavelet scales to use.
158
159 Returns
160 -------
161 coeffs:
162 The array of coefficents with shape `(scales+1, bands, Ny, Nx)`.
163 Note that the result has `scales+1` total arrays,
164 since the last set of coefficients is the image of all
165 flux with frequency greater than the last wavelet scale.
166 """
167 sigma = np.median(np.sqrt(variance), axis=(1, 2))
168 # Create the wavelet coefficients for the significant pixels
169 scales = get_starlet_scales(images[0].shape, scales)
170 coeffs = np.empty((scales + 1,) + images.shape, dtype=images.dtype)
171 for b, image in enumerate(images):
172 _coeffs = starlet_transform(image, scales=scales, generation=generation)
173 support = get_multiresolution_support(
174 image=image,
175 starlets=_coeffs,
176 sigma=sigma[b],
177 sigma_scaling=3,
178 epsilon=1e-1,
179 max_iter=20,
180 )
181 coeffs[:, b] = (support.support * _coeffs).astype(images.dtype)
182 return coeffs
183
184

Variable Documentation

◆ logger

lsst.scarlet.lite.detect.logger = logging.getLogger("scarlet.detect")

Definition at line 40 of file detect.py.

Generated on Mon Dec 30 2024 08:03:19 for LSST Applications by doxygen 1.10.0