Classes
class	DcrModel

Functions
	applyDcr (image, dcr, useInverse=False, splitSubfilters=False, splitThreshold=0., doPrefilter=True, order=3)

	calculateDcr (visitInfo, wcs, effectiveWavelength, bandwidth, dcrNumSubfilters, splitSubfilters=False, bbox=None)

	calculateImageParallacticAngle (visitInfo, wcs)

	wavelengthGenerator (effectiveWavelength, bandwidth, dcrNumSubfilters)

Function Documentation

◆ applyDcr()

lsst.ip.diffim.dcrModel.applyDcr	(	image,
		dcr,
		useInverse = False,
		splitSubfilters = False,
		splitThreshold = 0.,
		doPrefilter = True,
		order = 3 )

Shift an image along the X and Y directions.

Parameters
----------
image : `numpy.ndarray`
    The input image to shift.
dcr : `tuple`
    Shift calculated with ``calculateDcr``.
    Uses numpy axes ordering (Y, X).
    If ``splitSubfilters`` is set, each element is itself a `tuple`
    of two `float`, corresponding to the DCR shift at the two wavelengths.
    Otherwise, each element is a `float` corresponding to the DCR shift at
    the effective wavelength of the subfilter.
useInverse : `bool`, optional
    Apply the shift in the opposite direction. Default: False
splitSubfilters : `bool`, optional
    Calculate DCR for two evenly-spaced wavelengths in each subfilter,
    instead of at the midpoint. Default: False
splitThreshold : `float`, optional
    Minimum DCR difference within a subfilter required to use
    ``splitSubfilters``
doPrefilter : `bool`, optional
    Spline filter the image before shifting, if set. Filtering is required,
    so only set to False if the image is already filtered.
    Filtering takes ~20% of the time of shifting, so if `applyDcr` will be
    called repeatedly on the same image it is more efficient to
    precalculate the filter.
order : `int`, optional
    The order of the spline interpolation, default is 3.

Returns
-------
shiftedImage : `numpy.ndarray`
    A copy of the input image with the specified shift applied.

Definition at line 666 of file dcrModel.py.

             doPrefilter=True, order=3):
    """Shift an image along the X and Y directions.
 
    Parameters
    ----------
    image : `numpy.ndarray`
        The input image to shift.
    dcr : `tuple`
        Shift calculated with ``calculateDcr``.
        Uses numpy axes ordering (Y, X).
        If ``splitSubfilters`` is set, each element is itself a `tuple`
        of two `float`, corresponding to the DCR shift at the two wavelengths.
        Otherwise, each element is a `float` corresponding to the DCR shift at
        the effective wavelength of the subfilter.
    useInverse : `bool`, optional
        Apply the shift in the opposite direction. Default: False
    splitSubfilters : `bool`, optional
        Calculate DCR for two evenly-spaced wavelengths in each subfilter,
        instead of at the midpoint. Default: False
    splitThreshold : `float`, optional
        Minimum DCR difference within a subfilter required to use
        ``splitSubfilters``
    doPrefilter : `bool`, optional
        Spline filter the image before shifting, if set. Filtering is required,
        so only set to False if the image is already filtered.
        Filtering takes ~20% of the time of shifting, so if `applyDcr` will be
        called repeatedly on the same image it is more efficient to
        precalculate the filter.
    order : `int`, optional
        The order of the spline interpolation, default is 3.
 
    Returns
    -------
    shiftedImage : `numpy.ndarray`
        A copy of the input image with the specified shift applied.
    """
    if doPrefilter and order > 1:
        prefilteredImage = ndimage.spline_filter(image, order=order)
    else:
        prefilteredImage = image
    if splitSubfilters:
        shiftAmp = np.max(np.abs([_dcr0 - _dcr1 for _dcr0, _dcr1 in zip(dcr[0], dcr[1])]))
        if shiftAmp >= splitThreshold:
            if useInverse:
                shift = [-1.*s for s in dcr[0]]
                shift1 = [-1.*s for s in dcr[1]]
            else:
                shift = dcr[0]
                shift1 = dcr[1]
            shiftedImage = ndimage.shift(prefilteredImage, shift, prefilter=False, order=order)
            shiftedImage += ndimage.shift(prefilteredImage, shift1, prefilter=False, order=order)
            shiftedImage /= 2.
            return shiftedImage
        else:
            # If the difference in the DCR shifts is less than the threshold,
            # then just use the average shift for efficiency.
            dcr = (np.mean(dcr[0]), np.mean(dcr[1]))
    if useInverse:
        shift = [-1.*s for s in dcr]
    else:
        shift = dcr
    shiftedImage = ndimage.shift(prefilteredImage, shift, prefilter=False, order=order)
    return shiftedImage
 
 

◆ calculateDcr()

lsst.ip.diffim.dcrModel.calculateDcr	(	visitInfo,
		wcs,
		effectiveWavelength,
		bandwidth,
		dcrNumSubfilters,
		splitSubfilters = False,
		bbox = None )

Calculate the shift in pixels of an exposure due to DCR.

Parameters
----------
visitInfo : `lsst.afw.image.VisitInfo`
    Metadata for the exposure.
wcs : `lsst.afw.geom.SkyWcs`
    Coordinate system definition (wcs) for the exposure.
effectiveWavelength : `float`
    The effective wavelengths of the current filter, in nanometers.
bandwidth : `float`
    The bandwidth of the current filter, in nanometers.
dcrNumSubfilters : `int`
    Number of sub-filters used to model chromatic effects within a band.
splitSubfilters : `bool`, optional
    Calculate DCR for two evenly-spaced wavelengths in each subfilter,
    instead of at the midpoint. Default: False
bbox : `lsst.afw.geom.Box2I`, optional
    Bounding box for the region of interest for evaluating the local
    pixelScale (defaults to the Sky Origin of the ``wcs`` provided if
    ``bbox`` is None).

Returns
-------
dcrShift : `tuple` of two `float`
    The 2D shift due to DCR, in pixels.
    Uses numpy axes ordering (Y, X).

Definition at line 732 of file dcrModel.py.

                 bbox=None):
    """Calculate the shift in pixels of an exposure due to DCR.
 
    Parameters
    ----------
    visitInfo : `lsst.afw.image.VisitInfo`
        Metadata for the exposure.
    wcs : `lsst.afw.geom.SkyWcs`
        Coordinate system definition (wcs) for the exposure.
    effectiveWavelength : `float`
        The effective wavelengths of the current filter, in nanometers.
    bandwidth : `float`
        The bandwidth of the current filter, in nanometers.
    dcrNumSubfilters : `int`
        Number of sub-filters used to model chromatic effects within a band.
    splitSubfilters : `bool`, optional
        Calculate DCR for two evenly-spaced wavelengths in each subfilter,
        instead of at the midpoint. Default: False
    bbox : `lsst.afw.geom.Box2I`, optional
        Bounding box for the region of interest for evaluating the local
        pixelScale (defaults to the Sky Origin of the ``wcs`` provided if
        ``bbox`` is None).
 
    Returns
    -------
    dcrShift : `tuple` of two `float`
        The 2D shift due to DCR, in pixels.
        Uses numpy axes ordering (Y, X).
    """
    rotation = calculateImageParallacticAngle(visitInfo, wcs)
    dcrShift = []
    weight = [0.75, 0.25]
    for wl0, wl1 in wavelengthGenerator(effectiveWavelength, bandwidth, dcrNumSubfilters):
        # Note that diffRefractAmp can be negative, since it's relative to the
        # midpoint of the full band
        diffRefractAmp0 = differentialRefraction(wavelength=wl0, wavelengthRef=effectiveWavelength,
                                                 elevation=visitInfo.getBoresightAzAlt().getLatitude(),
                                                 observatory=visitInfo.getObservatory(),
                                                 weather=visitInfo.getWeather())
        diffRefractAmp1 = differentialRefraction(wavelength=wl1, wavelengthRef=effectiveWavelength,
                                                 elevation=visitInfo.getBoresightAzAlt().getLatitude(),
                                                 observatory=visitInfo.getObservatory(),
                                                 weather=visitInfo.getWeather())
        if bbox is not None:
            pixelScale = wcs.getPixelScale(bbox.getCenter()).asArcseconds()
        else:
            pixelScale = wcs.getPixelScale().asArcseconds()
 
        if splitSubfilters:
            diffRefractPix0 = diffRefractAmp0.asArcseconds()/pixelScale
            diffRefractPix1 = diffRefractAmp1.asArcseconds()/pixelScale
            diffRefractArr = [diffRefractPix0*weight[0] + diffRefractPix1*weight[1],
                              diffRefractPix0*weight[1] + diffRefractPix1*weight[0]]
            shiftX = [diffRefractPix*np.sin(rotation.asRadians()) for diffRefractPix in diffRefractArr]
            shiftY = [diffRefractPix*np.cos(rotation.asRadians()) for diffRefractPix in diffRefractArr]
            dcrShift.append(((shiftY[0], shiftX[0]), (shiftY[1], shiftX[1])))
        else:
            diffRefractAmp = (diffRefractAmp0 + diffRefractAmp1)/2.
            diffRefractPix = diffRefractAmp.asArcseconds()/pixelScale
            shiftX = diffRefractPix*np.sin(rotation.asRadians())
            shiftY = diffRefractPix*np.cos(rotation.asRadians())
            dcrShift.append((shiftY, shiftX))
    return dcrShift
 
 

◆ calculateImageParallacticAngle()

lsst.ip.diffim.dcrModel.calculateImageParallacticAngle	(		visitInfo,
			wcs )

Calculate the total sky rotation angle of an exposure.

Parameters
----------
visitInfo : `lsst.afw.image.VisitInfo`
    Metadata for the exposure.
wcs : `lsst.afw.geom.SkyWcs`
    Coordinate system definition (wcs) for the exposure.

Returns
-------
`lsst.geom.Angle`
    The rotation of the image axis, East from North.
    Equal to the parallactic angle plus any additional rotation of the
    coordinate system.
    A rotation angle of 0 degrees is defined with
    North along the +y axis and East along the +x axis.
    A rotation angle of 90 degrees is defined with
    North along the +x axis and East along the -y axis.

Definition at line 798 of file dcrModel.py.

def calculateImageParallacticAngle(visitInfo, wcs):
    """Calculate the total sky rotation angle of an exposure.
 
    Parameters
    ----------
    visitInfo : `lsst.afw.image.VisitInfo`
        Metadata for the exposure.
    wcs : `lsst.afw.geom.SkyWcs`
        Coordinate system definition (wcs) for the exposure.
 
    Returns
    -------
    `lsst.geom.Angle`
        The rotation of the image axis, East from North.
        Equal to the parallactic angle plus any additional rotation of the
        coordinate system.
        A rotation angle of 0 degrees is defined with
        North along the +y axis and East along the +x axis.
        A rotation angle of 90 degrees is defined with
        North along the +x axis and East along the -y axis.
    """
    parAngle = visitInfo.getBoresightParAngle().asRadians()
    cd = wcs.getCdMatrix()
    if wcs.isFlipped:
        cdAngle = (np.arctan2(-cd[0, 1], cd[0, 0]) + np.arctan2(cd[1, 0], cd[1, 1]))/2.
        rotAngle = (cdAngle + parAngle)*geom.radians
    else:
        cdAngle = (np.arctan2(cd[0, 1], -cd[0, 0]) + np.arctan2(cd[1, 0], cd[1, 1]))/2.
        rotAngle = (cdAngle - parAngle)*geom.radians
    return rotAngle
 
 

◆ wavelengthGenerator()

lsst.ip.diffim.dcrModel.wavelengthGenerator	(	effectiveWavelength,
		bandwidth,
		dcrNumSubfilters )

Iterate over the wavelength endpoints of subfilters.

Parameters
----------
effectiveWavelength : `float`
    The effective wavelength of the current filter, in nanometers.
bandwidth : `float`
    The bandwidth of the current filter, in nanometers.
dcrNumSubfilters : `int`
    Number of sub-filters used to model chromatic effects within a band.

Yields
------
`tuple` of two `float`
    The next set of wavelength endpoints for a subfilter, in nanometers.

Definition at line 830 of file dcrModel.py.

def wavelengthGenerator(effectiveWavelength, bandwidth, dcrNumSubfilters):
    """Iterate over the wavelength endpoints of subfilters.
 
    Parameters
    ----------
    effectiveWavelength : `float`
        The effective wavelength of the current filter, in nanometers.
    bandwidth : `float`
        The bandwidth of the current filter, in nanometers.
    dcrNumSubfilters : `int`
        Number of sub-filters used to model chromatic effects within a band.
 
    Yields
    ------
    `tuple` of two `float`
        The next set of wavelength endpoints for a subfilter, in nanometers.
    """
    lambdaMin = effectiveWavelength - bandwidth/2
    lambdaMax = effectiveWavelength + bandwidth/2
    wlStep = bandwidth/dcrNumSubfilters
    for wl in np.linspace(lambdaMin, lambdaMax, dcrNumSubfilters, endpoint=False):
        yield (wl, wl + wlStep)

Classes

Functions

Function Documentation

◆ applyDcr()

◆ calculateDcr()

◆ calculateImageParallacticAngle()

◆ wavelengthGenerator()