Inheritance diagram for lsst.scarlet.lite.initialization.FactorizedInitialization:
Public Member Functions | |
| __init__ (self, Observation observation, Image convolved, Sequence[tuple[int, int]] centers, float min_snr=50, Monotonicity|None monotonicity=None, bool use_sparse_init=True) | |
| float | get_snr (self, tuple[int, int] center) |
| FactorizedComponent | get_psf_component (self, tuple[int, int] center) |
| FactorizedComponent|None | get_single_component (self, tuple[int, int] center, np.ndarray detect, float thresh, int padding) |
| Source|None | init_source (self, tuple[int, int] center) |
Public Attributes | |
| observation | |
| convolved | |
| centers | |
| min_snr | |
| monotonicity | |
| use_sparse_init | |
| convolved_psf | |
| py | |
| px | |
| psf_spectrum | |
| sources | |
Detailed Description
Common variables and methods for both Factorized Component schemes
Parameters
----------
observation:
The observation containing the blend
centers:
The center of each source to initialize.
min_snr:
The minimum SNR required per component.
So a 2-component source requires at least `2*min_snr` while sources
with SNR < `min_snr` will be initialized with the PSF.
monotonicity:
When `monotonicity` is `None`,
the component is initialized with only the
monotonic pixels, otherwise the monotonicity operator is used to
project the morphology to a monotonic solution.
use_sparse_init:
Use a monotonic mask to prevent initial source models from growing
too large.
Definition at line 197 of file initialization.py.
Constructor & Destructor Documentation
◆ __init__()
| lsst.scarlet.lite.initialization.FactorizedInitialization.__init__ | ( | self, | |
| Observation | observation, | ||
| Image | convolved, | ||
| Sequence[tuple[int, int]] | centers, | ||
| float | min_snr = 50, | ||
| Monotonicity | None | monotonicity = None, | ||
| bool | use_sparse_init = True ) |
Reimplemented in lsst.scarlet.lite.initialization.FactorizedChi2Initialization, and lsst.scarlet.lite.initialization.FactorizedWaveletInitialization.
Definition at line 220 of file initialization.py.
228 ):
229 self.observation = observation
230 self.convolved = convolved
231 self.centers = centers
232 self.min_snr = min_snr
233 self.monotonicity = monotonicity
234 self.use_sparse_init = use_sparse_init
235
236 # Get the model PSF
237 # Convolve the PSF in order to set the spectrum
238 # of a point source correctly.
239 model_psf = Image(cast(np.ndarray, observation.model_psf)[0])
240 convolved = model_psf.repeat(observation.bands)
241 self.convolved_psf = observation.convolve(convolved, mode="real").data
242 # Get the "spectrum" of the PSF
243 self.py = model_psf.shape[0] // 2
244 self.px = model_psf.shape[1] // 2
245 self.psf_spectrum = self.convolved_psf[:, self.py, self.px]
246
247 # Initalize all of the sources
248 sources = []
249 for center in centers:
250 source = self.init_source((int(center[0]), int(center[1])))
251 sources.append(source)
252 self.sources = sources
253
Member Function Documentation
◆ get_psf_component()
| FactorizedComponent lsst.scarlet.lite.initialization.FactorizedInitialization.get_psf_component | ( | self, | |
| tuple[int, int] | center ) |
Create a factorized component with a PSF morphology
Parameters
----------
center:
The center of the component.
Returns
-------
component:
A `FactorizedComponent` with a PSF-like morphology.
Definition at line 277 of file initialization.py.
277 def get_psf_component(self, center: tuple[int, int]) -> FactorizedComponent:
278 """Create a factorized component with a PSF morphology
279
280 Parameters
281 ----------
282 center:
283 The center of the component.
284
285 Returns
286 -------
287 component:
288 A `FactorizedComponent` with a PSF-like morphology.
289 """
290 local_center = (
291 center[0] - self.observation.bbox.origin[0],
292 center[1] - self.observation.bbox.origin[1],
293 )
294 # There wasn't sufficient flux for an extended source,
295 # so create a PSF source.
296 spectrum_center = (slice(None), local_center[0], local_center[1])
297 spectrum = self.observation.images.data[spectrum_center] / self.psf_spectrum
298 spectrum[spectrum < 0] = 0
299
300 psf = cast(np.ndarray, self.observation.model_psf)[0].copy()
301 py = psf.shape[0] // 2
302 px = psf.shape[1] // 2
303 bbox = Box(psf.shape, origin=(-py + center[0], -px + center[1]))
304 bbox = self.observation.bbox & bbox
305 morph = Image(psf, yx0=cast(tuple[int, int], bbox.origin))[bbox].data
306 component = FactorizedComponent(
307 self.observation.bands,
308 spectrum,
309 morph,
310 bbox,
311 center,
312 self.observation.noise_rms,
313 monotonicity=self.monotonicity,
314 )
315 return component
316
◆ get_single_component()
| FactorizedComponent | None lsst.scarlet.lite.initialization.FactorizedInitialization.get_single_component | ( | self, | |
| tuple[int, int] | center, | ||
| np.ndarray | detect, | ||
| float | thresh, | ||
| int | padding ) |
Initialize parameters for a `FactorizedComponent`
Parameters
----------
center:
The location of the center of the source to detect in the
full image.
detect:
The image used for detection of the morphology.
thresh:
The lower cutoff threshold to use for the morphology.
padding:
The amount to pad the morphology to allow for extra flux
in the first few iterations before resizing.
Returns
-------
component:
A `FactorizedComponent` created from the detection image.
Definition at line 317 of file initialization.py.
323 ) -> FactorizedComponent | None:
324 """Initialize parameters for a `FactorizedComponent`
325
326 Parameters
327 ----------
328 center:
329 The location of the center of the source to detect in the
330 full image.
331 detect:
332 The image used for detection of the morphology.
333 thresh:
334 The lower cutoff threshold to use for the morphology.
335 padding:
336 The amount to pad the morphology to allow for extra flux
337 in the first few iterations before resizing.
338
339 Returns
340 -------
341 component:
342 A `FactorizedComponent` created from the detection image.
343
344 """
345 local_center = (
346 center[0] - self.observation.bbox.origin[0],
347 center[1] - self.observation.bbox.origin[1],
348 )
349
350 if self.use_sparse_init:
351 monotonicity = None
352 else:
353 monotonicity = self.monotonicity
354 bbox, morph = init_monotonic_morph(
355 detect,
356 center,
357 self.observation.bbox,
358 padding=padding,
359 normalize=False,
360 monotonicity=monotonicity,
361 thresh=thresh,
362 )
363
364 if morph is None:
365 return None
366 morph = morph[(bbox - self.observation.bbox.origin).slices]
367
368 spectrum_center = (slice(None), local_center[0], local_center[1])
369 images = self.observation.images
370
371 convolved = self.convolved
372 spectrum = images.data[spectrum_center] / convolved.data[spectrum_center]
373 spectrum[spectrum < 0] = 0
374 morph_max = np.max(morph)
375 spectrum *= morph_max
376 morph /= morph_max
377
378 return FactorizedComponent(
379 self.observation.bands,
380 spectrum,
381 morph,
382 bbox,
383 center,
384 self.observation.noise_rms,
385 monotonicity=self.monotonicity,
386 )
387
◆ get_snr()
| float lsst.scarlet.lite.initialization.FactorizedInitialization.get_snr | ( | self, | |
| tuple[int, int] | center ) |
Get the SNR at the center of a component
Parameters
----------
center:
The location of the center of the source.
Returns
-------
result:
The SNR at the center of the component.
Definition at line 254 of file initialization.py.
254 def get_snr(self, center: tuple[int, int]) -> float:
255 """Get the SNR at the center of a component
256
257 Parameters
258 ----------
259 center:
260 The location of the center of the source.
261
262 Returns
263 -------
264 result:
265 The SNR at the center of the component.
266 """
267 snr = np.floor(
268 calculate_snr(
269 self.observation.images,
270 self.observation.variance,
271 self.observation.psfs,
272 center,
273 )
274 )
275 return snr / self.min_snr
276
◆ init_source()
| Source | None lsst.scarlet.lite.initialization.FactorizedInitialization.init_source | ( | self, | |
| tuple[int, int] | center ) |
Initialize a source
Parameters
----------
center:
The center of the source.
Reimplemented in lsst.scarlet.lite.initialization.FactorizedChi2Initialization, and lsst.scarlet.lite.initialization.FactorizedWaveletInitialization.
Definition at line 389 of file initialization.py.
389 def init_source(self, center: tuple[int, int]) -> Source | None:
390 """Initialize a source
391
392 Parameters
393 ----------
394 center:
395 The center of the source.
396 """
397
398
Member Data Documentation
◆ centers
| lsst.scarlet.lite.initialization.FactorizedInitialization.centers |
Definition at line 231 of file initialization.py.
◆ convolved
| lsst.scarlet.lite.initialization.FactorizedInitialization.convolved |
Definition at line 230 of file initialization.py.
◆ convolved_psf
| lsst.scarlet.lite.initialization.FactorizedInitialization.convolved_psf |
Definition at line 241 of file initialization.py.
◆ min_snr
| lsst.scarlet.lite.initialization.FactorizedInitialization.min_snr |
Definition at line 232 of file initialization.py.
◆ monotonicity
| lsst.scarlet.lite.initialization.FactorizedInitialization.monotonicity |
Definition at line 233 of file initialization.py.
◆ observation
| lsst.scarlet.lite.initialization.FactorizedInitialization.observation |
Definition at line 229 of file initialization.py.
◆ psf_spectrum
| lsst.scarlet.lite.initialization.FactorizedInitialization.psf_spectrum |
Definition at line 245 of file initialization.py.
◆ px
| lsst.scarlet.lite.initialization.FactorizedInitialization.px |
Definition at line 244 of file initialization.py.
◆ py
| lsst.scarlet.lite.initialization.FactorizedInitialization.py |
Definition at line 243 of file initialization.py.
◆ sources
| lsst.scarlet.lite.initialization.FactorizedInitialization.sources |
Definition at line 252 of file initialization.py.
◆ use_sparse_init
| lsst.scarlet.lite.initialization.FactorizedInitialization.use_sparse_init |
Definition at line 234 of file initialization.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/initialization.py
