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)