Classes
class	DcrModel

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

def	calculateDcr (visitInfo, wcs, filterInfo, dcrNumSubfilters, splitSubfilters=False)

def	calculateImageParallacticAngle (visitInfo, wcs)

def	wavelengthGenerator (filterInfo, dcrNumSubfilters)

Function Documentation

◆ applyDcr()

def 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 585 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:
         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()

def lsst.ip.diffim.dcrModel.calculateDcr	(	visitInfo,
		wcs,
		filterInfo,
		dcrNumSubfilters,
		splitSubfilters = `False`
	)

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.
filterInfo : `lsst.afw.image.Filter`
    The filter definition, set in the current instruments' obs package.
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

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

Definition at line 649 of file dcrModel.py.

 def calculateDcr(visitInfo, wcs, filterInfo, dcrNumSubfilters, splitSubfilters=False):
     """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.
     filterInfo : `lsst.afw.image.Filter`
         The filter definition, set in the current instruments' obs package.
     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
 
     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]
     lambdaEff = filterInfo.getFilterProperty().getLambdaEff()
     for wl0, wl1 in wavelengthGenerator(filterInfo, dcrNumSubfilters):
         # Note that diffRefractAmp can be negative, since it's relative to the midpoint of the full band
         diffRefractAmp0 = differentialRefraction(wavelength=wl0, wavelengthRef=lambdaEff,
                                                  elevation=visitInfo.getBoresightAzAlt().getLatitude(),
                                                  observatory=visitInfo.getObservatory(),
                                                  weather=visitInfo.getWeather())
         diffRefractAmp1 = differentialRefraction(wavelength=wl1, wavelengthRef=lambdaEff,
                                                  elevation=visitInfo.getBoresightAzAlt().getLatitude(),
                                                  observatory=visitInfo.getObservatory(),
                                                  weather=visitInfo.getWeather())
         if splitSubfilters:
             diffRefractPix0 = diffRefractAmp0.asArcseconds()/wcs.getPixelScale().asArcseconds()
             diffRefractPix1 = diffRefractAmp1.asArcseconds()/wcs.getPixelScale().asArcseconds()
             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()/wcs.getPixelScale().asArcseconds()
             shiftX = diffRefractPix*np.sin(rotation.asRadians())
             shiftY = diffRefractPix*np.cos(rotation.asRadians())
             dcrShift.append((shiftY, shiftX))
     return dcrShift
 
 

◆ calculateImageParallacticAngle()

def 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 703 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()

def lsst.ip.diffim.dcrModel.wavelengthGenerator	(	filterInfo,
		dcrNumSubfilters
	)

Iterate over the wavelength endpoints of subfilters.

Parameters
----------
filterInfo : `lsst.afw.image.Filter`
    The filter definition, set in the current instruments' obs package.
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 nm.

Definition at line 735 of file dcrModel.py.

 def wavelengthGenerator(filterInfo, dcrNumSubfilters):
     """Iterate over the wavelength endpoints of subfilters.
 
     Parameters
     ----------
     filterInfo : `lsst.afw.image.Filter`
         The filter definition, set in the current instruments' obs package.
     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 nm.
     """
     lambdaMin = filterInfo.getFilterProperty().getLambdaMin()
     lambdaMax = filterInfo.getFilterProperty().getLambdaMax()
     wlStep = (lambdaMax - lambdaMin)/dcrNumSubfilters
     for wl in np.linspace(lambdaMin, lambdaMax, dcrNumSubfilters, endpoint=False):
         yield (wl, wl + wlStep)

Classes

Functions

Function Documentation

◆ applyDcr()

◆ calculateDcr()

◆ calculateImageParallacticAngle()

◆ wavelengthGenerator()