lsst.scarlet.lite.io.ScarletBlendData Class Reference

Public Member Functions
dict	as_dict (self)
ScarletBlendData	from_dict (cls, dict data, DTypeLike dtype=np.float32)
Blend	minimal_data_to_blend (self, np.ndarray model_psf, DTypeLike dtype)
Blend	to_blend (self, Observation observation)

Static Public Member Functions
ScarletBlendData	from_blend (Blend blend, tuple[int, int] psf_center)

Public Attributes
	origin
	shape
	psf_center
	bands

Static Public Attributes
tuple	origin [int, int]
tuple	shape [int, int]
dict	sources [int, ScarletSourceData]
tuple	psf_center [float, float]
np	psf .ndarray
tuple	bands [str]

Detailed Description

Data for an entire blend.

Attributes
----------
origin:
    The lower bound of the blend's bounding box.
shape:
    The shape of the blend's bounding box.
sources:
    Data for the sources contained in the blend,
    indexed by the source id.
psf_center:
    The location used for the center of the PSF for
    the blend.
psf:
    The PSF of the observation.
bands : `list` of `str`
    The names of the bands.
    The order of the bands must be the same as the order of
    the multiband model arrays, and SEDs.

Definition at line 228 of file io.py.

Member Function Documentation

as_dict()

dict lsst.scarlet.lite.io.ScarletBlendData.as_dict

(

self

)

Return the object encoded into a dict for JSON serialization

Returns
-------
result:
    The object encoded as a JSON compatible dict

Definition at line 258 of file io.py.

    def as_dict(self) -> dict:
        """Return the object encoded into a dict for JSON serialization
 
        Returns
        -------
        result:
            The object encoded as a JSON compatible dict
        """
        result = {
            "origin": self.origin,
            "shape": self.shape,
            "psf_center": self.psf_center,
            "psf_shape": self.psf.shape,
            "psf": tuple(self.psf.flatten().astype(float)),
            "sources": {bid: source.as_dict() for bid, source in self.sources.items()},
            "bands": self.bands,
        }
        return result
 

from_blend()

ScarletBlendData lsst.scarlet.lite.io.ScarletBlendData.from_blend ( Blend blend, tuple[int, int] psf_center )

static

Convert a scarlet lite blend into a persistable data object

Parameters
----------
blend:
    The blend that is being persisted.
psf_center:
    The center of the PSF.

Returns
-------
blend_data:
    The data model for a single blend.

Definition at line 392 of file io.py.

    def from_blend(blend: Blend, psf_center: tuple[int, int]) -> ScarletBlendData:
        """Convert a scarlet lite blend into a persistable data object
 
        Parameters
        ----------
        blend:
            The blend that is being persisted.
        psf_center:
            The center of the PSF.
 
        Returns
        -------
        blend_data:
            The data model for a single blend.
        """
        sources = {}
        for source in blend.sources:
            components = []
            factorized = []
            for component in source.components:
                if type(component) is FactorizedComponent:
                    factorized_data = ScarletFactorizedComponentData(
                        origin=component.bbox.origin,  # type: ignore
                        peak=component.peak,  # type: ignore
                        spectrum=component.spectrum,
                        morph=component.morph,
                    )
                    factorized.append(factorized_data)
                else:
                    component_data = ScarletComponentData(
                        origin=component.bbox.origin,  # type: ignore
                        peak=component.peak,  # type: ignore
                        model=component.get_model().data,
                    )
                    components.append(component_data)
            source_data = ScarletSourceData(
                components=components,
                factorized_components=factorized,
                peak_id=source.peak_id,  # type: ignore
            )
            sources[source.record_id] = source_data  # type: ignore
 
        blend_data = ScarletBlendData(
            origin=blend.bbox.origin,  # type: ignore
            shape=blend.bbox.shape,  # type: ignore
            sources=sources,
            psf_center=psf_center,
            psf=blend.observation.psfs,
            bands=blend.observation.bands,  # type: ignore
        )
 
        return blend_data
 
 

from_dict()

ScarletBlendData lsst.scarlet.lite.io.ScarletBlendData.from_dict	(		cls,
		dict	data,
		DTypeLike	dtype = np.float32 )

Reconstruct `ScarletBlendData` from JSON compatible
dict.

Parameters
----------
data:
    Dictionary representation of the object
dtype:
    Datatype of the resulting model.

Returns
-------
result:
    The reconstructed object

Definition at line 278 of file io.py.

    def from_dict(cls, data: dict, dtype: DTypeLike = np.float32) -> ScarletBlendData:
        """Reconstruct `ScarletBlendData` from JSON compatible
        dict.
 
        Parameters
        ----------
        data:
            Dictionary representation of the object
        dtype:
            Datatype of the resulting model.
 
        Returns
        -------
        result:
            The reconstructed object
        """
        psf_shape = data["psf_shape"]
        return cls(
            origin=tuple(data["origin"]),  # type: ignore
            shape=tuple(data["shape"]),  # type: ignore
            psf_center=tuple(data["psf_center"]),  # type: ignore
            psf=np.array(data["psf"]).reshape(psf_shape).astype(dtype),
            sources={
                int(bid): ScarletSourceData.from_dict(source, dtype=dtype)
                for bid, source in data["sources"].items()
            },
            bands=tuple(data["bands"]),  # type: ignore
        )
 

minimal_data_to_blend()

Blend lsst.scarlet.lite.io.ScarletBlendData.minimal_data_to_blend	(		self,
		np.ndarray	model_psf,
		DTypeLike	dtype )

Convert the storage data model into a scarlet lite blend

Parameters
----------
model_psf:
    PSF in model space (usually a nyquist sampled circular Gaussian).
dtype:
    The data type of the model that is generated.

Returns
-------
blend:
    A scarlet blend model extracted from persisted data.

Definition at line 307 of file io.py.

    def minimal_data_to_blend(self, model_psf: np.ndarray, dtype: DTypeLike) -> Blend:
        """Convert the storage data model into a scarlet lite blend
 
        Parameters
        ----------
        model_psf:
            PSF in model space (usually a nyquist sampled circular Gaussian).
        dtype:
            The data type of the model that is generated.
 
        Returns
        -------
        blend:
            A scarlet blend model extracted from persisted data.
        """
        model_box = Box(self.shape, origin=(0, 0))
        observation = Observation.empty(
            bands=self.bands,
            psfs=self.psf,
            model_psf=model_psf,
            bbox=model_box,
            dtype=dtype,
        )
        return self.to_blend(observation)
 

to_blend()

Blend lsst.scarlet.lite.io.ScarletBlendData.to_blend	(		self,
		Observation	observation )

Convert the storage data model into a scarlet lite blend

Parameters
----------
observation:
    The observation that contains the blend.
    If `observation` is ``None`` then an `Observation` containing
    no image data is initialized.

Returns
-------
blend:
    A scarlet blend model extracted from persisted data.

Definition at line 332 of file io.py.

    def to_blend(self, observation: Observation) -> Blend:
        """Convert the storage data model into a scarlet lite blend
 
        Parameters
        ----------
        observation:
            The observation that contains the blend.
            If `observation` is ``None`` then an `Observation` containing
            no image data is initialized.
 
        Returns
        -------
        blend:
            A scarlet blend model extracted from persisted data.
        """
        sources = []
        for source_id, source_data in self.sources.items():
            components: list[Component] = []
            for component_data in source_data.components:
                bbox = Box(component_data.shape, origin=component_data.origin)
                model = component_data.model
                if component_data.peak is None:
                    peak = None
                else:
                    peak = (int(np.round(component_data.peak[0])), int(np.round(component_data.peak[0])))
                component = ComponentCube(
                    bands=observation.bands,
                    bbox=bbox,
                    model=Image(model, yx0=bbox.origin, bands=observation.bands),  # type: ignore
                    peak=peak,
                )
                components.append(component)
            for factorized_data in source_data.factorized_components:
                bbox = Box(factorized_data.shape, origin=factorized_data.origin)
                # Add dummy values for properties only needed for
                # model fitting.
                spectrum = FixedParameter(factorized_data.spectrum)
                morph = FixedParameter(factorized_data.morph)
                # Note: since we aren't fitting a model, we don't need to
                # set the RMS of the background.
                # We set it to NaN just to be safe.
                factorized = FactorizedComponent(
                    bands=observation.bands,
                    spectrum=spectrum,
                    morph=morph,
                    peak=tuple(int(np.round(p)) for p in factorized_data.peak),  # type: ignore
                    bbox=bbox,
                    bg_rms=np.full((len(observation.bands),), np.nan),
                )
                components.append(factorized)
 
            source = Source(components=components)
            # Store identifiers for the source
            source.record_id = source_id  # type: ignore
            source.peak_id = source_data.peak_id  # type: ignore
            sources.append(source)
 
        return Blend(sources=sources, observation=observation)
 

Member Data Documentation

bands [1/2]

tuple lsst.scarlet.lite.io.ScarletBlendData.bands [str]

static

Definition at line 256 of file io.py.

bands [2/2]

lsst.scarlet.lite.io.ScarletBlendData.bands

Definition at line 273 of file io.py.

origin [1/2]

tuple lsst.scarlet.lite.io.ScarletBlendData.origin [int, int]

static

Definition at line 251 of file io.py.

origin [2/2]

lsst.scarlet.lite.io.ScarletBlendData.origin

Definition at line 267 of file io.py.

psf

np lsst.scarlet.lite.io.ScarletBlendData.psf .ndarray

static

Definition at line 255 of file io.py.

psf_center [1/2]

tuple lsst.scarlet.lite.io.ScarletBlendData.psf_center [float, float]

static

Definition at line 254 of file io.py.

psf_center [2/2]

lsst.scarlet.lite.io.ScarletBlendData.psf_center

Definition at line 269 of file io.py.

shape [1/2]

tuple lsst.scarlet.lite.io.ScarletBlendData.shape [int, int]

static

Definition at line 252 of file io.py.

shape [2/2]

lsst.scarlet.lite.io.ScarletBlendData.shape

Definition at line 268 of file io.py.

sources

dict lsst.scarlet.lite.io.ScarletBlendData.sources [int, ScarletSourceData]

static

Definition at line 253 of file io.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/io.py