def testBasics(self):
"""!Test basic functionality of LinearizeSquared
"""
for imageClass in (afwImage.ImageF, afwImage.ImageD):
inImage = makeRampImage(bbox=self.bbox,
start=-5,
stop=2500,
imageClass=imageClass)
measImage = inImage.Factory(inImage, True)
linSq = LinearizeSquared()
linRes = linSq(image=measImage, detector=self.detector)
desNumLinearized = np.sum(self.sqCoeffs.flatten() > 0)
self.assertEqual(linRes.numLinearized, desNumLinearized)
self.assertEqual(linRes.numAmps,
len(self.detector.getAmpInfoCatalog()))
refImage = inImage.Factory(inImage, True)
refLinearizeSquared(image=refImage, detector=self.detector)
self.assertImagesAlmostEqual(refImage, measImage)
# make sure logging is accepted
log = Log.getLogger("ip.isr.LinearizeSquared")
linRes = linSq(image=measImage, detector=self.detector, log=log)
def testBasics(self):
"""!Test basic functionality of LinearizeLookupTable
"""
for imageClass in (afwImage.ImageF, afwImage.ImageD):
inImage = makeRampImage(bbox=self.bbox,
start=-5,
stop=250,
imageClass=imageClass)
table = self.makeTable(inImage)
log = logging.getLogger("lsst.ip.isr.LinearizeLookupTable")
measImage = inImage.Factory(inImage, True)
llt = Linearizer(table=table, detector=self.detector)
linRes = llt.applyLinearity(measImage,
detector=self.detector,
log=log)
refImage = inImage.Factory(inImage, True)
refNumOutOfRange = refLinearize(image=refImage,
detector=self.detector,
table=table)
self.assertEqual(linRes.numAmps,
len(self.detector.getAmplifiers()))
self.assertEqual(linRes.numAmps, linRes.numLinearized)
self.assertEqual(linRes.numOutOfRange, refNumOutOfRange)
self.assertImagesAlmostEqual(refImage, measImage)
# make sure logging is accepted
log = logging.getLogger("lsst.ip.isr.LinearizeLookupTable")
linRes = llt.applyLinearity(image=measImage,
detector=self.detector,
log=log)
def testErrorHandling(self):
"""!Test error handling in LinearizeLookupTable
"""
image = makeRampImage(bbox=self.bbox, start=-5, stop=250)
table = self.makeTable(image)
llt = LinearizeLookupTable(table=table, detector=self.detector)
# bad name
detBadName = self.makeDetector(detName="bad_detector_name")
with self.assertRaises(RuntimeError):
llt(image, detBadName)
# bad serial
detBadSerial = self.makeDetector(detSerial="bad_detector_serial")
with self.assertRaises(RuntimeError):
llt(image, detBadSerial)
# bad number of amplifiers
badNumAmps = (self.numAmps[0]-1, self.numAmps[1])
detBadNumMaps = self.makeDetector(numAmps=badNumAmps)
with self.assertRaises(RuntimeError):
llt(image, detBadNumMaps)
# bad linearity type
detBadLinType = self.makeDetector(linearityType="bad_linearity_type")
with self.assertRaises(RuntimeError):
llt(image, detBadLinType)
def testBasics(self):
"""!Test basic functionality of applyLookupTable
"""
bbox = afwGeom.Box2I(afwGeom.Point2I(-31, 22),
afwGeom.Extent2I(100, 85))
imMin = -5
imMax = 2500
tableLen = 2000
tableSigma = 55
for indOffset in (0, -50, 234):
for imageClass in (afwImage.ImageF, afwImage.ImageD):
inImage = makeRampImage(bbox=bbox,
start=imMin,
stop=imMax,
imageClass=imageClass)
table = np.random.normal(scale=tableSigma, size=tableLen)
table = np.array(table, dtype=inImage.getArray().dtype)
refImage = imageClass(inImage, True)
refNumBad = referenceApply(image=refImage,
table=table,
indOffset=indOffset)
measImage = imageClass(inImage, True)
measNumBad = applyLookupTable(measImage, table, indOffset)
self.assertEqual(refNumBad, measNumBad)
self.assertImagesAlmostEqual(refImage, measImage)
def testErrorHandling(self):
"""!Test error handling in LinearizeLookupTable
"""
image = makeRampImage(bbox=self.bbox, start=-5, stop=250)
table = self.makeTable(image)
llt = LinearizeLookupTable(table=table, detector=self.detector)
# bad name
detBadName = self.makeDetector(detName="bad_detector_name")
with self.assertRaises(RuntimeError):
llt(image, detBadName)
# bad serial
detBadSerial = self.makeDetector(detSerial="bad_detector_serial")
with self.assertRaises(RuntimeError):
llt(image, detBadSerial)
# bad number of amplifiers
badNumAmps = (self.numAmps[0] - 1, self.numAmps[1])
detBadNumMaps = self.makeDetector(numAmps=badNumAmps)
with self.assertRaises(RuntimeError):
llt(image, detBadNumMaps)
# bad linearity type
detBadLinType = self.makeDetector(linearityType="bad_linearity_type")
with self.assertRaises(RuntimeError):
llt(image, detBadLinType)
def makeRampDecoratedImage(bbox, start, **metadataDict):
"""Make a DecoratedImageU that is a ramp."""
rampArr = makeRampImage(bbox=bbox, start=start, imageClass=afwImage.ImageU).getArray()
decoratedImage = afwImage.DecoratedImageU(bbox)
imarr = decoratedImage.getImage().getArray()
imarr[:] = rampArr
md = decoratedImage.getMetadata()
for (key, val) in metadataDict.items():
md.set(key, val)
return decoratedImage
def makeRampDecoratedImage(bbox, start, **metadataDict):
"""Make a DecoratedImageU that is a ramp."""
rampArr = makeRampImage(bbox=bbox, start=start,
imageClass=afwImage.ImageU).getArray()
decoratedImage = afwImage.DecoratedImageU(bbox)
imarr = decoratedImage.getImage().getArray()
imarr[:] = rampArr
md = decoratedImage.getMetadata()
for (key, val) in metadataDict.items():
md.set(key, val)
return decoratedImage
def testNonUnitIntervals(self):
"""!Test a small ramp image with non-integer increments
"""
for imageClass in (afwImage.ImageU, afwImage.ImageF, afwImage.ImageD):
dim = afwGeom.Extent2I(7, 9)
box = afwGeom.Box2I(afwGeom.Point2I(-1, 3), dim)
numPix = dim[0]*dim[1]
for start in (-5.1, 0, 4.3):
if imageClass == afwImage.ImageU and start < 0:
continue
for stop in (7, 1001.5, 5.4):
rampImage = makeRampImage(bbox=box, start=start, stop=stop, imageClass=imageClass)
dtype = rampImage.getArray().dtype
predArr = np.linspace(start, stop, num=numPix, endpoint=True, dtype=dtype)
predArr.shape = (dim[1], dim[0])
self.assertImagesNearlyEqual(rampImage, predArr)
def testUnitInterval(self):
"""!Test small ramp images with unit interval for known values
"""
for imageClass in (afwImage.ImageU, afwImage.ImageF, afwImage.ImageD):
dim = afwGeom.Extent2I(7, 9)
box = afwGeom.Box2I(afwGeom.Point2I(-1, 3), dim)
numPix = dim[0]*dim[1]
for start in (-5, 0, 4):
if imageClass == afwImage.ImageU and start < 0:
continue
predStop = start + numPix - 1 # for integer steps
for stop in (None, predStop):
rampImage = makeRampImage(bbox=box, start=start, stop=predStop, imageClass=imageClass)
predArr = np.arange(start, predStop+1)
self.assertEqual(len(predArr), numPix)
predArr.shape = (dim[1], dim[0])
self.assertImagesNearlyEqual(rampImage, predArr)
def testPickle(self):
"""!Test that a LinearizeSquared can be pickled and unpickled
"""
inImage = makeRampImage(bbox=self.bbox, start=-5, stop=2500)
linSq = LinearizeSquared()
refImage = inImage.Factory(inImage, True)
refNumOutOfRange = linSq(refImage, self.detector)
pickledStr = pickle.dumps(linSq)
restoredLlt = pickle.loads(pickledStr)
measImage = inImage.Factory(inImage, True)
measNumOutOfRange = restoredLlt(measImage, self.detector)
self.assertEqual(refNumOutOfRange, measNumOutOfRange)
self.assertImagesAlmostEqual(refImage, measImage)
def testPickle(self):
"""!Test that a LinearizeSquared can be pickled and unpickled
"""
inImage = makeRampImage(bbox=self.bbox, start=-5, stop=2500)
linSq = LinearizeSquared()
refImage = inImage.Factory(inImage, True)
refNumOutOfRange = linSq(refImage, self.detector)
pickledStr = pickle.dumps(linSq)
restoredLlt = pickle.loads(pickledStr)
measImage = inImage.Factory(inImage, True)
measNumOutOfRange = restoredLlt(measImage, self.detector)
self.assertEqual(refNumOutOfRange, measNumOutOfRange)
self.assertImagesAlmostEqual(refImage, measImage)
def testPickle(self):
"""!Test that a LinearizeLookupTable can be pickled and unpickled
"""
inImage = makeRampImage(bbox=self.bbox, start=-5, stop=2500)
table = self.makeTable(inImage)
llt = LinearizeLookupTable(table=table, detector=self.detector)
refImage = inImage.Factory(inImage, True)
refNumOutOfRange = llt(refImage, self.detector)
pickledStr = pickle.dumps(llt)
restoredLlt = pickle.loads(pickledStr)
measImage = inImage.Factory(inImage, True)
measNumOutOfRange = restoredLlt(measImage, self.detector)
self.assertEqual(refNumOutOfRange, measNumOutOfRange)
self.assertImagesAlmostEqual(refImage, measImage)
def testPickle(self):
"""!Test that a LinearizeLookupTable can be pickled and unpickled
"""
inImage = makeRampImage(bbox=self.bbox, start=-5, stop=2500)
table = self.makeTable(inImage)
llt = LinearizeLookupTable(table=table, detector=self.detector)
refImage = inImage.Factory(inImage, True)
refNumOutOfRange = llt(refImage, self.detector)
pickledStr = pickle.dumps(llt)
restoredLlt = pickle.loads(pickledStr)
measImage = inImage.Factory(inImage, True)
measNumOutOfRange = restoredLlt(measImage, self.detector)
self.assertEqual(refNumOutOfRange, measNumOutOfRange)
self.assertImagesAlmostEqual(refImage, measImage)
def testNonUnitIntervals(self):
"""!Test a small ramp image with non-integer increments
"""
for imageClass in (afwImage.ImageU, afwImage.ImageF, afwImage.ImageD):
dim = lsst.geom.Extent2I(7, 9)
box = lsst.geom.Box2I(lsst.geom.Point2I(-1, 3), dim)
numPix = dim[0]*dim[1]
for start in (-5.1, 0, 4.3):
if imageClass == afwImage.ImageU and start < 0:
continue
for stop in (7, 1001.5, 5.4):
rampImage = makeRampImage(
bbox=box, start=start, stop=stop, imageClass=imageClass)
dtype = rampImage.getArray().dtype
predArr = np.linspace(
start, stop, num=numPix, endpoint=True, dtype=dtype)
predArr.shape = (dim[1], dim[0])
self.assertImagesAlmostEqual(rampImage, predArr)
def testUnitInterval(self):
"""!Test small ramp images with unit interval for known values
"""
for imageClass in (afwImage.ImageU, afwImage.ImageF, afwImage.ImageD):
dim = lsst.geom.Extent2I(7, 9)
box = lsst.geom.Box2I(lsst.geom.Point2I(-1, 3), dim)
numPix = dim[0]*dim[1]
for start in (-5, 0, 4):
if imageClass == afwImage.ImageU and start < 0:
continue
predStop = start + numPix - 1 # for integer steps
for stop in (None, predStop):
rampImage = makeRampImage(
bbox=box, start=start, stop=predStop, imageClass=imageClass)
predArr = np.arange(start, predStop+1)
self.assertEqual(len(predArr), numPix)
predArr.shape = (dim[1], dim[0])
self.assertImagesAlmostEqual(rampImage, predArr)
def testKnown(self):
"""Test that a given image and lookup table produce the known answer
Apply a negative ramp table to a positive ramp image to get a flat
image, but have one value out of range at each end, to offset each end
point by one
"""
# generate a small ramp image with ascending integer values
# starting at some small negative value going positive
bbox = lsst.geom.Box2I(lsst.geom.Point2I(0, 0),
lsst.geom.Extent2I(3, 4))
numPix = bbox.getWidth() * bbox.getHeight()
start = -3
stop = start + numPix - 1
im = makeRampImage(bbox=bbox,
start=start,
stop=stop,
imageClass=afwImage.ImageF)
# generate a ramp lookup table with descending integer values,
# with a range offset by a small arbitrary value from the image ramp
# make it two elements too short so we can have one value out of range
# at each end
numOutOfRangePerEnd = 1
numOutOfRange = 2 * numOutOfRangePerEnd
tableOffset = -2
table = np.linspace(start=stop + tableOffset,
stop=numOutOfRange + start + tableOffset,
num=numPix - numOutOfRange)
table = np.array(table, dtype=im.getArray().dtype)
# apply the table with the first and last image value out of range by
# one.
indOffset = -(start + numOutOfRangePerEnd)
measNumOutOfRange = applyLookupTable(im, table, indOffset)
self.assertEqual(numOutOfRange, measNumOutOfRange)
# at this point the image should all have the same value
# except the first point will be one less and the last one more
imArr = im.getArray()
desVal = start + numOutOfRangePerEnd + table[0]
desImArr = np.zeros(numPix, dtype=im.getArray().dtype)
desImArr[:] = desVal
desImArr[0] -= 1
desImArr[-1] += 1
desImArr.shape = imArr.shape
self.assertFloatsAlmostEqual(desImArr, imArr)
def testBasics(self):
"""!Test basic functionality of LinearizeSquared
"""
for imageClass in (afwImage.ImageF, afwImage.ImageD):
inImage = makeRampImage(bbox=self.bbox, start=-5, stop=2500, imageClass=imageClass)
measImage = inImage.Factory(inImage, True)
linSq = LinearizeSquared()
linRes = linSq(image=measImage, detector=self.detector)
desNumLinearized = np.sum(self.sqCoeffs.flatten() > 0)
self.assertEqual(linRes.numLinearized, desNumLinearized)
self.assertEqual(linRes.numAmps, len(self.detector.getAmpInfoCatalog()))
refImage = inImage.Factory(inImage, True)
refLinearizeSquared(image=refImage, detector=self.detector)
self.assertImagesAlmostEqual(refImage, measImage)
# make sure logging is accepted
log = Log.getLogger("ip.isr.LinearizeSquared")
linRes = linSq(image=measImage, detector=self.detector, log=log)
def testBasics(self):
"""!Test basic functionality of applyLookupTable
"""
bbox = afwGeom.Box2I(afwGeom.Point2I(-31, 22), afwGeom.Extent2I(100, 85))
imMin = -5
imMax = 2500
tableLen = 2000
tableSigma = 55
for indOffset in (0, -50, 234):
for imageClass in (afwImage.ImageF, afwImage.ImageD):
inImage = makeRampImage(bbox=bbox, start=imMin, stop=imMax, imageClass=imageClass)
table = np.random.normal(scale=tableSigma, size=tableLen)
table = np.array(table, dtype=inImage.getArray().dtype)
refImage = imageClass(inImage, True)
refNumBad = referenceApply(image=refImage, table=table, indOffset=indOffset)
measImage = imageClass(inImage, True)
measNumBad = applyLookupTable(measImage, table, indOffset)
self.assertEqual(refNumBad, measNumBad)
self.assertImagesAlmostEqual(refImage, measImage)
def testBasics(self):
"""!Test basic functionality of LinearizeLookupTable
"""
for imageClass in (afwImage.ImageF, afwImage.ImageD):
inImage = makeRampImage(bbox=self.bbox, start=-5, stop=250, imageClass=imageClass)
table = self.makeTable(inImage)
measImage = inImage.Factory(inImage, True)
llt = LinearizeLookupTable(table=table, detector=self.detector)
linRes = llt(measImage, self.detector)
refImage = inImage.Factory(inImage, True)
refNumOutOfRange = refLinearize(image=refImage, detector=self.detector, table=table)
self.assertEqual(linRes.numAmps, len(self.detector.getAmpInfoCatalog()))
self.assertEqual(linRes.numAmps, linRes.numLinearized)
self.assertEqual(linRes.numOutOfRange, refNumOutOfRange)
self.assertImagesAlmostEqual(refImage, measImage)
# make sure logging is accepted
log = Log.getLogger("ip.isr.LinearizeLookupTable")
linRes = llt(image=measImage, detector=self.detector, log=log)
def testKnown(self):
"""Test that a given image and lookup table produce the known answer
Apply a negative ramp table to a positive ramp image to get a flat image,
but have one value out of range at each end, to offset each end point by one
"""
# generate a small ramp image with ascending integer values
# starting at some small negative value going positive
bbox = afwGeom.Box2I(afwGeom.Point2I(0, 0), afwGeom.Extent2I(3, 4))
numPix = bbox.getWidth()*bbox.getHeight()
start = -3
stop = start + numPix - 1
im = makeRampImage(bbox=bbox, start=start, stop=stop, imageClass=afwImage.ImageF)
# generate a ramp lookup table with descending integer values,
# with a range offset by a small arbitrary value from the image ramp
# make it two elements too short so we can have one value out of range at each end
numOutOfRangePerEnd = 1
numOutOfRange = 2*numOutOfRangePerEnd
tableOffset = -2
table = np.linspace(
start=stop + tableOffset,
stop=numOutOfRange + start + tableOffset,
num=numPix - numOutOfRange)
table = np.array(table, dtype=im.getArray().dtype)
# apply the table with the first and last image value out of range by one
indOffset = -(start + numOutOfRangePerEnd)
measNumOutOfRange = applyLookupTable(im, table, indOffset)
self.assertEqual(numOutOfRange, measNumOutOfRange)
# at this point the image should all have the same value
# except the first point will be one less and the last one more
imArr = im.getArray()
desVal = start + numOutOfRangePerEnd + table[0]
desImArr = np.zeros(numPix, dtype=im.getArray().dtype)
desImArr[:] = desVal
desImArr[0] -= 1
desImArr[-1] += 1
desImArr.shape = imArr.shape
self.assertFloatsAlmostEqual(desImArr, imArr)
def testBasics(self):
"""Test basic linearization functionality.
"""
for imageClass in (afwImage.ImageF, afwImage.ImageD):
inImage = makeRampImage(bbox=self.bbox,
start=-5,
stop=2500,
imageClass=imageClass)
for linearityType in ('Squared', 'LookupTable', 'Polynomial',
'Spline'):
detector = self.makeDetector(linearityType)
table = None
inputData = {
'Squared': self.sqCoeffs,
'LookupTable': self.lookupIndices,
'Polynomial': self.polyCoeffs,
'Spline': self.splineCoeffs
}[linearityType]
if linearityType == 'LookupTable':
table = np.array(self.table,
dtype=inImage.getArray().dtype)
linearizer = Linearizer(detector=detector, table=table)
measImage = inImage.Factory(inImage, True)
result = linearizer.applyLinearity(measImage,
detector=detector,
log=self.log)
refImage, refNumOutOfRange = referenceImage(
inImage.Factory(inImage, True), detector, linearityType,
inputData, table)
# This is necessary for the same tests to be used on
# all types. The first amplifier has 0.0 for the
# coefficient, which should be tested (it has a log
# message), but we are not linearizing an amplifier
# with no correction, so it fails the test that
# numLinearized == numAmps.
zeroLinearity = 1 if linearityType == 'Squared' else 0
self.compareResults(measImage, result.numOutOfRange,
result.numLinearized, result.numAmps,
refImage, refNumOutOfRange,
self.numAmps - zeroLinearity, self.numAmps)
# Test a stand alone linearizer. This ignores validate checks.
measImage = inImage.Factory(inImage, True)
storedLinearizer = self.makeLinearizer(linearityType)
storedResult = storedLinearizer.applyLinearity(measImage,
log=self.log)
self.compareResults(measImage, storedResult.numOutOfRange,
storedResult.numLinearized,
storedResult.numAmps, refImage,
refNumOutOfRange,
self.numAmps - zeroLinearity, self.numAmps)
# "Save to yaml" and test again
storedDict = storedLinearizer.toDict()
storedLinearizer = Linearizer().fromDict(storedDict)
measImage = inImage.Factory(inImage, True)
storedLinearizer = self.makeLinearizer(linearityType)
storedResult = storedLinearizer.applyLinearity(measImage,
log=self.log)
self.compareResults(measImage, storedResult.numOutOfRange,
storedResult.numLinearized,
storedResult.numAmps, refImage,
refNumOutOfRange,
self.numAmps - zeroLinearity, self.numAmps)
# "Save to fits" and test again
storedTable = storedLinearizer.toTable()
storedLinearizer = Linearizer().fromTable(storedTable)
measImage = inImage.Factory(inImage, True)
storedLinearizer = self.makeLinearizer(linearityType)
storedResult = storedLinearizer.applyLinearity(measImage,
log=self.log)
self.compareResults(measImage, storedResult.numOutOfRange,
storedResult.numLinearized,
storedResult.numAmps, refImage,
refNumOutOfRange,
self.numAmps - zeroLinearity, self.numAmps)
