1 from __future__
import division, print_function, absolute_import
2 from builtins
import input
3 from builtins
import range
39 """Make a double Gaussian PSF 41 @param[in] fwhm FWHM of double Gaussian smoothing kernel 42 @return measAlg.DoubleGaussianPsf 44 ksize = 4*int(fwhm) + 1
45 return measAlg.DoubleGaussianPsf(ksize, ksize, fwhm/(2*math.sqrt(2*math.log(2))))
48 """Make a transposed copy of a masked image 50 @param[in] maskedImage afw.image.MaskedImage to process 51 @return transposed masked image 53 transposed = maskedImage.Factory(afwGeom.Extent2I(maskedImage.getHeight(), maskedImage.getWidth()))
54 transposed.getImage().getArray()[:] = maskedImage.getImage().getArray().T
55 transposed.getMask().getArray()[:] = maskedImage.getMask().getArray().T
56 transposed.getVariance().getArray()[:] = maskedImage.getVariance().getArray().T
61 """Interpolate over defects specified in a defect list 63 @param[in,out] maskedImage masked image to process 64 @param[in] defectList defect list 65 @param[in] fwhm FWHM of double Gaussian smoothing kernel 66 @param[in] fallbackValue fallback value if an interpolated value cannot be determined; 67 if None then use clipped mean image value 70 if fallbackValue
is None:
71 fallbackValue = afwMath.makeStatistics(maskedImage.getImage(), afwMath.MEANCLIP).getValue()
72 if 'INTRP' not in maskedImage.getMask().getMaskPlaneDict():
73 maskedImage.getMask.addMaskPlane(
'INTRP')
74 measAlg.interpolateOverDefects(maskedImage, psf, defectList, fallbackValue,
True)
78 """Compute a defect list from a footprint list, optionally growing the footprints 80 @param[in] fpList footprint list 84 for bbox
in afwDetection.footprintToBBoxList(fp):
85 defect = measAlg.Defect(bbox)
86 defectList.append(defect)
91 """Make a transposed copy of a defect list 93 @param[in] defectList a list of defects (afw.meas.algorithms.Defect) 94 @return a defect list with transposed defects 97 for defect
in defectList:
98 bbox = defect.getBBox()
99 nbbox = afwGeom.Box2I(afwGeom.Point2I(bbox.getMinY(), bbox.getMinX()),
100 afwGeom.Extent2I(bbox.getDimensions()[1], bbox.getDimensions()[0]))
101 retDefectList.append(measAlg.Defect(nbbox))
106 """Set mask plane based on a defect list 108 @param[in,out] maskedImage afw.image.MaskedImage to process; mask plane is updated 109 @param[in] defectList a list of defects (afw.meas.algorithms.Defect) 110 @param[in] maskName mask plane name 113 mask = maskedImage.getMask()
114 bitmask = mask.getPlaneBitMask(maskName)
115 for defect
in defectList:
116 bbox = defect.getBBox()
117 afwGeom.SpanSet(bbox).clippedTo(mask.getBBox()).setMask(mask, bitmask)
121 """Compute a defect list from a specified mask plane 123 @param[in] maskedImage masked image to process 124 @param[in] maskName mask plane name, or list of names 126 mask = maskedImage.getMask()
127 thresh = afwDetection.Threshold(mask.getPlaneBitMask(maskName), afwDetection.Threshold.BITMASK)
128 fpList = afwDetection.FootprintSet(mask, thresh).getFootprints()
133 """Mask pixels based on threshold detection 135 @param[in,out] maskedImage afw.image.MaskedImage to process; the mask is altered 136 @param[in] threshold detection threshold 137 @param[in] growFootprints amount by which to grow footprints of detected regions 138 @param[in] maskName mask plane name 139 @return a list of defects (meas.algrithms.Defect) of regions set in the mask. 142 thresh = afwDetection.Threshold(threshold)
143 fs = afwDetection.FootprintSet(maskedImage, thresh)
145 if growFootprints > 0:
146 fs = afwDetection.FootprintSet(fs, growFootprints)
148 fpList = fs.getFootprints()
150 mask = maskedImage.getMask()
151 bitmask = mask.getPlaneBitMask(maskName)
152 afwDetection.setMaskFromFootprintList(mask, fpList, bitmask)
158 """Interpolate over defects identified by a particular mask plane 160 @param[in,out] maskedImage afw.image.MaskedImage to process 161 @param[in] fwhm FWHM of double Gaussian smoothing kernel 162 @param[in] growFootprints amount by which to grow footprints of detected regions 163 @param[in] maskName mask plane name 164 @param[in] fallbackValue value of last resort for interpolation 166 mask = maskedImage.getMask()
167 thresh = afwDetection.Threshold(mask.getPlaneBitMask(maskName), afwDetection.Threshold.BITMASK)
168 fpSet = afwDetection.FootprintSet(mask, thresh)
169 if growFootprints > 0:
170 fpSet = afwDetection.FootprintSet(fpSet, rGrow=growFootprints, isotropic=
False)
173 fpSet.setMask(mask, maskName)
178 def saturationCorrection(maskedImage, saturation, fwhm, growFootprints=1, interpolate=True, maskName='SAT',
180 """Mark saturated pixels and optionally interpolate over them 182 @param[in,out] maskedImage afw.image.MaskedImage to process 183 @param[in] saturation saturation level (used as a detection threshold) 184 @param[in] fwhm FWHM of double Gaussian smoothing kernel 185 @param[in] growFootprints amount by which to grow footprints of detected regions 186 @param[in] interpolate interpolate over saturated pixels? 187 @param[in] maskName mask plane name 188 @param[in] fallbackValue value of last resort for interpolation 191 maskedImage=maskedImage,
192 threshold=saturation,
193 growFootprints=growFootprints,
201 """Apply bias correction in place 203 @param[in,out] maskedImage masked image to correct 204 @param[in] biasMaskedImage bias, as a masked image 206 if maskedImage.getBBox(afwImage.LOCAL) != biasMaskedImage.getBBox(afwImage.LOCAL):
207 raise RuntimeError(
"maskedImage bbox %s != biasMaskedImage bbox %s" %
208 (maskedImage.getBBox(afwImage.LOCAL), biasMaskedImage.getBBox(afwImage.LOCAL)))
209 maskedImage -= biasMaskedImage
212 def darkCorrection(maskedImage, darkMaskedImage, expScale, darkScale, invert=False):
213 """Apply dark correction in place 215 maskedImage -= dark * expScaling / darkScaling 217 @param[in,out] maskedImage afw.image.MaskedImage to correct 218 @param[in] darkMaskedImage dark afw.image.MaskedImage 219 @param[in] expScale exposure scale 220 @param[in] darkScale dark scale 221 @param[in] invert if True, remove the dark from an already-corrected image 223 if maskedImage.getBBox(afwImage.LOCAL) != darkMaskedImage.getBBox(afwImage.LOCAL):
224 raise RuntimeError(
"maskedImage bbox %s != darkMaskedImage bbox %s" %
225 (maskedImage.getBBox(afwImage.LOCAL), darkMaskedImage.getBBox(afwImage.LOCAL)))
227 scale = expScale / darkScale
229 maskedImage.scaledMinus(scale, darkMaskedImage)
231 maskedImage.scaledPlus(scale, darkMaskedImage)
235 """Set the variance plane based on the image plane 237 @param[in,out] maskedImage afw.image.MaskedImage; image plane is read and variance plane is written 238 @param[in] gain amplifier gain (e-/ADU) 239 @param[in] readNoise amplifier read noise (ADU/pixel) 241 var = maskedImage.getVariance()
242 var[:] = maskedImage.getImage()
247 def flatCorrection(maskedImage, flatMaskedImage, scalingType, userScale=1.0, invert=False):
248 """Apply flat correction in place 250 @param[in,out] maskedImage afw.image.MaskedImage to correct 251 @param[in] flatMaskedImage flat field afw.image.MaskedImage 252 @param[in] scalingType how to compute flat scale; one of 'MEAN', 'MEDIAN' or 'USER' 253 @param[in] userScale scale to use if scalingType is 'USER', else ignored 254 @param[in] invert if True, unflatten an already-flattened image instead. 256 if maskedImage.getBBox(afwImage.LOCAL) != flatMaskedImage.getBBox(afwImage.LOCAL):
257 raise RuntimeError(
"maskedImage bbox %s != flatMaskedImage bbox %s" %
258 (maskedImage.getBBox(afwImage.LOCAL), flatMaskedImage.getBBox(afwImage.LOCAL)))
263 if scalingType ==
'MEAN':
264 flatScale = afwMath.makeStatistics(flatMaskedImage.getImage(), afwMath.MEAN).getValue(afwMath.MEAN)
265 elif scalingType ==
'MEDIAN':
266 flatScale = afwMath.makeStatistics(flatMaskedImage.getImage(),
267 afwMath.MEDIAN).getValue(afwMath.MEDIAN)
268 elif scalingType ==
'USER':
269 flatScale = userScale
271 raise pexExcept.Exception(
'%s : %s not implemented' % (
"flatCorrection", scalingType))
274 maskedImage.scaledDivides(1.0/flatScale, flatMaskedImage)
276 maskedImage.scaledMultiplies(1.0/flatScale, flatMaskedImage)
280 """Apply illumination correction in place 282 @param[in,out] maskedImage afw.image.MaskedImage to correct 283 @param[in] illumMaskedImage illumination correction masked image 284 @param[in] illumScale scale value for illumination correction 286 if maskedImage.getBBox(afwImage.LOCAL) != illumMaskedImage.getBBox(afwImage.LOCAL):
287 raise RuntimeError(
"maskedImage bbox %s != illumMaskedImage bbox %s" %
288 (maskedImage.getBBox(afwImage.LOCAL), illumMaskedImage.getBBox(afwImage.LOCAL)))
290 maskedImage.scaledDivides(1./illumScale, illumMaskedImage)
293 def overscanCorrection(ampMaskedImage, overscanImage, fitType='MEDIAN', order=1, collapseRej=3.0,
295 """Apply overscan correction in place 297 @param[in,out] ampMaskedImage masked image to correct 298 @param[in] overscanImage overscan data as an afw.image.Image or afw.image.MaskedImage. 299 If a masked image is passed in the mask plane will be used 300 to constrain the fit of the bias level. 301 @param[in] fitType type of fit for overscan correction; one of: 304 - 'POLY' (ordinary polynomial) 305 - 'CHEB' (Chebyshev polynomial) 306 - 'LEG' (Legendre polynomial) 307 - 'NATURAL_SPLINE', 'CUBIC_SPLINE', 'AKIMA_SPLINE' (splines) 308 @param[in] order polynomial order or spline knots (ignored unless fitType 309 indicates a polynomial or spline) 310 @param[in] collapseRej Rejection threshold (sigma) for collapsing dimension of overscan 311 @param[in] statControl Statistics control object 313 ampImage = ampMaskedImage.getImage()
314 if statControl
is None:
315 statControl = afwMath.StatisticsControl()
316 if fitType ==
'MEAN':
317 offImage = afwMath.makeStatistics(overscanImage, afwMath.MEAN, statControl).getValue(afwMath.MEAN)
318 elif fitType ==
'MEDIAN':
319 offImage = afwMath.makeStatistics(overscanImage, afwMath.MEDIAN, statControl).getValue(afwMath.MEDIAN)
320 elif fitType
in (
'POLY',
'CHEB',
'LEG',
'NATURAL_SPLINE',
'CUBIC_SPLINE',
'AKIMA_SPLINE'):
321 if hasattr(overscanImage,
"getImage"):
322 biasArray = overscanImage.getImage().getArray()
323 biasArray = numpy.ma.masked_where(overscanImage.getMask().getArray() & statControl.getAndMask(),
326 biasArray = overscanImage.getArray()
328 shortInd = numpy.argmin(biasArray.shape)
331 biasArray = numpy.transpose(biasArray)
334 percentiles = numpy.percentile(biasArray, [25.0, 50.0, 75.0], axis=1)
335 medianBiasArr = percentiles[1]
336 stdevBiasArr = 0.74*(percentiles[2] - percentiles[0])
337 diff = numpy.abs(biasArray - medianBiasArr[:, numpy.newaxis])
338 biasMaskedArr = numpy.ma.masked_where(diff > collapseRej*stdevBiasArr[:, numpy.newaxis], biasArray)
339 collapsed = numpy.mean(biasMaskedArr, axis=1)
340 if collapsed.mask.sum() > 0:
341 collapsed.data[collapsed.mask] = numpy.mean(biasArray.data[collapsed.mask], axis=1)
342 del biasArray, percentiles, stdevBiasArr, diff, biasMaskedArr
345 collapsed = numpy.transpose(collapsed)
348 indices = 2.0*numpy.arange(num)/float(num) - 1.0
350 if fitType
in (
'POLY',
'CHEB',
'LEG'):
352 poly = numpy.polynomial
353 fitter, evaler = {
"POLY": (poly.polynomial.polyfit, poly.polynomial.polyval),
354 "CHEB": (poly.chebyshev.chebfit, poly.chebyshev.chebval),
355 "LEG": (poly.legendre.legfit, poly.legendre.legval),
358 coeffs = fitter(indices, collapsed, order)
359 fitBiasArr = evaler(indices, coeffs)
360 elif 'SPLINE' in fitType:
369 collapsedMask = collapsed.mask
371 if collapsedMask == numpy.ma.nomask:
372 collapsedMask = numpy.array(len(collapsed)*[numpy.ma.nomask])
376 numPerBin, binEdges = numpy.histogram(indices, bins=numBins,
377 weights=1-collapsedMask.astype(int))
380 values = numpy.histogram(indices, bins=numBins,
381 weights=collapsed.data*~collapsedMask)[0]/numPerBin
382 binCenters = numpy.histogram(indices, bins=numBins,
383 weights=indices*~collapsedMask)[0]/numPerBin
384 interp = afwMath.makeInterpolate(binCenters.astype(float)[numPerBin > 0],
385 values.astype(float)[numPerBin > 0],
386 afwMath.stringToInterpStyle(fitType))
387 fitBiasArr = numpy.array([interp.interpolate(i)
for i
in indices])
391 import matplotlib.pyplot
as plot
392 figure = plot.figure(1)
394 axes = figure.add_axes((0.1, 0.1, 0.8, 0.8))
395 axes.plot(indices[~collapsedMask], collapsed[~collapsedMask],
'k+')
396 if collapsedMask.sum() > 0:
397 axes.plot(indices[collapsedMask], collapsed.data[collapsedMask],
'b+')
398 axes.plot(indices, fitBiasArr,
'r-')
400 prompt =
"Press Enter or c to continue [chp]... " 402 ans = input(prompt).lower()
403 if ans
in (
"",
"c",):
409 print(
"h[elp] c[ontinue] p[db]")
412 offImage = ampImage.Factory(ampImage.getDimensions())
413 offArray = offImage.getArray()
415 offArray[:, :] = fitBiasArr[:, numpy.newaxis]
417 offArray[:, :] = fitBiasArr[numpy.newaxis, :]
425 mask = ampMaskedImage.getMask()
426 maskArray = mask.getArray()
if shortInd == 1
else mask.getArray().transpose()
427 suspect = mask.getPlaneBitMask(
"SUSPECT")
429 if collapsed.mask == numpy.ma.nomask:
433 for low
in range(num):
434 if not collapsed.mask[low]:
437 maskArray[:low, :] |= suspect
438 for high
in range(1, num):
439 if not collapsed.mask[-high]:
442 maskArray[-high:, :] |= suspect
445 raise pexExcept.Exception(
'%s : %s an invalid overscan type' % \
446 (
"overscanCorrection", fitType))
451 sensorTransmission=None, atmosphereTransmission=None):
452 """Attach a TransmissionCurve to an Exposure, given separate curves for 453 different components. 457 exposure : `lsst.afw.image.Exposure` 458 Exposure object to modify by attaching the product of all given 459 ``TransmissionCurves`` in post-assembly trimmed detector coordinates. 460 Must have a valid ``Detector`` attached that matches the detector 461 associated with sensorTransmission. 462 opticsTransmission : `lsst.afw.image.TransmissionCurve` 463 A ``TransmissionCurve`` that represents the throughput of the optics, 464 to be evaluated in focal-plane coordinates. 465 filterTransmission : `lsst.afw.image.TransmissionCurve` 466 A ``TransmissionCurve`` that represents the throughput of the filter 467 itself, to be evaluated in focal-plane coordinates. 468 sensorTransmission : `lsst.afw.image.TransmissionCurve` 469 A ``TransmissionCurve`` that represents the throughput of the sensor 470 itself, to be evaluated in post-assembly trimmed detector coordinates. 471 atmosphereTransmission : `lsst.afw.image.TransmissionCurve` 472 A ``TransmissionCurve`` that represents the throughput of the 473 atmosphere, assumed to be spatially constant. 475 All ``TransmissionCurve`` arguments are optional; if none are provided, the 476 attached ``TransmissionCurve`` will have unit transmission everywhere. 480 combined : ``lsst.afw.image.TransmissionCurve`` 481 The TransmissionCurve attached to the exposure. 483 combined = afwImage.TransmissionCurve.makeIdentity()
484 if atmosphereTransmission
is not None:
485 combined *= atmosphereTransmission
486 if opticsTransmission
is not None:
487 combined *= opticsTransmission
488 if filterTransmission
is not None:
489 combined *= filterTransmission
490 detector = exposure.getDetector()
491 fpToPix = detector.getTransform(fromSys=camGeom.FOCAL_PLANE,
492 toSys=camGeom.PIXELS)
493 combined = combined.transformedBy(fpToPix)
494 if sensorTransmission
is not None:
495 combined *= sensorTransmission
496 exposure.getInfo().setTransmissionCurve(combined)
def darkCorrection(maskedImage, darkMaskedImage, expScale, darkScale, invert=False)
def illuminationCorrection(maskedImage, illumMaskedImage, illumScale)
def saturationCorrection(maskedImage, saturation, fwhm, growFootprints=1, interpolate=True, maskName='SAT', fallbackValue=None)
def transposeDefectList(defectList)
def getDefectListFromMask(maskedImage, maskName)
def interpolateDefectList(maskedImage, defectList, fwhm, fallbackValue=None)
def defectListFromFootprintList(fpList)
def transposeMaskedImage(maskedImage)
def biasCorrection(maskedImage, biasMaskedImage)
def interpolateFromMask(maskedImage, fwhm, growFootprints=1, maskName='SAT', fallbackValue=None)
def attachTransmissionCurve(exposure, opticsTransmission=None, filterTransmission=None, sensorTransmission=None, atmosphereTransmission=None)
def makeThresholdMask(maskedImage, threshold, growFootprints=1, maskName='SAT')
def overscanCorrection(ampMaskedImage, overscanImage, fitType='MEDIAN', order=1, collapseRej=3.0, statControl=None)
def flatCorrection(maskedImage, flatMaskedImage, scalingType, userScale=1.0, invert=False)
def updateVariance(maskedImage, gain, readNoise)
def maskPixelsFromDefectList(maskedImage, defectList, maskName='BAD')