def refLinearize(image, detector, table):
"""!Basic implementation of lookup table based non-linearity correction
@param[in,out] image image to correct in place (an lsst.afw.image.Image
of some type)
@param[in] detector detector info (an lsst.afw.cameraGeom.Detector)
@param[in] table lookup table: a 2D array of values of the same type as
image;
- one row for each row index (value of coef[0] in the amp info
catalog)
- one column for each image value
@return the number of pixels whose values were out of range of the lookup
table
"""
ampInfoCat = detector.getAmplifiers()
numOutOfRange = 0
for ampInfo in ampInfoCat:
bbox = ampInfo.getBBox()
rowInd, colIndOffset = ampInfo.getLinearityCoeffs()[0:2]
rowInd = int(rowInd)
tableRow = table[rowInd, :]
imView = image.Factory(image, bbox)
numOutOfRange += applyLookupTable(imView, tableRow, colIndOffset)
return numOutOfRange
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 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 refLinearize(image, detector, table):
"""!Basic implementation of lookup table based non-linearity correction
@param[in,out] image image to correct in place (an lsst.afw.image.Image of some type)
@param[in] detector detector info (an lsst.afw.cameraGeom.Detector)
@param[in] table lookup table: a 2D array of values of the same type as image;
- one row for each row index (value of coef[0] in the amp info catalog)
- one column for each image value
@return the number of pixels whose values were out of range of the lookup table
"""
ampInfoCat = detector.getAmpInfoCatalog()
numOutOfRange = 0
for ampInfo in ampInfoCat:
bbox = ampInfo.getBBox()
rowInd, colIndOffset = ampInfo.getLinearityCoeffs()[0:2]
rowInd = int(rowInd)
tableRow = table[rowInd, :]
imView = image.Factory(image, bbox)
numOutOfRange += applyLookupTable(imView, tableRow, colIndOffset)
return numOutOfRange
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 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 referenceImage(image, detector, linearityType, inputData, table=None):
"""Generate a reference linearization.
Parameters
----------
image: `lsst.afw.image.Image`
Image to linearize.
detector: `lsst.afw.cameraGeom.Detector`
Detector this image is from.
linearityType: `str`
Type of linearity to apply.
inputData: `numpy.array`
An array of values for the linearity correction.
table: `numpy.array`, optional
An optional lookup table to use.
Returns
-------
outImage: `lsst.afw.image.Image`
The output linearized image.
numOutOfRange: `int`
The number of values that could not be linearized.
Raises
------
RuntimeError :
Raised if an invalid linearityType is supplied.
"""
numOutOfRange = 0
for ampIdx, amp in enumerate(detector.getAmplifiers()):
ampIdx = (ampIdx // 3, ampIdx % 3)
bbox = amp.getBBox()
imageView = image.Factory(image, bbox)
if linearityType == 'Squared':
sqCoeff = inputData[ampIdx]
array = imageView.getArray()
array[:] = array + sqCoeff * array**2
elif linearityType == 'LookupTable':
rowInd, colIndOffset = inputData[ampIdx]
rowInd = int(rowInd)
tableRow = table[rowInd, :]
numOutOfRange += applyLookupTable(imageView, tableRow,
colIndOffset)
elif linearityType == 'Polynomial':
coeffs = inputData[ampIdx]
array = imageView.getArray()
summation = np.zeros_like(array)
for index, coeff in enumerate(coeffs):
summation += coeff * np.power(array, (index + 2))
array += summation
elif linearityType == 'Spline':
centers, values = np.split(inputData, 2) # This uses the full data
interp = afwMath.makeInterpolate(
centers.tolist(), values.tolist(),
afwMath.stringToInterpStyle('AKIMA_SPLINE'))
array = imageView.getArray()
delta = interp.interpolate(array.flatten())
array -= np.array(delta).reshape(array.shape)
else:
raise RuntimeError(f"Unknown linearity: {linearityType}")
return image, numOutOfRange