def testIntUneven(self):
"""!Test dividing an integer box into an uneven grid
Divide a 5x4 box into 2x3 regions
"""
minPt = afwGeom.Point2I(0, 0)
extent = afwGeom.Extent2I(5, 7)
numColRow = (2, 3)
outerBox = afwGeom.Box2I(minPt, extent)
boxGrid = BoxGrid(box=outerBox, numColRow=numColRow)
desColStarts = (0, 2)
desWidths = (2, 3)
desRowStarts = (0, 2, 4)
desHeights = (2, 2, 3)
for row in range(numColRow[1]):
desRowStart = desRowStarts[row]
desHeight = desHeights[row]
for col in range(numColRow[0]):
desColStart = desColStarts[col]
desWidth = desWidths[col]
box = boxGrid[col, row]
self.assertEqual(tuple(box.getMin()),
(desColStart, desRowStart))
self.assertEqual(tuple(box.getDimensions()),
(desWidth, desHeight))
def makeDetector(self, linearityType, bbox=None):
"""Generate a fake detector for the test.
Parameters
----------
linearityType : `str`
Which linearity to assign to the detector's cameraGeom.
bbox : `lsst.geom.Box2I`, optional
Bounding box to use for the detector.
Returns
-------
detBuilder : `lsst.afw.cameraGeom.Detector`
The fake detector.
"""
bbox = bbox if bbox is not None else self.bbox
numAmps = self.ampArrangement
detName = "det_a"
detId = 1
detSerial = "123"
orientation = cameraGeom.Orientation()
pixelSize = lsst.geom.Extent2D(1, 1)
camBuilder = cameraGeom.Camera.Builder("fakeCam")
detBuilder = camBuilder.add(detName, detId)
detBuilder.setSerial(detSerial)
detBuilder.setBBox(bbox)
detBuilder.setOrientation(orientation)
detBuilder.setPixelSize(pixelSize)
boxArr = BoxGrid(box=bbox, numColRow=numAmps)
for i in range(numAmps[0]):
for j in range(numAmps[1]):
ampInfo = cameraGeom.Amplifier.Builder()
ampInfo.setName("amp %d_%d" % (i + 1, j + 1))
ampInfo.setBBox(boxArr[i, j])
ampInfo.setLinearityType(linearityType)
if linearityType == 'Squared':
ampInfo.setLinearityCoeffs([self.sqCoeffs[i, j]])
elif linearityType == 'LookupTable':
# setLinearityCoeffs is picky about getting a mixed
# int/float list.
ampInfo.setLinearityCoeffs(
np.array([
self.rowInds[i, j], self.colIndOffsets[i, j], 0, 0
],
dtype=float))
elif linearityType == 'Polynomial':
ampInfo.setLinearityCoeffs(self.polyCoeffs[i, j])
elif linearityType == 'Spline':
ampInfo.setLinearityCoeffs(self.splineCoeffs)
detBuilder.append(ampInfo)
return detBuilder
def makeDetector(self,
bbox=None,
numAmps=None,
rowInds=None,
colIndOffsets=None,
detName="det_a",
detSerial="123",
linearityType="LookupTable"):
"""!Make a detector
@param[in] bbox bounding box for image
@param[n] numAmps x,y number of amplifiers (pair of int)
@param[in] rowInds index of lookup table for each amplifier (array of
shape numAmps)
@param[in] colIndOffsets column index offset for each amplifier
(array of shape numAmps)
@param[in] detName detector name (a str)
@param[in] detSerial detector serial numbe (a str)
@param[in] linearityType name of linearity type (a str)
@return a detector (an lsst.afw.cameraGeom.Detector)
"""
bbox = bbox if bbox is not None else self.bbox
numAmps = numAmps if numAmps is not None else self.numAmps
rowInds = rowInds if rowInds is not None else self.rowInds
colIndOffsets = colIndOffsets if colIndOffsets is not None else self.colIndOffsets
detId = 1
orientation = cameraGeom.Orientation()
pixelSize = lsst.geom.Extent2D(1, 1)
camBuilder = cameraGeom.Camera.Builder("fakeCam")
detBuilder = camBuilder.add(detName, detId)
detBuilder.setSerial(detSerial)
detBuilder.setBBox(bbox)
detBuilder.setOrientation(orientation)
detBuilder.setPixelSize(pixelSize)
boxArr = BoxGrid(box=bbox, numColRow=numAmps)
for i in range(numAmps[0]):
for j in range(numAmps[1]):
ampInfo = cameraGeom.Amplifier.Builder()
ampInfo.setName("amp %d_%d" % (i + 1, j + 1))
ampInfo.setBBox(boxArr[i, j])
ampInfo.setLinearityType(linearityType)
# setLinearityCoeffs is picky about getting a mixed int/float
# list.
ampInfo.setLinearityCoeffs(
np.array([rowInds[i, j], colIndOffsets[i, j], 0, 0],
dtype=float))
detBuilder.append(ampInfo)
return detBuilder
def makeDetector(self,
bbox=None,
numAmps=None,
rowInds=None,
colIndOffsets=None,
detName="det_a",
detSerial="123",
linearityType="LookupTable"):
"""!Make a detector
@param[in] bbox bounding box for image
@param[n] numAmps x,y number of amplifiers (pair of int)
@param[in] rowInds index of lookup table for each amplifier (array of shape numAmps)
@param[in] colIndOffsets column index offset for each amplifier (array of shape numAmps)
@param[in] detName detector name (a str)
@param[in] detSerial detector serial numbe (a str)
@param[in] linearityType name of linearity type (a str)
@return a detector (an lsst.afw.cameraGeom.Detector)
"""
bbox = bbox if bbox is not None else self.bbox
numAmps = numAmps if numAmps is not None else self.numAmps
rowInds = rowInds if rowInds is not None else self.rowInds
colIndOffsets = colIndOffsets if colIndOffsets is not None else self.colIndOffsets
schema = afwTable.AmpInfoTable.makeMinimalSchema()
ampInfoCat = afwTable.AmpInfoCatalog(schema)
boxArr = BoxGrid(box=bbox, numColRow=numAmps)
for i in range(numAmps[0]):
for j in range(numAmps[1]):
ampInfo = ampInfoCat.addNew()
ampInfo.setName("amp %d_%d" % (i + 1, j + 1))
ampInfo.setBBox(boxArr[i, j])
ampInfo.setLinearityType(linearityType)
# setLinearityCoeffs is picky about getting a mixed int/float list.
ampInfo.setLinearityCoeffs(
np.array([rowInds[i, j], colIndOffsets[i, j], 0, 0],
dtype=float))
detId = 1
orientation = cameraGeom.Orientation()
pixelSize = afwGeom.Extent2D(1, 1)
transMap = {}
return cameraGeom.Detector(
detName,
detId,
cameraGeom.SCIENCE,
detSerial,
bbox,
ampInfoCat,
orientation,
pixelSize,
transMap,
)
def makeLinearizer(self, linearityType, bbox=None):
"""Construct a linearizer with the test coefficients.
Parameters
----------
linearityType : `str`
Type of linearity to use. The coefficients are set by the
setUp method.
bbox : `lsst.geom.Box2I`
Bounding box for the full detector. Used to assign
amp-based bounding boxes.
Returns
-------
linearizer : `lsst.ip.isr.Linearizer`
A fully constructed, persistable linearizer.
"""
bbox = bbox if bbox is not None else self.bbox
numAmps = self.ampArrangement
boxArr = BoxGrid(box=bbox, numColRow=numAmps)
linearizer = Linearizer()
linearizer.hasLinearity = True
for i in range(numAmps[0]):
for j in range(numAmps[1]):
ampName = f"amp {i+1}_{j+1}"
ampBox = boxArr[i, j]
linearizer.ampNames.append(ampName)
if linearityType == 'Squared':
linearizer.linearityCoeffs[ampName] = np.array(
[self.sqCoeffs[i, j]])
elif linearityType == 'LookupTable':
linearizer.linearityCoeffs[ampName] = np.array(
self.lookupIndices[i, j])
linearizer.tableData = self.table
elif linearityType == 'Polynomial':
linearizer.linearityCoeffs[ampName] = np.array(
self.polyCoeffs[i, j])
elif linearityType == 'Spline':
linearizer.linearityCoeffs[ampName] = np.array(
self.splineCoeffs)
linearizer.linearityType[ampName] = linearityType
linearizer.linearityBBox[ampName] = ampBox
linearizer.fitParams[ampName] = np.array([])
linearizer.fitParamsErr[ampName] = np.array([])
linearizer.fitChiSq[ampName] = np.nan
linearizer.fitResiduals[ampName] = np.array([])
linearizer.linearFit[ampName] = np.array([])
return linearizer
def makeDetector(self,
bbox=None,
numAmps=None,
sqCoeffs=None,
linearityType="Squared"):
"""!Make a detector
@param[in] bbox bounding box for image
@param[n] numAmps x,y number of amplifiers (pair of int)
@param[in] sqCoeffs square coefficient for each amplifier (2D array of float)
@param[in] detName detector name (a str)
@param[in] detID detector ID (an int)
@param[in] detSerial detector serial numbe (a str)
@param[in] linearityType name of linearity type (a str)
@return a detector (an lsst.afw.cameraGeom.Detector)
"""
bbox = bbox if bbox is not None else self.bbox
numAmps = numAmps if numAmps is not None else self.numAmps
sqCoeffs = sqCoeffs if sqCoeffs is not None else self.sqCoeffs
schema = afwTable.AmpInfoTable.makeMinimalSchema()
ampInfoCat = afwTable.AmpInfoCatalog(schema)
boxArr = BoxGrid(box=bbox, numColRow=numAmps)
for i in range(numAmps[0]):
for j in range(numAmps[1]):
ampInfo = ampInfoCat.addNew()
ampInfo.setName("amp %d_%d" % (i + 1, j + 1))
ampInfo.setBBox(boxArr[i, j])
ampInfo.setLinearityType(linearityType)
ampInfo.setLinearityCoeffs([sqCoeffs[i, j]])
detName = "det_a"
detId = 1
detSerial = "123"
orientation = cameraGeom.Orientation()
pixelSize = afwGeom.Extent2D(1, 1)
transMap = {}
return cameraGeom.Detector(
detName,
detId,
cameraGeom.SCIENCE,
detSerial,
bbox,
ampInfoCat,
orientation,
pixelSize,
transMap,
)
def makeDetector(self,
bbox=None,
numAmps=None,
sqCoeffs=None,
linearityType="Squared"):
"""!Make a detector
@param[in] bbox bounding box for image
@param[n] numAmps x,y number of amplifiers (pair of int)
@param[in] sqCoeffs square coefficient for each amplifier (2D array of
float)
@param[in] detName detector name (a str)
@param[in] detID detector ID (an int)
@param[in] detSerial detector serial numbe (a str)
@param[in] linearityType name of linearity type (a str)
@return a detector (an lsst.afw.cameraGeom.Detector)
"""
bbox = bbox if bbox is not None else self.bbox
numAmps = numAmps if numAmps is not None else self.numAmps
sqCoeffs = sqCoeffs if sqCoeffs is not None else self.sqCoeffs
detName = "det_a"
detId = 1
detSerial = "123"
orientation = cameraGeom.Orientation()
pixelSize = lsst.geom.Extent2D(1, 1)
camBuilder = cameraGeom.Camera.Builder("fakeCam")
detBuilder = camBuilder.add(detName, detId)
detBuilder.setSerial(detSerial)
detBuilder.setBBox(bbox)
detBuilder.setOrientation(orientation)
detBuilder.setPixelSize(pixelSize)
boxArr = BoxGrid(box=bbox, numColRow=numAmps)
for i in range(numAmps[0]):
for j in range(numAmps[1]):
ampInfo = cameraGeom.Amplifier.Builder()
ampInfo.setName("amp %d_%d" % (i + 1, j + 1))
ampInfo.setBBox(boxArr[i, j])
ampInfo.setLinearityType(linearityType)
ampInfo.setLinearityCoeffs([sqCoeffs[i, j]])
detBuilder.append(ampInfo)
return detBuilder
def test3By4(self):
"""!Test a 3x4 box divided into a 3x2 grid, such that each sub-box is 1x2
"""
for boxClass in (afwGeom.Box2I, afwGeom.Box2D):
pointClass = type(boxClass().getMin())
extentClass = type(boxClass().getDimensions())
minPt = pointClass(-1, 3)
extent = extentClass(3, 4)
numColRow = (3, 2)
outerBox = boxClass(minPt, extent)
boxGrid = BoxGrid(box=outerBox, numColRow=numColRow)
for box in boxGrid:
self.assertEqual(box.getDimensions(), extentClass(1, 2))
for row in range(numColRow[1]):
for col in range(numColRow[0]):
box = boxGrid[col, row]
predMin = outerBox.getMin() + extentClass(col*1, row*2)
self.assertEqual(box.getMin(), predMin)