Public Member Functions
	__init__ (self, bbox, threshold=10.0, exposure=None, **kwds)

	makeMinimalSchema (cls)

	addSource (self, instFlux, centroid, shape=None, setPeakSignificance=True)

	addBlend (self)

	transform (self, wcs, **kwds)

	realize (self, noise, schema, randomSeed=1)

Static Public Member Functions
	makePerturbedWcs (oldWcs, minScaleFactor=1.2, maxScaleFactor=1.5, minRotation=None, maxRotation=None, minRefShift=None, maxRefShift=None, minPixShift=2.0, maxPixShift=4.0, randomSeed=1)

	makeEmptyExposure (bbox, wcs=None, crval=None, cdelt=None, psfSigma=2.0, psfDim=17, calibration=4, visitId=1234, mjd=60000.0)

	drawGaussian (bbox, instFlux, ellipse)

Public Attributes
	threshold

	exposure

	psfShape

	schema

	catalog

	keys

Protected Member Functions
	_installFootprint (self, record, image, setPeakSignificance=True)

Protected Attributes
	_schema

Detailed Description

A simulated dataset consisuting of test image and truth catalog.

TestDataset creates an idealized image made of pure Gaussians (including a
Gaussian PSF), with simple noise and idealized Footprints/HeavyFootprints
that simulated the outputs of detection and deblending.  Multiple noise
realizations can be created from the same underlying sources, allowing
uncertainty estimates to be verified via Monte Carlo.

Parameters
----------
bbox : `lsst.geom.Box2I` or `lsst.geom.Box2D`
    Bounding box of the test image.
threshold : `float`
    Threshold absolute value used to determine footprints for
    simulated sources.  This thresholding will be applied before noise is
    actually added to images (or before the noise level is even known), so
    this will necessarily produce somewhat artificial footprints.
exposure : `lsst.afw.image.ExposureF`
    The image to which test sources should be added. Ownership should
    be considered transferred from the caller to the TestDataset.
    Must have a Gaussian PSF for truth catalog shapes to be exact.
**kwds
    Keyword arguments forwarded to makeEmptyExposure if exposure is `None`.

Notes
-----
Typical usage:

.. code-block: py

    bbox = lsst.geom.Box2I(lsst.geom.Point2I(0,0), lsst.geom.Point2I(100,
                                                                     100))
    dataset = TestDataset(bbox)
    dataset.addSource(instFlux=1E5, centroid=lsst.geom.Point2D(25, 26))
    dataset.addSource(instFlux=2E5, centroid=lsst.geom.Point2D(75, 24),
                    shape=lsst.afw.geom.Quadrupole(8, 7, 2))
    with dataset.addBlend() as family:
        family.addChild(instFlux=2E5, centroid=lsst.geom.Point2D(50, 72))
        family.addChild(instFlux=1.5E5, centroid=lsst.geom.Point2D(51, 74))
    exposure, catalog = dataset.realize(noise=100.0,
                                        schema=TestDataset.makeMinimalSchema())

Definition at line 126 of file tests.py.

Constructor & Destructor Documentation

◆ init()

lsst.meas.base.tests.TestDataset.__init__	(		self,
			bbox,
			threshold = 10.0,
			exposure = None,
		**	kwds )

Definition at line 170 of file tests.py.

    def __init__(self, bbox, threshold=10.0, exposure=None, **kwds):
        if exposure is None:
            exposure = self.makeEmptyExposure(bbox, **kwds)
        self.threshold = lsst.afw.detection.Threshold(threshold, lsst.afw.detection.Threshold.VALUE)
        self.exposure = exposure
        self.psfShape = self.exposure.getPsf().computeShape(bbox.getCenter())
        self.schema = self.makeMinimalSchema()
        self.catalog = lsst.afw.table.SourceCatalog(self.schema)
 

Member Function Documentation

◆ _installFootprint()

lsst.meas.base.tests.TestDataset._installFootprint	(	self,
		record,
		image,
		setPeakSignificance = True )

protected

Create simulated Footprint and add it to a truth catalog record.

Definition at line 410 of file tests.py.

    def _installFootprint(self, record, image, setPeakSignificance=True):
        """Create simulated Footprint and add it to a truth catalog record.
        """
        schema = lsst.afw.detection.PeakTable.makeMinimalSchema()
        if setPeakSignificance:
            schema.addField("significance", type=float,
                            doc="Ratio of peak value to configured standard deviation.")
        # Run detection on the single-source image
        fpSet = lsst.afw.detection.FootprintSet(image, self.threshold, peakSchema=schema)
        # the call below to the FootprintSet ctor is actually a grow operation
        fpSet = lsst.afw.detection.FootprintSet(fpSet, int(self.psfShape.getDeterminantRadius() + 1.0), True)
        if setPeakSignificance:
            # This isn't a traditional significance, since we're using the VALUE
            # threshold type, but it's the best we can do in that case.
            for footprint in fpSet.getFootprints():
                footprint.updatePeakSignificance(self.threshold.getValue())
        # Update the full exposure's mask plane to indicate the detection
        fpSet.setMask(self.exposure.mask, "DETECTED")
        # Attach the new footprint to the exposure
        if len(fpSet.getFootprints()) > 1:
            raise RuntimeError("Threshold value results in multiple Footprints for a single object")
        if len(fpSet.getFootprints()) == 0:
            raise RuntimeError("Threshold value results in zero Footprints for object")
        record.setFootprint(fpSet.getFootprints()[0])
 

◆ addBlend()

lsst.meas.base.tests.TestDataset.addBlend ( self )

Return a context manager which can add a blend of multiple sources.

Notes
-----
Note that nothing stops you from creating overlapping sources just using the addSource() method,
but addBlend() is necesssary to create a parent object and deblended HeavyFootprints of the type
produced by the detection and deblending pipelines.

Examples
--------
.. code-block: py
    d = TestDataset(...)
    with d.addBlend() as b:
        b.addChild(flux1, centroid1)
        b.addChild(flux2, centroid2, shape2)

Definition at line 489 of file tests.py.

    def addBlend(self):
        """Return a context manager which can add a blend of multiple sources.
 
        Notes
        -----
        Note that nothing stops you from creating overlapping sources just using the addSource() method,
        but addBlend() is necesssary to create a parent object and deblended HeavyFootprints of the type
        produced by the detection and deblending pipelines.
 
        Examples
        --------
        .. code-block: py
            d = TestDataset(...)
            with d.addBlend() as b:
                b.addChild(flux1, centroid1)
                b.addChild(flux2, centroid2, shape2)
        """
        return BlendContext(self)
 

◆ addSource()

lsst.meas.base.tests.TestDataset.addSource	(	self,
		instFlux,
		centroid,
		shape = None,
		setPeakSignificance = True )

Add a source to the simulation.

To insert a point source with a given signal-to-noise (sn), the total
``instFlux`` should be: ``sn*noise*psf_scale``, where ``noise`` is the
noise you will pass to ``realize()``, and
``psf_scale=sqrt(4*pi*r^2)``, where ``r`` is the width of the PSF.

Parameters
----------
instFlux : `float`
    Total instFlux of the source to be added.
centroid : `lsst.geom.Point2D`
    Position of the source to be added.
shape : `lsst.afw.geom.Quadrupole`
    Second moments of the source before PSF convolution. Note that the
    truth catalog records post-convolution moments. If `None`, a point
    source will be added.
setPeakSignificance : `bool`
    Set the ``significance`` field for peaks in the footprints?
    See ``lsst.meas.algorithms.SourceDetectionTask.setPeakSignificance``
    for how this field is computed for real datasets.

Returns
-------
record : `lsst.afw.table.SourceRecord`
    A truth catalog record.
image : `lsst.afw.image.ImageF`
    Single-source image corresponding to the new source.

Definition at line 435 of file tests.py.

    def addSource(self, instFlux, centroid, shape=None, setPeakSignificance=True):
        """Add a source to the simulation.
 
        To insert a point source with a given signal-to-noise (sn), the total
        ``instFlux`` should be: ``sn*noise*psf_scale``, where ``noise`` is the
        noise you will pass to ``realize()``, and
        ``psf_scale=sqrt(4*pi*r^2)``, where ``r`` is the width of the PSF.
 
        Parameters
        ----------
        instFlux : `float`
            Total instFlux of the source to be added.
        centroid : `lsst.geom.Point2D`
            Position of the source to be added.
        shape : `lsst.afw.geom.Quadrupole`
            Second moments of the source before PSF convolution. Note that the
            truth catalog records post-convolution moments. If `None`, a point
            source will be added.
        setPeakSignificance : `bool`
            Set the ``significance`` field for peaks in the footprints?
            See ``lsst.meas.algorithms.SourceDetectionTask.setPeakSignificance``
            for how this field is computed for real datasets.
 
        Returns
        -------
        record : `lsst.afw.table.SourceRecord`
            A truth catalog record.
        image : `lsst.afw.image.ImageF`
            Single-source image corresponding to the new source.
        """
        # Create and set the truth catalog fields
        record = self.catalog.addNew()
        record.set(self.keys["instFlux"], instFlux)
        record.set(self.keys["instFluxErr"], 0)
        record.set(self.keys["centroid"], centroid)
        covariance = np.random.normal(0, 0.1, 4).reshape(2, 2)
        covariance[0, 1] = covariance[1, 0]  # CovarianceMatrixKey assumes symmetric x_y_Cov
        record.set(self.keys["centroid_sigma"], covariance.astype(np.float32))
        if shape is None:
            record.set(self.keys["isStar"], True)
            fullShape = self.psfShape
        else:
            record.set(self.keys["isStar"], False)
            fullShape = shape.convolve(self.psfShape)
        record.set(self.keys["shape"], fullShape)
        # Create an image containing just this source
        image = self.drawGaussian(self.exposure.getBBox(), instFlux,
                                  lsst.afw.geom.Ellipse(fullShape, centroid))
        # Generate a footprint for this source
        self._installFootprint(record, image, setPeakSignificance)
        # Actually add the source to the full exposure
        self.exposure.image.array[:, :] += image.array
        return record, image
 

◆ drawGaussian()

lsst.meas.base.tests.TestDataset.drawGaussian	(	bbox,
		instFlux,
		ellipse )

static

Create an image of an elliptical Gaussian.

Parameters
----------
bbox : `lsst.geom.Box2I` or `lsst.geom.Box2D`
    Bounding box of image to create.
instFlux : `float`
    Total instrumental flux of the Gaussian (normalized analytically,
    not using pixel values).
ellipse : `lsst.afw.geom.Ellipse`
    Defines the centroid and shape.

Returns
-------
image : `lsst.afw.image.ImageF`
    An image of the Gaussian.

Definition at line 383 of file tests.py.

    def drawGaussian(bbox, instFlux, ellipse):
        """Create an image of an elliptical Gaussian.
 
        Parameters
        ----------
        bbox : `lsst.geom.Box2I` or `lsst.geom.Box2D`
            Bounding box of image to create.
        instFlux : `float`
            Total instrumental flux of the Gaussian (normalized analytically,
            not using pixel values).
        ellipse : `lsst.afw.geom.Ellipse`
            Defines the centroid and shape.
 
        Returns
        -------
        image : `lsst.afw.image.ImageF`
            An image of the Gaussian.
        """
        x, y = np.meshgrid(np.arange(bbox.getBeginX(), bbox.getEndX()),
                           np.arange(bbox.getBeginY(), bbox.getEndY()))
        t = ellipse.getGridTransform()
        xt = t[t.XX] * x + t[t.XY] * y + t[t.X]
        yt = t[t.YX] * x + t[t.YY] * y + t[t.Y]
        image = lsst.afw.image.ImageF(bbox)
        image.array[:, :] = np.exp(-0.5*(xt**2 + yt**2))*instFlux/(2.0*ellipse.getCore().getArea())
        return image
 

◆ makeEmptyExposure()

lsst.meas.base.tests.TestDataset.makeEmptyExposure	(	bbox,
		wcs = None,
		crval = None,
		cdelt = None,
		psfSigma = 2.0,
		psfDim = 17,
		calibration = 4,
		visitId = 1234,
		mjd = 60000.0 )

static

Create an Exposure, with a PhotoCalib, Wcs, and Psf, but no pixel values.

Parameters
----------
bbox : `lsst.geom.Box2I` or `lsst.geom.Box2D`
    Bounding box of the image in image coordinates.
wcs : `lsst.afw.geom.SkyWcs`, optional
    New WCS for the exposure (created from CRVAL and CDELT if `None`).
crval : `lsst.afw.geom.SpherePoint`, optional
    ICRS center of the TAN WCS attached to the image. If `None`, (45
    degrees, 45 degrees) is assumed.
cdelt : `lsst.geom.Angle`, optional
    Pixel scale of the image. If `None`, 0.2 arcsec is assumed.
psfSigma : `float`, optional
    Radius (sigma) of the Gaussian PSF attached to the image
psfDim : `int`, optional
    Width and height of the image's Gaussian PSF attached to the image
calibration : `float`, optional
    The spatially-constant calibration (in nJy/count) to set the
    PhotoCalib of the exposure.
visitId : `int`, optional
    Visit id to store in VisitInfo.
mjd : `float`, optional
    Modified Julian Date of this exposure to store in VisitInfo.

Returns
-------
exposure : `lsst.age.image.ExposureF`
    An empty image.

Definition at line 326 of file tests.py.

                          visitId=1234, mjd=60000.0):
        """Create an Exposure, with a PhotoCalib, Wcs, and Psf, but no pixel values.
 
        Parameters
        ----------
        bbox : `lsst.geom.Box2I` or `lsst.geom.Box2D`
            Bounding box of the image in image coordinates.
        wcs : `lsst.afw.geom.SkyWcs`, optional
            New WCS for the exposure (created from CRVAL and CDELT if `None`).
        crval : `lsst.afw.geom.SpherePoint`, optional
            ICRS center of the TAN WCS attached to the image. If `None`, (45
            degrees, 45 degrees) is assumed.
        cdelt : `lsst.geom.Angle`, optional
            Pixel scale of the image. If `None`, 0.2 arcsec is assumed.
        psfSigma : `float`, optional
            Radius (sigma) of the Gaussian PSF attached to the image
        psfDim : `int`, optional
            Width and height of the image's Gaussian PSF attached to the image
        calibration : `float`, optional
            The spatially-constant calibration (in nJy/count) to set the
            PhotoCalib of the exposure.
        visitId : `int`, optional
            Visit id to store in VisitInfo.
        mjd : `float`, optional
            Modified Julian Date of this exposure to store in VisitInfo.
 
        Returns
        -------
        exposure : `lsst.age.image.ExposureF`
            An empty image.
        """
        if wcs is None:
            if crval is None:
                crval = lsst.geom.SpherePoint(45.0, 45.0, lsst.geom.degrees)
            if cdelt is None:
                cdelt = 0.2*lsst.geom.arcseconds
            crpix = lsst.geom.Box2D(bbox).getCenter()
            wcs = lsst.afw.geom.makeSkyWcs(crpix=crpix, crval=crval,
                                           cdMatrix=lsst.afw.geom.makeCdMatrix(scale=cdelt))
        exposure = lsst.afw.image.ExposureF(bbox)
        psf = lsst.afw.detection.GaussianPsf(psfDim, psfDim, psfSigma)
        photoCalib = lsst.afw.image.PhotoCalib(calibration)
        visitInfo = lsst.afw.image.VisitInfo(id=visitId,
                                             exposureTime=30.0,
                                             date=lsst.daf.base.DateTime(mjd),
                                             observatory=lsst.afw.coord.Observatory(11.1*lsst.geom.degrees,
                                                                                    22.2*lsst.geom.degrees,
                                                                                    0.333),
                                             hasSimulatedContent=True)
        exposure.setWcs(wcs)
        exposure.setPsf(psf)
        exposure.setPhotoCalib(photoCalib)
        exposure.info.setVisitInfo(visitInfo)
        return exposure
 

◆ makeMinimalSchema()

lsst.meas.base.tests.TestDataset.makeMinimalSchema ( cls )

Return the minimal schema needed to hold truth catalog fields.

Notes
-----
When `TestDataset.realize` is called, the schema must include at least
these fields.  Usually it will include additional fields for
measurement algorithm outputs, allowing the same catalog to be used
for both truth values (the fields from the minimal schema) and the
measurements.

Definition at line 180 of file tests.py.

    def makeMinimalSchema(cls):
        """Return the minimal schema needed to hold truth catalog fields.
 
        Notes
        -----
        When `TestDataset.realize` is called, the schema must include at least
        these fields.  Usually it will include additional fields for
        measurement algorithm outputs, allowing the same catalog to be used
        for both truth values (the fields from the minimal schema) and the
        measurements.
        """
        if not hasattr(cls, "_schema"):
            schema = lsst.afw.table.SourceTable.makeMinimalSchema()
            cls.keys = {}
            cls.keys["coordErr"] = lsst.afw.table.CoordKey.addErrorFields(schema)
            cls.keys["parent"] = schema.find("parent").key
            cls.keys["nChild"] = schema.addField("deblend_nChild", type=np.int32)
            cls.keys["instFlux"] = schema.addField("truth_instFlux", type=np.float64,
                                                   doc="true instFlux", units="count")
            cls.keys["instFluxErr"] = schema.addField("truth_instFluxErr", type=np.float64,
                                                      doc="true instFluxErr", units="count")
            cls.keys["centroid"] = lsst.afw.table.Point2DKey.addFields(
                schema, "truth", "true simulated centroid", "pixel"
            )
            cls.keys["centroid_sigma"] = lsst.afw.table.CovarianceMatrix2fKey.addFields(
                schema, "truth", ['x', 'y'], "pixel"
            )
            cls.keys["centroid_flag"] = schema.addField("truth_flag", type="Flag",
                                                        doc="set if the object is a star")
            cls.keys["shape"] = lsst.afw.table.QuadrupoleKey.addFields(
                schema, "truth", "true shape after PSF convolution", lsst.afw.table.CoordinateType.PIXEL
            )
            cls.keys["isStar"] = schema.addField("truth_isStar", type="Flag",
                                                 doc="set if the object is a star")
            schema.getAliasMap().set("slot_Shape", "truth")
            schema.getAliasMap().set("slot_Centroid", "truth")
            schema.getAliasMap().set("slot_ModelFlux", "truth")
            cls._schema = schema
        schema = lsst.afw.table.Schema(cls._schema)
        schema.disconnectAliases()
        return schema
 

◆ makePerturbedWcs()

lsst.meas.base.tests.TestDataset.makePerturbedWcs	(	oldWcs,
		minScaleFactor = 1.2,
		maxScaleFactor = 1.5,
		minRotation = None,
		maxRotation = None,
		minRefShift = None,
		maxRefShift = None,
		minPixShift = 2.0,
		maxPixShift = 4.0,
		randomSeed = 1 )

static

Return a perturbed version of the input WCS.

Create a new undistorted TAN WCS that is similar but not identical to
another, with random scaling, rotation, and offset (in both pixel
position and reference position).

Parameters
----------
oldWcs : `lsst.afw.geom.SkyWcs`
    The input WCS.
minScaleFactor : `float`
    Minimum scale factor to apply to the input WCS.
maxScaleFactor : `float`
    Maximum scale factor to apply to the input WCS.
minRotation : `lsst.geom.Angle` or `None`
    Minimum rotation to apply to the input WCS. If `None`, defaults to
    30 degrees.
maxRotation : `lsst.geom.Angle` or `None`
    Minimum rotation to apply to the input WCS. If `None`, defaults to
    60 degrees.
minRefShift : `lsst.geom.Angle` or `None`
    Miniumum shift to apply to the input WCS reference value. If
    `None`, defaults to 0.5 arcsec.
maxRefShift : `lsst.geom.Angle` or `None`
    Miniumum shift to apply to the input WCS reference value. If
    `None`, defaults to 1.0 arcsec.
minPixShift : `float`
    Minimum shift to apply to the input WCS reference pixel.
maxPixShift : `float`
    Maximum shift to apply to the input WCS reference pixel.
randomSeed : `int`
    Random seed.

Returns
-------
newWcs : `lsst.afw.geom.SkyWcs`
    A perturbed version of the input WCS.

Notes
-----
The maximum and minimum arguments are interpreted as absolute values
for a split range that covers both positive and negative values (as
this method is used in testing, it is typically most important to
avoid perturbations near zero). Scale factors are treated somewhat
differently: the actual scale factor is chosen between
``minScaleFactor`` and ``maxScaleFactor`` OR (``1/maxScaleFactor``)
and (``1/minScaleFactor``).

The default range for rotation is 30-60 degrees, and the default range
for reference shift is 0.5-1.0 arcseconds (these cannot be safely
included directly as default values because Angle objects are
mutable).

The random number generator is primed with the seed given. If
`None`, a seed is automatically chosen.

Definition at line 223 of file tests.py.

                         minPixShift=2.0, maxPixShift=4.0, randomSeed=1):
        """Return a perturbed version of the input WCS.
 
        Create a new undistorted TAN WCS that is similar but not identical to
        another, with random scaling, rotation, and offset (in both pixel
        position and reference position).
 
        Parameters
        ----------
        oldWcs : `lsst.afw.geom.SkyWcs`
            The input WCS.
        minScaleFactor : `float`
            Minimum scale factor to apply to the input WCS.
        maxScaleFactor : `float`
            Maximum scale factor to apply to the input WCS.
        minRotation : `lsst.geom.Angle` or `None`
            Minimum rotation to apply to the input WCS. If `None`, defaults to
            30 degrees.
        maxRotation : `lsst.geom.Angle` or `None`
            Minimum rotation to apply to the input WCS. If `None`, defaults to
            60 degrees.
        minRefShift : `lsst.geom.Angle` or `None`
            Miniumum shift to apply to the input WCS reference value. If
            `None`, defaults to 0.5 arcsec.
        maxRefShift : `lsst.geom.Angle` or `None`
            Miniumum shift to apply to the input WCS reference value. If
            `None`, defaults to 1.0 arcsec.
        minPixShift : `float`
            Minimum shift to apply to the input WCS reference pixel.
        maxPixShift : `float`
            Maximum shift to apply to the input WCS reference pixel.
        randomSeed : `int`
            Random seed.
 
        Returns
        -------
        newWcs : `lsst.afw.geom.SkyWcs`
            A perturbed version of the input WCS.
 
        Notes
        -----
        The maximum and minimum arguments are interpreted as absolute values
        for a split range that covers both positive and negative values (as
        this method is used in testing, it is typically most important to
        avoid perturbations near zero). Scale factors are treated somewhat
        differently: the actual scale factor is chosen between
        ``minScaleFactor`` and ``maxScaleFactor`` OR (``1/maxScaleFactor``)
        and (``1/minScaleFactor``).
 
        The default range for rotation is 30-60 degrees, and the default range
        for reference shift is 0.5-1.0 arcseconds (these cannot be safely
        included directly as default values because Angle objects are
        mutable).
 
        The random number generator is primed with the seed given. If
        `None`, a seed is automatically chosen.
        """
        random_state = np.random.RandomState(randomSeed)
        if minRotation is None:
            minRotation = 30.0*lsst.geom.degrees
        if maxRotation is None:
            maxRotation = 60.0*lsst.geom.degrees
        if minRefShift is None:
            minRefShift = 0.5*lsst.geom.arcseconds
        if maxRefShift is None:
            maxRefShift = 1.0*lsst.geom.arcseconds
 
        def splitRandom(min1, max1, min2=None, max2=None):
            if min2 is None:
                min2 = -max1
            if max2 is None:
                max2 = -min1
            if random_state.uniform() > 0.5:
                return float(random_state.uniform(min1, max1))
            else:
                return float(random_state.uniform(min2, max2))
        # Generate random perturbations
        scaleFactor = splitRandom(minScaleFactor, maxScaleFactor, 1.0/maxScaleFactor, 1.0/minScaleFactor)
        rotation = splitRandom(minRotation.asRadians(), maxRotation.asRadians())*lsst.geom.radians
        refShiftRa = splitRandom(minRefShift.asRadians(), maxRefShift.asRadians())*lsst.geom.radians
        refShiftDec = splitRandom(minRefShift.asRadians(), maxRefShift.asRadians())*lsst.geom.radians
        pixShiftX = splitRandom(minPixShift, maxPixShift)
        pixShiftY = splitRandom(minPixShift, maxPixShift)
        # Compute new CD matrix
        oldTransform = lsst.geom.LinearTransform(oldWcs.getCdMatrix())
        rTransform = lsst.geom.LinearTransform.makeRotation(rotation)
        sTransform = lsst.geom.LinearTransform.makeScaling(scaleFactor)
        newTransform = oldTransform*rTransform*sTransform
        matrix = newTransform.getMatrix()
        # Compute new coordinate reference pixel (CRVAL)
        oldSkyOrigin = oldWcs.getSkyOrigin()
        newSkyOrigin = lsst.geom.SpherePoint(oldSkyOrigin.getRa() + refShiftRa,
                                             oldSkyOrigin.getDec() + refShiftDec)
        # Compute new pixel reference pixel (CRPIX)
        oldPixOrigin = oldWcs.getPixelOrigin()
        newPixOrigin = lsst.geom.Point2D(oldPixOrigin.getX() + pixShiftX,
                                         oldPixOrigin.getY() + pixShiftY)
        return lsst.afw.geom.makeSkyWcs(crpix=newPixOrigin, crval=newSkyOrigin, cdMatrix=matrix)
 

◆ realize()

lsst.meas.base.tests.TestDataset.realize	(	self,
		noise,
		schema,
		randomSeed = 1 )

Simulate an exposure and detection catalog for this dataset.

The simulation includes noise, and the detection catalog includes
`~lsst.afw.detection.heavyFootprint.HeavyFootprint`\ s.

Parameters
----------
noise : `float`
Standard deviation of noise to be added to the exposure.  The
noise will be Gaussian and constant, appropriate for the
sky-limited regime.
schema : `lsst.afw.table.Schema`
Schema of the new catalog to be created.  Must start with
``self.schema`` (i.e. ``schema.contains(self.schema)`` must be
`True`), but typically contains fields for already-configured
measurement algorithms as well.
randomSeed : `int`, optional
Seed for the random number generator.
If `None`, a seed is chosen automatically.

Returns
-------
`exposure` : `lsst.afw.image.ExposureF`
Simulated image.
`catalog` : `lsst.afw.table.SourceCatalog`
Simulated detection catalog.

Definition at line 557 of file tests.py.

    def realize(self, noise, schema, randomSeed=1):
        r"""Simulate an exposure and detection catalog for this dataset.
 
        The simulation includes noise, and the detection catalog includes
        `~lsst.afw.detection.heavyFootprint.HeavyFootprint`\ s.
 
        Parameters
        ----------
        noise : `float`
            Standard deviation of noise to be added to the exposure.  The
            noise will be Gaussian and constant, appropriate for the
            sky-limited regime.
        schema : `lsst.afw.table.Schema`
            Schema of the new catalog to be created.  Must start with
            ``self.schema`` (i.e. ``schema.contains(self.schema)`` must be
            `True`), but typically contains fields for already-configured
            measurement algorithms as well.
        randomSeed : `int`, optional
            Seed for the random number generator.
            If `None`, a seed is chosen automatically.
 
        Returns
        -------
        `exposure` : `lsst.afw.image.ExposureF`
            Simulated image.
        `catalog` : `lsst.afw.table.SourceCatalog`
            Simulated detection catalog.
        """
        random_state = np.random.RandomState(randomSeed)
        assert schema.contains(self.schema)
        mapper = lsst.afw.table.SchemaMapper(self.schema)
        mapper.addMinimalSchema(self.schema, True)
        exposure = self.exposure.clone()
        exposure.variance.array[:, :] = noise**2
        exposure.image.array[:, :] += random_state.randn(exposure.height, exposure.width)*noise
        catalog = lsst.afw.table.SourceCatalog(schema)
        catalog.extend(self.catalog, mapper=mapper)
        # Loop over sources and generate new HeavyFootprints that divide up
        # the noisy pixels, not the ideal no-noise pixels.
        for record in catalog:
            # parent objects have non-Heavy Footprints, which don't need to be
            # updated after adding noise.
            if record.getParent() == 0:
                continue
            # get flattened arrays that correspond to the no-noise and noisy
            # parent images
            parent = catalog.find(record.getParent())
            footprint = parent.getFootprint()
            parentFluxArrayNoNoise = np.zeros(footprint.getArea(), dtype=np.float32)
            footprint.spans.flatten(parentFluxArrayNoNoise, self.exposure.image.array, self.exposure.getXY0())
            parentFluxArrayNoisy = np.zeros(footprint.getArea(), dtype=np.float32)
            footprint.spans.flatten(parentFluxArrayNoisy, exposure.image.array, exposure.getXY0())
            oldHeavy = record.getFootprint()
            fraction = (oldHeavy.getImageArray() / parentFluxArrayNoNoise)
            # N.B. this isn't a copy ctor - it's a copy from a vanilla
            # Footprint, so it doesn't copy the arrays we don't want to
            # change, and hence we have to do that ourselves below.
            newHeavy = lsst.afw.detection.HeavyFootprintF(oldHeavy)
            newHeavy.getImageArray()[:] = parentFluxArrayNoisy*fraction
            newHeavy.getMaskArray()[:] = oldHeavy.getMaskArray()
            newHeavy.getVarianceArray()[:] = oldHeavy.getVarianceArray()
            record.setFootprint(newHeavy)
        lsst.afw.table.updateSourceCoords(exposure.wcs, catalog)
        return exposure, catalog
 
 

◆ transform()

lsst.meas.base.tests.TestDataset.transform	(		self,
			wcs,
		**	kwds )

Copy this dataset transformed to a new WCS, with new Psf and PhotoCalib.

Parameters
----------
wcs : `lsst.afw.geom.SkyWcs`
    WCS for the new dataset.
**kwds
    Additional keyword arguments passed on to
    `TestDataset.makeEmptyExposure`.  If not specified, these revert
    to the defaults for `~TestDataset.makeEmptyExposure`, not the
    values in the current dataset.

Returns
-------
newDataset : `TestDataset`
    Transformed copy of this dataset.

Definition at line 508 of file tests.py.

    def transform(self, wcs, **kwds):
        """Copy this dataset transformed to a new WCS, with new Psf and PhotoCalib.
 
        Parameters
        ----------
        wcs : `lsst.afw.geom.SkyWcs`
            WCS for the new dataset.
        **kwds
            Additional keyword arguments passed on to
            `TestDataset.makeEmptyExposure`.  If not specified, these revert
            to the defaults for `~TestDataset.makeEmptyExposure`, not the
            values in the current dataset.
 
        Returns
        -------
        newDataset : `TestDataset`
            Transformed copy of this dataset.
        """
        bboxD = lsst.geom.Box2D()
        xyt = lsst.afw.geom.makeWcsPairTransform(self.exposure.getWcs(), wcs)
        for corner in lsst.geom.Box2D(self.exposure.getBBox()).getCorners():
            bboxD.include(xyt.applyForward(lsst.geom.Point2D(corner)))
        bboxI = lsst.geom.Box2I(bboxD)
        result = TestDataset(bbox=bboxI, wcs=wcs, **kwds)
        oldPhotoCalib = self.exposure.getPhotoCalib()
        newPhotoCalib = result.exposure.getPhotoCalib()
        oldPsfShape = self.exposure.getPsf().computeShape(bboxD.getCenter())
        for record in self.catalog:
            if record.get(self.keys["nChild"]):
                raise NotImplementedError("Transforming blended sources in TestDatasets is not supported")
            magnitude = oldPhotoCalib.instFluxToMagnitude(record.get(self.keys["instFlux"]))
            newFlux = newPhotoCalib.magnitudeToInstFlux(magnitude)
            oldCentroid = record.get(self.keys["centroid"])
            newCentroid = xyt.applyForward(oldCentroid)
            if record.get(self.keys["isStar"]):
                newDeconvolvedShape = None
            else:
                affine = lsst.afw.geom.linearizeTransform(xyt, oldCentroid)
                oldFullShape = record.get(self.keys["shape"])
                oldDeconvolvedShape = lsst.afw.geom.Quadrupole(
                    oldFullShape.getIxx() - oldPsfShape.getIxx(),
                    oldFullShape.getIyy() - oldPsfShape.getIyy(),
                    oldFullShape.getIxy() - oldPsfShape.getIxy(),
                    False
                )
                newDeconvolvedShape = oldDeconvolvedShape.transform(affine.getLinear())
            result.addSource(newFlux, newCentroid, newDeconvolvedShape)
        return result
 

Member Data Documentation

◆ _schema

lsst.meas.base.tests.TestDataset._schema

protected

Definition at line 217 of file tests.py.

◆ catalog

lsst.meas.base.tests.TestDataset.catalog

Definition at line 177 of file tests.py.

◆ exposure

lsst.meas.base.tests.TestDataset.exposure

Definition at line 174 of file tests.py.

◆ keys

lsst.meas.base.tests.TestDataset.keys

Definition at line 193 of file tests.py.

◆ psfShape

lsst.meas.base.tests.TestDataset.psfShape

Definition at line 175 of file tests.py.

◆ schema

lsst.meas.base.tests.TestDataset.schema

Definition at line 176 of file tests.py.

◆ threshold

lsst.meas.base.tests.TestDataset.threshold

Definition at line 173 of file tests.py.

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

/j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/meas_base/g48712c4677+f88676dd22/python/lsst/meas/base/tests.py

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ _installFootprint()

◆ addBlend()

◆ addSource()

◆ drawGaussian()

◆ makeEmptyExposure()

◆ makeMinimalSchema()

◆ makePerturbedWcs()

◆ realize()

◆ transform()

Member Data Documentation

◆ _schema

◆ catalog

◆ exposure

◆ keys

◆ psfShape

◆ schema

◆ threshold

◆ init()