Inheritance diagram for lsst.pipe.tasks.processBrightStars.ProcessBrightStarsTask:

Public Member Functions
	__init__ (self, initInputs=None, args, *kwargs)

	runQuantum (self, butlerQC, inputRefs, outputRefs)

	run (self, inputExposure, refObjLoader=None, dataId=None, skyCorr=None)

	applySkyCorr (self, calexp, skyCorr)

	extractStamps (self, inputExposure, filterName="phot_g_mean", refObjLoader=None, inputBrightStarStamps=None)

	warpStamps (self, stamps, pixCenters)

	setModelStamp (self)

Public Attributes
	modelStampSize

	modelCenter

Static Public Attributes
	ConfigClass = ProcessBrightStarsConfig

Protected Member Functions
	_getCutout (self, inputExposure, Point2D coordPix, list[int] stampSize)

	_replaceSecondaryFootprints (self, stamp, coordPix, objectId, find="DETECTED", replace="BAD")

Static Protected Attributes
str	_DefaultName = "processBrightStars"

Detailed Description

Extract bright star cutouts; normalize and warp to the same pixel grid.

This task is used to extract, process, and store small image cut-outs
(or "postage stamps") around bright stars. It relies on three methods,
called in succession:

`extractStamps`
    Find bright stars within the exposure using a reference catalog and
    extract a stamp centered on each.
`warpStamps`
    Shift and warp each stamp to remove optical distortions and sample all
    stars on the same pixel grid.
`measureAndNormalize`
    Compute the flux of an object in an annulus and normalize it. This is
    required to normalize each bright star stamp as their central pixels
    are likely saturated and/or contain ghosts, and cannot be used.

Definition at line 165 of file processBrightStars.py.

Constructor & Destructor Documentation

◆ init()

lsst.pipe.tasks.processBrightStars.ProcessBrightStarsTask.__init__	(		self,
			initInputs = None,
		*	args,
		**	kwargs )

Definition at line 187 of file processBrightStars.py.

    def __init__(self, initInputs=None, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.setModelStamp()
 

Member Function Documentation

◆ _getCutout()

lsst.pipe.tasks.processBrightStars.ProcessBrightStarsTask._getCutout	(		self,
			inputExposure,
		Point2D	coordPix,
		list[int]	stampSize )

protected

Get a cutout from an input exposure, handling edge cases.

Generate a cutout from an input exposure centered on a given position
and with a given size.
If any part of the cutout is outside the input exposure bounding box,
the cutout is padded with NaNs.

Parameters
----------
inputExposure : `~lsst.afw.image.ExposureF`
    The image to extract bright star stamps from.
coordPix : `~lsst.geom.Point2D`
    Center of the cutout in pixel space.
stampSize : `list` [`int`]
    Size of the cutout, in pixels.

Returns
-------
stamp : `~lsst.afw.image.ExposureF` or `None`
    The cutout, or `None` if the cutout is entirely outside the input
    exposure bounding box.

Notes
-----
This method is a short-term workaround until DM-40042 is implemented.
At that point, it should be replaced by a call to the Exposure method
``getCutout``, which will handle edge cases automatically.

Definition at line 415 of file processBrightStars.py.

    def _getCutout(self, inputExposure, coordPix: Point2D, stampSize: list[int]):
        """Get a cutout from an input exposure, handling edge cases.
 
        Generate a cutout from an input exposure centered on a given position
        and with a given size.
        If any part of the cutout is outside the input exposure bounding box,
        the cutout is padded with NaNs.
 
        Parameters
        ----------
        inputExposure : `~lsst.afw.image.ExposureF`
            The image to extract bright star stamps from.
        coordPix : `~lsst.geom.Point2D`
            Center of the cutout in pixel space.
        stampSize : `list` [`int`]
            Size of the cutout, in pixels.
 
        Returns
        -------
        stamp : `~lsst.afw.image.ExposureF` or `None`
            The cutout, or `None` if the cutout is entirely outside the input
            exposure bounding box.
 
        Notes
        -----
        This method is a short-term workaround until DM-40042 is implemented.
        At that point, it should be replaced by a call to the Exposure method
        ``getCutout``, which will handle edge cases automatically.
        """
        # TODO: Replace this method with exposure getCutout after DM-40042.
        corner = Point2I(np.array(coordPix) - np.array(stampSize) / 2)
        dimensions = Extent2I(stampSize)
        stampBBox = Box2I(corner, dimensions)
        overlapBBox = Box2I(stampBBox)
        overlapBBox.clip(inputExposure.getBBox())
        if overlapBBox.getArea() > 0:
            # Create full-sized stamp with pixels initially flagged as NO_DATA.
            stamp = ExposureF(bbox=stampBBox)
            stamp.image[:] = np.nan
            stamp.mask.set(inputExposure.mask.getPlaneBitMask("NO_DATA"))
            # Restore pixels which overlap the input exposure.
            inputMI = inputExposure.maskedImage
            overlap = inputMI.Factory(inputMI, overlapBBox)
            stamp.maskedImage[overlapBBox] = overlap
            # Set detector and WCS.
            stamp.setDetector(inputExposure.getDetector())
            stamp.setWcs(inputExposure.getWcs())
        else:
            stamp = None
        return stamp
 

◆ _replaceSecondaryFootprints()

lsst.pipe.tasks.processBrightStars.ProcessBrightStarsTask._replaceSecondaryFootprints	(	self,
		stamp,
		coordPix,
		objectId,
		find = "DETECTED",
		replace = "BAD" )

protected

Replace all secondary footprints in a stamp with another mask flag.

This method identifies all secondary footprints in a stamp as those
whose ``find`` footprints do not overlap the given pixel coordinates.
If then sets these secondary footprints to the ``replace`` flag.

Parameters
----------
stamp : `~lsst.afw.image.ExposureF`
    The postage stamp to modify.
coordPix : `~lsst.geom.Point2D`
    The pixel coordinates of the central primary object.
objectId : `int`
    The unique identifier of the central primary object.
find : `str`, optional
    The mask plane to use to identify secondary footprints.
replace : `str`, optional
    The mask plane to set secondary footprints to.

Notes
-----
This method modifies the input ``stamp`` in-place.

Definition at line 466 of file processBrightStars.py.

    def _replaceSecondaryFootprints(self, stamp, coordPix, objectId, find="DETECTED", replace="BAD"):
        """Replace all secondary footprints in a stamp with another mask flag.
 
        This method identifies all secondary footprints in a stamp as those
        whose ``find`` footprints do not overlap the given pixel coordinates.
        If then sets these secondary footprints to the ``replace`` flag.
 
        Parameters
        ----------
        stamp : `~lsst.afw.image.ExposureF`
            The postage stamp to modify.
        coordPix : `~lsst.geom.Point2D`
            The pixel coordinates of the central primary object.
        objectId : `int`
            The unique identifier of the central primary object.
        find : `str`, optional
            The mask plane to use to identify secondary footprints.
        replace : `str`, optional
            The mask plane to set secondary footprints to.
 
        Notes
        -----
        This method modifies the input ``stamp`` in-place.
        """
        # Find a FootprintSet given an Image and a threshold.
        detThreshold = Threshold(stamp.mask.getPlaneBitMask(find), Threshold.BITMASK)
        footprintSet = FootprintSet(stamp.mask, detThreshold)
        allFootprints = footprintSet.getFootprints()
        # Identify secondary objects (i.e., not the central primary object).
        secondaryFootprints = []
        for footprint in allFootprints:
            if not footprint.contains(Point2I(coordPix)):
                secondaryFootprints.append(footprint)
        # Set secondary object footprints to BAD.
        # Note: the value of numPrimaryFootprints can only be 0 or 1. If it is
        # 0, then the primary object was not found overlapping a footprint.
        # This can occur for low-S/N stars, for example. Processing can still
        # continue beyond this point in an attempt to utilize this faint flux.
        if (numPrimaryFootprints := len(allFootprints) - len(secondaryFootprints)) == 0:
            self.log.info(
                "Could not uniquely identify central %s footprint for star %s; "
                "found %d footprints instead.",
                find,
                objectId,
                numPrimaryFootprints,
            )
        footprintSet.setFootprints(secondaryFootprints)
        footprintSet.setMask(stamp.mask, replace)
 

◆ applySkyCorr()

lsst.pipe.tasks.processBrightStars.ProcessBrightStarsTask.applySkyCorr	(	self,
		calexp,
		skyCorr )

Apply sky correction to the input exposure.

Sky corrections can be generated using the
`~lsst.pipe.tasks.skyCorrection.SkyCorrectionTask`.
As the sky model generated via that task extends over the full focal
plane, this should produce a more optimal sky subtraction solution.

Parameters
----------
calexp : `~lsst.afw.image.Exposure` or `~lsst.afw.image.MaskedImage`
    Calibrated exposure to correct.
skyCorr : `~lsst.afw.math.backgroundList.BackgroundList`
    Full focal plane sky correction from ``SkyCorrectionTask``.

Notes
-----
This method modifies the input ``calexp`` in-place.

Definition at line 298 of file processBrightStars.py.

    def applySkyCorr(self, calexp, skyCorr):
        """Apply sky correction to the input exposure.
 
        Sky corrections can be generated using the
        `~lsst.pipe.tasks.skyCorrection.SkyCorrectionTask`.
        As the sky model generated via that task extends over the full focal
        plane, this should produce a more optimal sky subtraction solution.
 
        Parameters
        ----------
        calexp : `~lsst.afw.image.Exposure` or `~lsst.afw.image.MaskedImage`
            Calibrated exposure to correct.
        skyCorr : `~lsst.afw.math.backgroundList.BackgroundList`
            Full focal plane sky correction from ``SkyCorrectionTask``.
 
        Notes
        -----
        This method modifies the input ``calexp`` in-place.
        """
        if isinstance(calexp, Exposure):
            calexp = calexp.getMaskedImage()
        calexp -= skyCorr.getImage()
 

◆ extractStamps()

lsst.pipe.tasks.processBrightStars.ProcessBrightStarsTask.extractStamps	(	self,
		inputExposure,
		filterName = "phot_g_mean",
		refObjLoader = None,
		inputBrightStarStamps = None )

Identify the positions of bright stars within an input exposure using
a reference catalog and extract them.

Parameters
----------
inputExposure : `~lsst.afw.image.ExposureF`
    The image to extract bright star stamps from.
filterName : `str`, optional
    Name of the camera filter to use for reference catalog filtering.
refObjLoader : `~lsst.meas.algorithms.ReferenceObjectLoader`, optional
    Loader to find objects within a reference catalog.
inputBrightStarStamps:
    `~lsst.meas.algorithms.brightStarStamps.BrightStarStamps`, optional
    Provides information about the stars that have already been
    extracted from the inputExposure in other steps of the pipeline.
    For example, this is used in the `SubtractBrightStarsTask` to avoid
    extracting stars that already have been extracted when running
    `ProcessBrightStarsTask` to produce brightStarStamps.

Returns
-------
result : `~lsst.pipe.base.Struct`
    Results as a struct with attributes:

    ``starStamps``
        Postage stamps (`list`).
    ``pixCenters``
        Corresponding coords to each star's center, in pixels (`list`).
    ``gMags``
        Corresponding (Gaia) G magnitudes (`list`).
    ``gaiaIds``
        Corresponding unique Gaia identifiers (`np.ndarray`).

Definition at line 321 of file processBrightStars.py.

    ):
        """Identify the positions of bright stars within an input exposure using
        a reference catalog and extract them.
 
        Parameters
        ----------
        inputExposure : `~lsst.afw.image.ExposureF`
            The image to extract bright star stamps from.
        filterName : `str`, optional
            Name of the camera filter to use for reference catalog filtering.
        refObjLoader : `~lsst.meas.algorithms.ReferenceObjectLoader`, optional
            Loader to find objects within a reference catalog.
        inputBrightStarStamps:
            `~lsst.meas.algorithms.brightStarStamps.BrightStarStamps`, optional
            Provides information about the stars that have already been
            extracted from the inputExposure in other steps of the pipeline.
            For example, this is used in the `SubtractBrightStarsTask` to avoid
            extracting stars that already have been extracted when running
            `ProcessBrightStarsTask` to produce brightStarStamps.
 
        Returns
        -------
        result : `~lsst.pipe.base.Struct`
            Results as a struct with attributes:
 
            ``starStamps``
                Postage stamps (`list`).
            ``pixCenters``
                Corresponding coords to each star's center, in pixels (`list`).
            ``gMags``
                Corresponding (Gaia) G magnitudes (`list`).
            ``gaiaIds``
                Corresponding unique Gaia identifiers (`np.ndarray`).
        """
        if refObjLoader is None:
            refObjLoader = self.refObjLoader
 
        wcs = inputExposure.getWcs()
        inputBBox = inputExposure.getBBox()
 
        # Trim the reference catalog to only those objects within the exposure
        # bounding box dilated by half the bright star stamp size. This ensures
        # all stars that overlap the exposure are included.
        dilatationExtent = Extent2I(np.array(self.config.stampSize) // 2)
        withinExposure = refObjLoader.loadPixelBox(
            inputBBox.dilatedBy(dilatationExtent), wcs, filterName=filterName
        )
        refCat = withinExposure.refCat
        fluxField = withinExposure.fluxField
 
        # Define ref cat bright subset: objects brighter than the mag limit.
        fluxLimit = ((self.config.magLimit * u.ABmag).to(u.nJy)).to_value()  # AB magnitudes.
        refCatBright = Table(
            refCat.extract("id", "coord_ra", "coord_dec", fluxField, where=refCat[fluxField] > fluxLimit)
        )
        refCatBright["mag"] = (refCatBright[fluxField][:] * u.nJy).to(u.ABmag).to_value()  # AB magnitudes.
 
        # Remove input bright stars (if provided) from the bright subset.
        if inputBrightStarStamps is not None:
            # Extract the IDs of stars that have already been extracted.
            existing = np.isin(refCatBright["id"][:], inputBrightStarStamps.getGaiaIds())
            refCatBright = refCatBright[~existing]
 
        # Loop over each reference bright star, extract a stamp around it.
        pixCenters = []
        starStamps = []
        badRows = []
        for row, object in enumerate(refCatBright):
            coordSky = SpherePoint(object["coord_ra"], object["coord_dec"], radians)
            coordPix = wcs.skyToPixel(coordSky)
            # TODO: Replace this method with exposure getCutout after DM-40042.
            starStamp = self._getCutout(inputExposure, coordPix, self.config.stampSize.list())
            if not starStamp:
                badRows.append(row)
                continue
            if self.config.doRemoveDetected:
                self._replaceSecondaryFootprints(starStamp, coordPix, object["id"])
            starStamps.append(starStamp)
            pixCenters.append(coordPix)
 
        # Remove bad rows from the reference catalog; set up return data.
        refCatBright.remove_rows(badRows)
        gMags = list(refCatBright["mag"][:])
        ids = list(refCatBright["id"][:])
 
        # Store the count number of all stars (within the given magnitude
        # range) that overlap the exposure.
        # TODO: Make sure self._getCutout only misses stars that don't have any
        # valid pixel overlapped with the exposure.
        self.metadata["allStarCount"] = len(starStamps)
        return Struct(starStamps=starStamps, pixCenters=pixCenters, gMags=gMags, gaiaIds=ids)
 

◆ run()

lsst.pipe.tasks.processBrightStars.ProcessBrightStarsTask.run	(	self,
		inputExposure,
		refObjLoader = None,
		dataId = None,
		skyCorr = None )

Identify bright stars within an exposure using a reference catalog,
extract stamps around each, then preprocess them.

Bright star preprocessing steps are: shifting, warping and potentially
rotating them to the same pixel grid; computing their annular flux,
and; normalizing them.

Parameters
----------
inputExposure : `~lsst.afw.image.ExposureF`
    The image from which bright star stamps should be extracted.
refObjLoader : `~lsst.meas.algorithms.ReferenceObjectLoader`, optional
    Loader to find objects within a reference catalog.
dataId : `dict` or `~lsst.daf.butler.DataCoordinate`
    The dataId of the exposure (including detector) that bright stars
    should be extracted from.
skyCorr : `~lsst.afw.math.backgroundList.BackgroundList`, optional
    Full focal plane sky correction obtained by `SkyCorrectionTask`.

Returns
-------
brightStarResults : `~lsst.pipe.base.Struct`
    Results as a struct with attributes:

    ``brightStarStamps``
        (`~lsst.meas.algorithms.brightStarStamps.BrightStarStamps`)

Definition at line 206 of file processBrightStars.py.

    def run(self, inputExposure, refObjLoader=None, dataId=None, skyCorr=None):
        """Identify bright stars within an exposure using a reference catalog,
        extract stamps around each, then preprocess them.
 
        Bright star preprocessing steps are: shifting, warping and potentially
        rotating them to the same pixel grid; computing their annular flux,
        and; normalizing them.
 
        Parameters
        ----------
        inputExposure : `~lsst.afw.image.ExposureF`
            The image from which bright star stamps should be extracted.
        refObjLoader : `~lsst.meas.algorithms.ReferenceObjectLoader`, optional
            Loader to find objects within a reference catalog.
        dataId : `dict` or `~lsst.daf.butler.DataCoordinate`
            The dataId of the exposure (including detector) that bright stars
            should be extracted from.
        skyCorr : `~lsst.afw.math.backgroundList.BackgroundList`, optional
            Full focal plane sky correction obtained by `SkyCorrectionTask`.
 
        Returns
        -------
        brightStarResults : `~lsst.pipe.base.Struct`
            Results as a struct with attributes:
 
            ``brightStarStamps``
                (`~lsst.meas.algorithms.brightStarStamps.BrightStarStamps`)
        """
        if self.config.doApplySkyCorr:
            self.log.info("Applying sky correction to exposure %s (exposure modified in-place).", dataId)
            self.applySkyCorr(inputExposure, skyCorr)
 
        self.log.info("Extracting bright stars from exposure %s", dataId)
        # Extract stamps around bright stars.
        extractedStamps = self.extractStamps(inputExposure, refObjLoader=refObjLoader)
        if not extractedStamps.starStamps:
            self.log.info("No suitable bright star found.")
            return None
        # Warp (and shift, and potentially rotate) them.
        self.log.info(
            "Applying warp and/or shift to %i star stamps from exposure %s.",
            len(extractedStamps.starStamps),
            dataId,
        )
        warpOutputs = self.warpStamps(extractedStamps.starStamps, extractedStamps.pixCenters)
        warpedStars = warpOutputs.warpedStars
        xy0s = warpOutputs.xy0s
        brightStarList = [
            BrightStarStamp(
                stamp_im=warp,
                archive_element=transform,
                position=xy0s[j],
                gaiaGMag=extractedStamps.gMags[j],
                gaiaId=extractedStamps.gaiaIds[j],
                minValidAnnulusFraction=self.config.minValidAnnulusFraction,
            )
            for j, (warp, transform) in enumerate(zip(warpedStars, warpOutputs.warpTransforms))
        ]
        # Compute annularFlux and normalize
        self.log.info(
            "Computing annular flux and normalizing %i bright stars from exposure %s.",
            len(warpedStars),
            dataId,
        )
        # annularFlux statistic set-up, excluding mask planes
        statsControl = StatisticsControl(
            numSigmaClip=self.config.numSigmaClip,
            numIter=self.config.numIter,
        )
 
        innerRadius, outerRadius = self.config.annularFluxRadii
        statsFlag = stringToStatisticsProperty(self.config.annularFluxStatistic)
        brightStarStamps = BrightStarStamps.initAndNormalize(
            brightStarList,
            innerRadius=innerRadius,
            outerRadius=outerRadius,
            nb90Rots=warpOutputs.nb90Rots,
            imCenter=self.modelCenter,
            use_archive=True,
            statsControl=statsControl,
            statsFlag=statsFlag,
            badMaskPlanes=self.config.badMaskPlanes,
            discardNanFluxObjects=(self.config.discardNanFluxStars),
        )
        # Store the count number of valid stars that overlap the exposure.
        self.metadata["validStarCount"] = len(brightStarStamps)
        # Do not create empty FITS files if there aren't any normalized stamps.
        if not brightStarStamps._stamps:
            self.log.info("No normalized stamps exist for this exposure.")
            return None
        return Struct(brightStarStamps=brightStarStamps)
 

◆ runQuantum()

lsst.pipe.tasks.processBrightStars.ProcessBrightStarsTask.runQuantum	(	self,
		butlerQC,
		inputRefs,
		outputRefs )

Definition at line 191 of file processBrightStars.py.

    def runQuantum(self, butlerQC, inputRefs, outputRefs):
        inputs = butlerQC.get(inputRefs)
        inputs["dataId"] = str(butlerQC.quantum.dataId)
        refObjLoader = ReferenceObjectLoader(
            dataIds=[ref.datasetRef.dataId for ref in inputRefs.refCat],
            refCats=inputs.pop("refCat"),
            name=self.config.connections.refCat,
            config=self.config.refObjLoader,
        )
        output = self.run(**inputs, refObjLoader=refObjLoader)
        # Only ingest stamp if it exists; prevent ingesting an empty FITS file.
        if output:
            butlerQC.put(output, outputRefs)
 

◆ setModelStamp()

lsst.pipe.tasks.processBrightStars.ProcessBrightStarsTask.setModelStamp ( self )

Compute (model) stamp size depending on provided buffer value.

Definition at line 611 of file processBrightStars.py.

    def setModelStamp(self):
        """Compute (model) stamp size depending on provided buffer value."""
        self.modelStampSize = [
            int(self.config.stampSize[0] * self.config.modelStampBuffer),
            int(self.config.stampSize[1] * self.config.modelStampBuffer),
        ]
        # Force stamp to be odd-sized so we have a central pixel.
        if not self.modelStampSize[0] % 2:
            self.modelStampSize[0] += 1
        if not self.modelStampSize[1] % 2:
            self.modelStampSize[1] += 1
        # Central pixel.
        self.modelCenter = self.modelStampSize[0] // 2, self.modelStampSize[1] // 2

◆ warpStamps()

lsst.pipe.tasks.processBrightStars.ProcessBrightStarsTask.warpStamps	(	self,
		stamps,
		pixCenters )

Warps and shifts all given stamps so they are sampled on the same
pixel grid and centered on the central pixel. This includes rotating
the stamp depending on detector orientation.

Parameters
----------
stamps : `Sequence` [`~lsst.afw.image.ExposureF`]
    Image cutouts centered on a single object.
pixCenters : `Sequence` [`~lsst.geom.Point2D`]
    Positions of each object's center (from the refCat) in pixels.

Returns
-------
result : `~lsst.pipe.base.Struct`
    Results as a struct with attributes:

    ``warpedStars``
        Stamps of warped stars.
            (`list` [`~lsst.afw.image.MaskedImage`])
    ``warpTransforms``
        The corresponding Transform from the initial star stamp
        to the common model grid.
            (`list` [`~lsst.afw.geom.TransformPoint2ToPoint2`])
    ``xy0s``
        Coordinates of the bottom-left pixels of each stamp,
        before rotation.
            (`list` [`~lsst.geom.Point2I`])
    ``nb90Rots``
        The number of 90 degrees rotations required to compensate for
        detector orientation.
            (`int`)

Definition at line 515 of file processBrightStars.py.

    def warpStamps(self, stamps, pixCenters):
        """Warps and shifts all given stamps so they are sampled on the same
        pixel grid and centered on the central pixel. This includes rotating
        the stamp depending on detector orientation.
 
        Parameters
        ----------
        stamps : `Sequence` [`~lsst.afw.image.ExposureF`]
            Image cutouts centered on a single object.
        pixCenters : `Sequence` [`~lsst.geom.Point2D`]
            Positions of each object's center (from the refCat) in pixels.
 
        Returns
        -------
        result : `~lsst.pipe.base.Struct`
            Results as a struct with attributes:
 
            ``warpedStars``
                Stamps of warped stars.
                    (`list` [`~lsst.afw.image.MaskedImage`])
            ``warpTransforms``
                The corresponding Transform from the initial star stamp
                to the common model grid.
                    (`list` [`~lsst.afw.geom.TransformPoint2ToPoint2`])
            ``xy0s``
                Coordinates of the bottom-left pixels of each stamp,
                before rotation.
                    (`list` [`~lsst.geom.Point2I`])
            ``nb90Rots``
                The number of 90 degrees rotations required to compensate for
                detector orientation.
                    (`int`)
        """
        # warping control; only contains shiftingALg provided in config
        warpCont = WarpingControl(self.config.warpingKernelName)
        # Compare model to star stamp sizes
        bufferPix = (
            self.modelStampSize[0] - self.config.stampSize[0],
            self.modelStampSize[1] - self.config.stampSize[1],
        )
        # Initialize detector instance (note all stars were extracted from an
        # exposure from the same detector)
        det = stamps[0].getDetector()
        # Define correction for optical distortions
        if self.config.doApplyTransform:
            pixToTan = det.getTransform(PIXELS, TAN_PIXELS)
        else:
            pixToTan = makeIdentityTransform()
        # Array of all possible rotations for detector orientation:
        possibleRots = np.array([k * np.pi / 2 for k in range(4)])
        # determine how many, if any, rotations are required
        yaw = det.getOrientation().getYaw()
        nb90Rots = np.argmin(np.abs(possibleRots - float(yaw)))
 
        # apply transformation to each star
        warpedStars, warpTransforms, xy0s = [], [], []
        for star, cent in zip(stamps, pixCenters):
            # (re)create empty destination image
            destImage = MaskedImageF(*self.modelStampSize)
            bottomLeft = Point2D(star.image.getXY0())
            newBottomLeft = pixToTan.applyForward(bottomLeft)
            newBottomLeft.setX(newBottomLeft.getX() - bufferPix[0] / 2)
            newBottomLeft.setY(newBottomLeft.getY() - bufferPix[1] / 2)
            # Convert to int
            newBottomLeft = Point2I(newBottomLeft)
            # Set origin and save it
            destImage.setXY0(newBottomLeft)
            xy0s.append(newBottomLeft)
 
            # Define linear shifting to recenter stamps
            newCenter = pixToTan.applyForward(cent)  # center of warped star
            shift = (
                self.modelCenter[0] + newBottomLeft[0] - newCenter[0],
                self.modelCenter[1] + newBottomLeft[1] - newCenter[1],
            )
            affineShift = AffineTransform(shift)
            shiftTransform = makeTransform(affineShift)
 
            # Define full transform (warp and shift)
            starWarper = pixToTan.then(shiftTransform)
 
            # Apply it
            goodPix = warpImage(destImage, star.getMaskedImage(), starWarper, warpCont)
            if not goodPix:
                self.log.debug("Warping of a star failed: no good pixel in output")
 
            # Arbitrarily set origin of shifted star to 0
            destImage.setXY0(0, 0)
 
            # Apply rotation if appropriate
            if nb90Rots:
                destImage = rotateImageBy90(destImage, nb90Rots)
            warpedStars.append(destImage.clone())
            warpTransforms.append(starWarper)
        return Struct(warpedStars=warpedStars, warpTransforms=warpTransforms, xy0s=xy0s, nb90Rots=nb90Rots)
 

Member Data Documentation

◆ _DefaultName

str lsst.pipe.tasks.processBrightStars.ProcessBrightStarsTask._DefaultName = "processBrightStars"

staticprotected

Definition at line 185 of file processBrightStars.py.

◆ ConfigClass

lsst.pipe.tasks.processBrightStars.ProcessBrightStarsTask.ConfigClass = ProcessBrightStarsConfig

static

Definition at line 184 of file processBrightStars.py.

◆ modelCenter

lsst.pipe.tasks.processBrightStars.ProcessBrightStarsTask.modelCenter

Definition at line 623 of file processBrightStars.py.

◆ modelStampSize

lsst.pipe.tasks.processBrightStars.ProcessBrightStarsTask.modelStampSize

Definition at line 613 of file processBrightStars.py.

The documentation for this class was generated from the following file:

/j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/pipe_tasks/g14a832a312+ff425fae3c/python/lsst/pipe/tasks/processBrightStars.py

Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Attributes