def _testImageSlicing(testCase, mImage, gVal, rVal, iVal): """Test slicing in the spatial dimensions for image-like objects""" testCase.assertIsInstance(mImage[:, -1, -1, LOCAL], MultibandPixel) testCase.assertEqual(mImage["G", -1, -1, LOCAL], gVal) testCase.assertEqual(mImage[:, 1100:, 2025:].getBBox(), Box2I(Point2I(1100, 2025), Extent2I(100, 75))) testCase.assertEqual(mImage[:, -20:-10, -10:-5, LOCAL].getBBox(), Box2I(Point2I(1180, 2090), Extent2I(10, 5))) testCase.assertEqual(mImage[:, :1100, :2050].getBBox(), Box2I(Point2I(1000, 2000), Extent2I(100, 50))) coord = Point2I(1075, 2015) bbox = Box2I(Point2I(1050, 2010), coord) testCase.assertEqual(mImage[:, bbox].getBBox(), bbox) testCase.assertEqual(mImage[:, 1010, 2010].getBBox().getMin(), Point2I(1010, 2010)) testCase.assertEqual(mImage[:, Point2I(1075, 2015)].getBBox().getMin(), coord) testCase.assertEqual(mImage["G", 1100:, 2025:].getBBox(), Box2I(Point2I(1100, 2025), Extent2I(100, 75))) testCase.assertEqual(mImage["R", -20:-10, -10:-5, LOCAL].getBBox(), Box2I(Point2I(1180, 2090), Extent2I(10, 5))) testCase.assertEqual(mImage["I", :1100, :2050].getBBox(), Box2I(Point2I(1000, 2000), Extent2I(100, 50))) testCase.assertEqual(mImage["R", bbox].getBBox(), bbox) testCase.assertEqual(mImage["I", 1010, 2010], iVal) testCase.assertEqual(mImage["R", Point2I(1075, 2015)], rVal) with testCase.assertRaises(TypeError): mImage[:, 0] with testCase.assertRaises(TypeError): mImage[:, 10:] with testCase.assertRaises(TypeError): mImage[:, :10] with testCase.assertRaises(TypeError): mImage[:, :, 0]
def _testMaskedImageCopy(testCase, maskedImage1): maskedImage2 = maskedImage1.clone() maskedImage2.setXY0(Point2I(11, 23)) testCase.assertEqual(maskedImage2.getBBox(), Box2I(Point2I(11, 23), Extent2I(200, 100))) testCase.assertEqual(maskedImage1.getBBox(), Box2I(Point2I(1000, 2000), Extent2I(200, 100))) testCase.assertTrue( np.all([ img.getBBox() == maskedImage1.getBBox() for img in maskedImage1.image ])) testCase.assertTrue( np.all([ img.getBBox() == maskedImage2.getBBox() for img in maskedImage2.image ])) maskedImage2.image.array = 1 testCase.assertFloatsEqual(maskedImage1.image.array, testCase.imgValue) testCase.assertFloatsEqual(maskedImage2.image.array, 1) testCase.assertFloatsEqual(maskedImage1["G"].image.array, testCase.imgValue) testCase.assertFloatsEqual(maskedImage2["G"].image.array, 1) maskedImage2 = maskedImage1.clone(False) maskedImage2.image.array = 1 testCase.assertFloatsEqual(maskedImage1.image.array, 1) testCase.assertFloatsEqual(maskedImage2.image.array, 1) testCase.assertFloatsEqual(maskedImage1["G"].image.array, 1) testCase.assertFloatsEqual(maskedImage2["G"].image.array, 1)
def test_getNumGoodPixels(self): """Test the the number of pixels in the image not masked is as expected.""" testImage = self.flatExp.clone() mi = testImage.maskedImage imageSize = testImage.getBBox().getArea() nGood = self.defaultTask.measure._getNumGoodPixels(mi) self.assertEqual(imageSize, nGood) NODATABIT = mi.mask.getPlaneBitMask("NO_DATA") noDataBox = Box2I(Point2I(31, 49), Extent2I(3, 6)) testImage.mask[noDataBox] |= NODATABIT self.assertEqual(imageSize - noDataBox.getArea(), self.defaultTask.measure._getNumGoodPixels(mi)) # check for misfire; we're setting NO_DATA here, not BAD self.assertEqual(imageSize, self.defaultTask.measure._getNumGoodPixels(mi, 'BAD')) testImage.mask[noDataBox] ^= NODATABIT # XOR to reset what we did self.assertEqual(imageSize, nGood) BADBIT = mi.mask.getPlaneBitMask("BAD") badBox = Box2I(Point2I(85, 98), Extent2I(4, 7)) testImage.mask[badBox] |= BADBIT self.assertEqual(imageSize - badBox.getArea(), self.defaultTask.measure._getNumGoodPixels(mi, 'BAD'))
def _testImageCopy(testCase, mImage1, value1, value2): """Test copy and deep copy in image-like objects""" mImage2 = mImage1.clone() mImage2.setXY0(Point2I(11, 23)) testCase.assertEqual(mImage2.getBBox(), Box2I(Point2I(11, 23), Extent2I(200, 100))) testCase.assertEqual(mImage1.getBBox(), Box2I(Point2I(1000, 2000), Extent2I(200, 100))) testCase.assertTrue( np.all([s.getBBox() == mImage1.getBBox() for s in mImage1.singles])) testCase.assertTrue( np.all([s.getBBox() == mImage2.getBBox() for s in mImage2.singles])) mImage2.array[:] = 17 testCase.assertNotEqual(mImage1.array[0, 0, 0], 17) mImage2.array[:] = value2 testCase.assertFloatsEqual(mImage1.array, value1) testCase.assertFloatsEqual(mImage2.array, value2) testCase.assertFloatsEqual(mImage1["G"].array, value1) testCase.assertFloatsEqual(mImage2["G"].array, value2) mImage2 = mImage1.clone(False) mImage2.setXY0(Point2I(11, 23)) mImage2.array[:] = 17 testCase.assertFloatsEqual(mImage2.array, mImage1.array) mImage2.array[:] = value2 testCase.assertFloatsEqual(mImage1.array, value2) testCase.assertFloatsEqual(mImage2.array, value2) testCase.assertFloatsEqual(mImage1["G"].array, value2) testCase.assertFloatsEqual(mImage2["G"].array, value2)
def setUp(self): np.random.seed(1) self.bbox1 = Box2I(Point2I(1000, 2000), Extent2I(200, 100)) self.filters = ["G", "R", "I", "Z", "Y"] self.value1, self.value2 = 10, 100 images = [ImageF(self.bbox1, self.value1) for f in self.filters] self.mImage1 = MultibandImage.fromImages(self.filters, images) self.bbox2 = Box2I(Point2I(1100, 2025), Extent2I(30, 50)) images = [ImageF(self.bbox2, self.value2) for f in self.filters] self.mImage2 = MultibandImage.fromImages(self.filters, images)
def test_amp_curve(self): # Future versions of astropy will pass unit through concatenation amp_wavelength = np.concatenate([self.wavelength.value, self.wavelength.value])*u.angstrom # Two amps amp_efficiency = np.concatenate([self.efficiency.value, self.efficiency.value*0.8])*u.percent # Two amps amp_name = np.concatenate([['A' for el in self.wavelength], ['B' for el in self.wavelength]]) amplist = [MockAmp('A', Box2I(Point2I(0, 0), Extent2I(512, 1025))), MockAmp('B', Box2I(Point2I(512, 10), Extent2I(512, 1024)))] args = (amp_name, amp_wavelength, amp_efficiency, self.metadata) self.curve_tester(algorithms.AmpCurve, args) self.interp_tester(algorithms.AmpCurve, args, amplist)
def setUp(self): self.dtypes = [ np.dtype(t) for t in (np.uint16, np.int32, np.float32, np.float64) ] self.bbox = Box2I(Point2I(2, 1), Extent2I(5, 7)) self.args = [ (), (Box2I(Point2I(3, 4), Extent2I(2, 1)), ), (Box2I(Point2I(3, 4), Extent2I(2, 1)), PARENT), (Box2I(Point2I(1, 0), Extent2I(3, 2)), LOCAL), ]
def testPixelBBoxModification(self): pixel = self.pixel.clone() otherPixel = pixel.clone() pixel.getBBox().shift(Extent2I(9, -2)) self.assertEqual(pixel.getBBox().getMin(), Point2I(110, 500)) self.assertEqual(otherPixel.getBBox().getMin(), Point2I(101, 502)) pixel = self.pixel.clone() otherPixel = pixel.clone(False) pixel.getBBox().shift(Extent2I(9, -2)) self.assertEqual(pixel.getBBox().getMin(), Point2I(110, 500)) self.assertEqual(otherPixel.getBBox().getMin(), Point2I(110, 500))
def testConstructor(self): def projectSpans(radius, value, bbox, asArray): ss = SpanSet.fromShape(radius, Stencil.CIRCLE, offset=(10, 10)) image = ImageF(bbox) ss.setImage(image, value) if asArray: return image.array else: return image def runTest(images, mFoot, peaks=self.peaks, footprintBBox=Box2I(Point2I(6, 6), Extent2I(9, 9))): self.assertEqual(mFoot.getBBox(), footprintBBox) try: fpImage = np.array(images)[:, 1:-1, 1:-1] except IndexError: fpImage = np.array([img.array for img in images])[:, 1:-1, 1:-1] # result = mFoot.getImage(fill=0).image.array self.assertFloatsAlmostEqual(mFoot.getImage(fill=0).image.array, fpImage) if peaks is not None: self.verifyPeaks(mFoot.getPeaks(), peaks) bbox = Box2I(Point2I(5, 5), Extent2I(11, 11)) xy0 = Point2I(5, 5) images = np.array([projectSpans(n, 5-n, bbox, True) for n in range(2, 5)]) mFoot = MultibandFootprint.fromArrays(self.filters, images, xy0=xy0, peaks=self.peaks) runTest(images, mFoot) mFoot = MultibandFootprint.fromArrays(self.filters, images) runTest(images, mFoot, None, Box2I(Point2I(1, 1), Extent2I(9, 9))) images = [projectSpans(n, 5-n, bbox, False) for n in range(2, 5)] mFoot = MultibandFootprint.fromImages(self.filters, images, peaks=self.peaks) runTest(images, mFoot) images = np.array([projectSpans(n, n, bbox, True) for n in range(2, 5)]) mFoot = MultibandFootprint.fromArrays(self.filters, images, peaks=self.peaks, xy0=bbox.getMin()) runTest(images, mFoot) images = np.array([projectSpans(n, 5-n, bbox, True) for n in range(2, 5)]) thresh = [1, 2, 2.5] mFoot = MultibandFootprint.fromArrays(self.filters, images, xy0=bbox.getMin(), thresh=thresh) footprintBBox = Box2I(Point2I(8, 8), Extent2I(5, 5)) self.assertEqual(mFoot.getBBox(), footprintBBox) fpImage = np.array(images)[:, 3:-3, 3:-3] mask = np.all(fpImage <= np.array(thresh)[:, None, None], axis=0) fpImage[:, mask] = 0 self.assertFloatsAlmostEqual(mFoot.getImage(fill=0).image.array, fpImage) img = mFoot.getImage().image.array img[~np.isfinite(img)] = 1.1 self.assertFloatsAlmostEqual(mFoot.getImage(fill=1.1).image.array, img)
def test_maskBlocks_short_column(self): """A test for maskBlocksIfIntermitentBadPixelsInColumn. Tests that a contigous bad column Npix < badOnAndOffPixelColumnThreshold (10) does not get split by the code. Plots can be found in DM-19903 on Jira. """ expectedDefects = [Box2I(corner=Point2I(25, 1), dimensions=Extent2I(1, 8))] defects = self.allDefectsList defects.append(Box2I(corner=Point2I(25, 1), dimensions=Extent2I(1, 8))) self.check_maskBlocks(defects, expectedDefects)
def __init__(self, filters, singles, position): if any([arg is None for arg in [singles, filters, position]]): err = "Expected an array of `singles`, a list of `filters, and a `bbox`" raise NotImplementedError(err) # Make sure that singles is an array singles = np.array(singles, copy=False) super().__init__(filters, singles, bbox=Box2I(position, Extent2I(1, 1))) # In this case we want self.singles to be an array self._singles = singles # Make sure that the bounding box has been setup properly assert self.getBBox().getDimensions() == Extent2I(1, 1)
def setUp(self): xy0 = Point2I(12345, 67890) # xy0 for image dims = Extent2I(2345, 2345) # Dimensions of image box = Box2I(xy0, dims) # Bounding box of image sigma = 3.21 # PSF sigma buffer = 4.0 # Buffer for star centers around edge nSigmaForKernel = 5.0 # Number of PSF sigmas for kernel sky = 12345.6 # Sky level numStars = 100 # Number of stars noise = np.sqrt(sky) * np.pi * sigma**2 # Poisson noise per PSF faint = 1.0 * noise # Faintest level for star fluxes bright = 100.0 * noise # Brightest level for star fluxes starBox = Box2I(box) # Area on image in which we can put star centers starBox.grow(-int(buffer * sigma)) scale = 1.0e-5 * degrees # Pixel scale np.random.seed(12345) stars = [(xx, yy, ff, sigma) for xx, yy, ff in zip( np.random.uniform(starBox.getMinX(), starBox.getMaxX(), numStars), np.random.uniform(starBox.getMinY(), starBox.getMaxY(), numStars), np.linspace(faint, bright, numStars))] self.exposure = plantSources(box, 2 * int(nSigmaForKernel * sigma) + 1, sky, stars, True) self.exposure.setWcs( makeSkyWcs(crpix=Point2D(0, 0), crval=SpherePoint(0, 0, degrees), cdMatrix=makeCdMatrix(scale=scale))) # Make a large area of extra background; we should be robust against it # Unfortunately, some tuning is required here to get something challenging but not impossible: # * A very large box will cause failures because the "extra" and the "normal" are reversed. # * A small box will not be challenging because it's simple to clip out. # * A large value will cause failures because it produces large edges in background-subtrction that # broaden flux distributions. # * A small value will not be challenging because it has little effect. extraBox = Box2I(xy0 + Extent2I(345, 456), Extent2I(1234, 1234)) # Box for extra background extraValue = 0.5 * noise # Extra background value to add in self.exposure.image[extraBox, PARENT] += extraValue self.config = DynamicDetectionTask.ConfigClass() self.config.skyObjects.nSources = 300 self.config.reEstimateBackground = False self.config.doTempWideBackground = True self.config.thresholdType = "pixel_stdev" # Relative tolerance for tweak factor # Not sure why this isn't smaller; maybe due to use of Poisson instead of Gaussian noise? self.rtol = 0.1
def test_maskBlocks_full_column(self): """A test for maskBlocksIfIntermitentBadPixelsInColumn. Tests that a contigous bad column does not get split by the code. The mock flat has a size of 200X204 pixels. This column has a maximum length of 50 pixels, otherwise there would be a split along the mock amp boundary. Plots can be found in DM-19903 on Jira. """ defects = self.allDefectsList defects.append(Box2I(corner=Point2I(15, 1), dimensions=Extent2I(1, 50))) expectedDefects = [Box2I(corner=Point2I(15, 1), dimensions=Extent2I(1, 50))] self.check_maskBlocks(defects, expectedDefects)
def run(self, exposure, catalog, flux_key): subtracted_exposure = afwImage.ExposureF(exposure, deep=True) model = self.modelImage.run(subtracted_exposure, catalog, flux_key) for source in catalog: with self.modelImage.replaced_source(subtracted_exposure, source, flux_key): # This parameter is the radius of the spanset # Changing the radius doesn't seem to affect SDSS Centroid? spanSet = afwGeom.SpanSet.fromShape(3) spanSet = spanSet.shiftedBy(Extent2I(source.getCentroid())) footprint = afwDetection.Footprint(spanSet) peak = footprint.peaks.addNew() peak.setFx(source.getCentroid().getX()) peak.setFy(source.getCentroid().getY()) # Check for NaNs if (source.getCentroid().getX() == source.getCentroid().getX() ): peak.setIx(int(source.getCentroid().getX())) peak.setIy(int(source.getCentroid().getY())) source.setFootprint(footprint) try: self.sdssCentroid.measure(source, subtracted_exposure) except (MeasurementError): pass
def _testImageModification(testCase, mImage1, mImage2, bbox1, bbox2, value1, value2): """Test the image-like objects can be modified""" mImage1[:"R", bbox2].array = value2 testCase.assertFloatsEqual(mImage1["G", bbox2].array, mImage2["G"].array) testCase.assertFloatsEqual(mImage1["R"].array, value1) mImage1.setXY0(Point2I(500, 150)) testCase.assertEqual( mImage1.getBBox(), Box2I(Point2I(500, 150), Extent2I(bbox1.getDimensions()))) mImage1["G"].array[:] = value2 testCase.assertFloatsEqual(mImage1["G"].array, value2) testCase.assertFloatsEqual(mImage1.array[0], value2) if "Z" in mImage1.filters: filterSlice = slice("R", "Z") else: filterSlice = slice("R", None) mImage1[filterSlice].array[:] = 7 testCase.assertFloatsEqual(mImage1["I"].array, 7) newBBox = Box2I(Point2I(10000, 20000), mImage1.getBBox().getDimensions()) mImage1.setXY0(newBBox.getMin()) testCase.assertEqual(mImage1.getBBox(), newBBox) for image in mImage1: testCase.assertEqual(image.getBBox(), newBBox)
def setUp(self): np.random.seed(1) self.bbox = Box2I(Point2I(1000, 2000), Extent2I(200, 100)) self.filters = ["G", "R", "I"] self.imgValue = 10 images = [ImageF(self.bbox, self.imgValue) for f in self.filters] mImage = MultibandImage.fromImages(self.filters, images) self.Mask = Mask[MaskPixel] # Store the default mask planes for later use maskPlaneDict = self.Mask().getMaskPlaneDict() self.defaultMaskPlanes = sorted(maskPlaneDict, key=maskPlaneDict.__getitem__) # reset so tests will be deterministic self.Mask.clearMaskPlaneDict() for p in ("BAD", "SAT", "INTRP", "CR", "EDGE"): self.Mask.addMaskPlane(p) self.maskValue = self.Mask.getPlaneBitMask("BAD") singles = [self.Mask(self.bbox) for f in range(len(self.filters))] for n in range(len(singles)): singles[n].set(self.maskValue) mMask = MultibandMask.fromMasks(self.filters, singles) self.varValue = 1e-2 images = [ImageF(self.bbox, self.varValue) for f in self.filters] mVariance = MultibandImage.fromImages(self.filters, images) self.maskedImage = MultibandMaskedImage(self.filters, image=mImage, mask=mMask, variance=mVariance)
def make_coadd_dm_wcs_simple(coadd_dim): """ make a coadd wcs, using the default world origin. Parameters ---------- coadd_origin: int Origin in pixels of the coadd, can be within a larger pixel grid e.g. tract surrounding the patch Returns -------- A galsim wcs, see make_wcs for return type """ coadd_bbox = Box2I(Point2I(0), Extent2I(coadd_dim)) coadd_origin = coadd_bbox.getCenter() gs_coadd_origin = galsim.PositionD( x=coadd_origin.x, y=coadd_origin.y, ) coadd_wcs = make_dm_wcs( make_wcs( scale=SCALE, image_origin=gs_coadd_origin, world_origin=WORLD_ORIGIN, )) return coadd_wcs, coadd_bbox
def run(self, bss_ref_list, region_name=None): """Read input bright star stamps and stack them together. The stacking is done iteratively over smaller areas of the final model image to allow for a great number of bright star stamps to be used. Parameters ---------- bss_ref_list : `list` of `lsst.daf.butler._deferredDatasetHandle.DeferredDatasetHandle` List of available bright star stamps data references. region_name : `str`, optional Name of the focal plane region, if applicable. Only used for logging purposes, when running over multiple such regions (typically from `MeasureExtendedPsfTask`) """ if region_name: region_message = f' for region "{region_name}".' else: region_message = '' self.log.info( 'Building extended PSF from stamps extracted from %d detector images%s', len(bss_ref_list), region_message) # read in example set of full stamps example_bss = bss_ref_list[0].get(datasetType="brightStarStamps", immediate=True) example_stamp = example_bss[0].stamp_im # create model image ext_psf = afwImage.MaskedImageF(example_stamp.getBBox()) # divide model image into smaller subregions subregion_size = Extent2I(*self.config.subregion_size) sub_bboxes = AssembleCoaddTask._subBBoxIter(ext_psf.getBBox(), subregion_size) # compute approximate number of subregions n_subregions = int(ext_psf.getDimensions()[0] / subregion_size[0] + 1) * int(ext_psf.getDimensions()[1] / subregion_size[1] + 1) self.log.info( "Stacking will performed iteratively over approximately %d " "smaller areas of the final model image.", n_subregions) # set up stacking statistic stats_control, stats_flags = self._set_up_stacking(example_stamp) # perform stacking for jbbox, bbox in enumerate(sub_bboxes): all_stars = None for bss_ref in bss_ref_list: read_stars = bss_ref.get(datasetType="brightStarStamps", parameters={'bbox': bbox}) if self.config.do_mag_cut: read_stars = read_stars.selectByMag( magMax=self.config.mag_limit) if all_stars: all_stars.extend(read_stars) else: all_stars = read_stars # TODO: DM-27371 add weights to bright stars for stacking coadd_sub_bbox = afwMath.statisticsStack( all_stars.getMaskedImages(), stats_flags, stats_control) ext_psf.assign(coadd_sub_bbox, bbox) return ext_psf
def __init__(self, width, height, piffResult): assert width == height ImagePsf.__init__(self) self.width = width self.height = height self.dimensions = Extent2I(width, height) self._piffResult = piffResult
def tripleFromArrays(cls, filters, image, mask, variance, bbox=None): """Construct a MultibandTriple from a set of arrays Parameters ---------- filters: `list` List of filter names. image: array Array of image values mask: array Array of mask values variance: array Array of variance values bbox: `Box2I` Location of the array in a larger single band image. This argument is ignored if `singles` is not `None`. """ if bbox is None: bbox = Box2I(Point2I(0, 0), Extent2I(image.shape[1], image.shape[0])) mImage = MultibandImage(filters, image, bbox) if mask is not None: mMask = MultibandMask(filters, mask, bbox) else: mMask = None if variance is not None: mVariance = MultibandImage(filters, variance, bbox) else: mVariance = None return cls(filters, mImage, mMask, mVariance)
def setUp(self): np.random.seed(1) self.filters = ["G", "R", "I"] self.Mask = Mask[MaskPixel] # Store the default mask planes for later use maskPlaneDict = self.Mask().getMaskPlaneDict() self.defaultMaskPlanes = sorted(maskPlaneDict, key=maskPlaneDict.__getitem__) # reset so tests will be deterministic self.Mask.clearMaskPlaneDict() for p in ("BAD", "SAT", "INTRP", "CR", "EDGE"): self.Mask.addMaskPlane(p) self.BAD = self.Mask.getPlaneBitMask("BAD") self.CR = self.Mask.getPlaneBitMask("CR") self.EDGE = self.Mask.getPlaneBitMask("EDGE") self.values1 = [ self.BAD | self.CR, self.BAD | self.EDGE, self.BAD | self.CR | self.EDGE ] self.bbox = Box2I(Point2I(1000, 2000), Extent2I(200, 100)) singles = [self.Mask(self.bbox) for f in range(len(self.filters))] for n in range(len(singles)): singles[n].set(self.values1[n]) self.mMask1 = MultibandMask.fromMasks(self.filters, singles) self.values2 = [self.EDGE, self.BAD, self.CR | self.EDGE] singles = [self.Mask(self.bbox) for f in range(len(self.filters))] for n in range(len(singles)): singles[n].set(self.values2[n]) self.mMask2 = MultibandMask.fromMasks(self.filters, singles)
def run(md, **kwds2): kwds = extractCtorArgs(md) kwds.update(kwds2) gridShape = Extent2I(20, 20) approx = SipApproximation(gridShape=gridShape, **kwds) diffs = approx.computeMaxDeviation() self.assertLess(diffs[0], 0.1) self.assertLess(diffs[1], 0.1)
def fromTable(cls, tableList): """Read linearity from a FITS file. This method uses the `fromDict` method to create the calibration, after constructing an appropriate dictionary from the input tables. Parameters ---------- tableList : `list` [`astropy.table.Table`] afwTable read from input file name. Returns ------- linearity : `~lsst.ip.isr.linearize.Linearizer`` Linearity parameters. Notes ----- The method reads a FITS file with 1 or 2 extensions. The metadata is read from the header of extension 1, which must exist. Then the table is loaded, and the ['AMPLIFIER_NAME', 'TYPE', 'COEFFS', 'BBOX_X0', 'BBOX_Y0', 'BBOX_DX', 'BBOX_DY'] columns are read and used to set each dictionary by looping over rows. Eextension 2 is then attempted to read in the try block (which only exists for lookup tables). It has a column named 'LOOKUP_VALUES' that contains a vector of the lookup entries in each row. """ coeffTable = tableList[0] metadata = coeffTable.meta inDict = dict() inDict['metadata'] = metadata inDict['hasLinearity'] = metadata.get('HAS_LINEARITY', False) inDict['amplifiers'] = dict() for record in coeffTable: ampName = record['AMPLIFIER_NAME'] fitParams = record['FIT_PARAMS'] if 'FIT_PARAMS' in record.columns else np.array([0.0]) fitParamsErr = record['FIT_PARAMS_ERR'] if 'FIT_PARAMS_ERR' in record.columns else np.array([0.0]) fitChiSq = record['RED_CHI_SQ'] if 'RED_CHI_SQ' in record.columns else np.nan inDict['amplifiers'][ampName] = { 'linearityType': record['TYPE'], 'linearityCoeffs': record['COEFFS'], 'linearityBBox': Box2I(Point2I(record['BBOX_X0'], record['BBOX_Y0']), Extent2I(record['BBOX_DX'], record['BBOX_DY'])), 'fitParams': fitParams, 'fitParamsErr': fitParamsErr, 'fitChiSq': fitChiSq, } if len(tableList) > 1: tableData = tableList[1] inDict['tableData'] = [record['LOOKUP_VALUES'] for record in tableData] return cls().fromDict(inDict)
def setUp(self): dimensions = Extent2I(7, 7) self.bbox = Box2I(Point2I(-dimensions/2), dimensions) self.img = Image(self.bbox, dtype=np.float64) x, y = np.ogrid[-3:4, -3:4] rsqr = x**2 + y**2 # Some arbitrary circular double Gaussian self.img.array[:] = np.exp(-0.5*rsqr**2) + np.exp(-0.5*rsqr**2/4) self.img.array /= np.sum(self.img.array) self.psf = MyTestImagePsf(self.img)
def _doComputeKernelImage(self, position=None, color=None): bbox = Box2I(Point2I(-3, -3), Extent2I(7, 7)) img = Image(bbox, dtype=np.float64) x, y = np.ogrid[bbox.minY:bbox.maxY + 1, bbox.minX:bbox.maxX + 1] rsqr = x**2 + y**2 if position.x >= 0.0: img.array[:] = np.exp(-0.5 * rsqr) else: img.array[:] = np.exp(-0.5 * rsqr / 4) img.array /= np.sum(img.array) return img
def test_maskBlocks_not_enough_bad_pixels_in_column(self): """A test for maskBlocksIfIntermitentBadPixelsInColumn. Npix discontiguous bad pixels in a column where Npix < badOnAndOffPixelColumnThreshold (10) and and gaps of good pixels > goodPixelColumnGapThreshold (5). Since Npix < badOnAndOffPixelColumnThreshold, then it doesn't matter that the number of good pixels in gap > goodPixelColumnGapThreshold. 5<10 bad pixels total, 1 "good" gap big enough (29>=5 good pixels, from y =12 (10+2) to y=30) Plots can be found in DM-19903 on Jira. """ expectedDefects = [Box2I(corner=Point2I(45, 10), dimensions=Extent2I(1, 2)), Box2I(corner=Point2I(45, 30), dimensions=Extent2I(1, 3))] defects = self.allDefectsList badPixels = [Box2I(corner=Point2I(45, 10), dimensions=Extent2I(1, 2)), Box2I(corner=Point2I(45, 30), dimensions=Extent2I(1, 3))] for badBox in badPixels: defects.append(badBox) self.check_maskBlocks(defects, expectedDefects)
def run(md, **kwds2): kwds = extractCtorArgs(md) kwds['order'] = max(md["A_ORDER"], md["B_ORDER"], md["AP_ORDER"], md["BP_ORDER"]) kwds.update(kwds2) gridShape = Extent2I(10, 10) approx = SipApproximation(gridShape=gridShape, **kwds) diffs = approx.computeMaxDeviation() self.compareSolution(md, approx) self.assertLess(diffs[0], 1E-10) self.assertLess(diffs[1], 1E-10)
def numpyToStack(images, center, offset): """Convert numpy and python objects to stack objects """ cy, cx = center bands, height, width = images.shape x0, y0 = offset bbox = Box2I(Point2I(x0, y0), Extent2I(width, height)) spanset = SpanSet(bbox) foot = Footprint(spanset) foot.addPeak(cx + x0, cy + y0, images[:, cy, cx].max()) peak = foot.getPeaks()[0] return foot, peak, bbox
def runExposureCompositePutGetTest(self, storageClass, datasetTypeName): example = os.path.join(TESTDIR, "data", "basic", "small.fits") exposure = lsst.afw.image.ExposureF(example) butler = Butler(self.tmpConfigFile) dimensions = butler.registry.dimensions.extract( ["instrument", "visit"]) self.registerDatasetTypes(datasetTypeName, dimensions, storageClass, butler.registry) dataId = { "visit": 42, "instrument": "DummyCam", "physical_filter": "d-r" } # Add needed Dimensions butler.registry.addDimensionEntry("instrument", {"instrument": "DummyCam"}) butler.registry.addDimensionEntry("physical_filter", { "instrument": "DummyCam", "physical_filter": "d-r" }) butler.registry.addDimensionEntry("visit", { "instrument": "DummyCam", "visit": 42, "physical_filter": "d-r" }) butler.put(exposure, datasetTypeName, dataId) # Get the full thing butler.get(datasetTypeName, dataId) # TODO enable check for equality (fix for Exposure type) # self.assertEqual(full, exposure) # Get a component compsRead = {} for compName in ("wcs", "image", "mask", "coaddInputs", "psf"): compTypeName = DatasetType.nameWithComponent( datasetTypeName, compName) component = butler.get(compTypeName, dataId) # TODO enable check for component instance types # compRef = butler.registry.find(butler.run.collection, # f"calexp.{compName}", dataId) # self.assertIsInstance(component, # compRef.datasetType.storageClass.pytype) compsRead[compName] = component # Simple check of WCS bbox = Box2I(Point2I(0, 0), Extent2I(9, 9)) self.assertWcsAlmostEqualOverBBox(compsRead["wcs"], exposure.getWcs(), bbox) # With parameters inBBox = Box2I(minimum=Point2I(0, 0), maximum=Point2I(3, 3)) parameters = dict(bbox=inBBox, origin=LOCAL) subset = butler.get(datasetTypeName, dataId, parameters=parameters) outBBox = subset.getBBox() self.assertEqual(inBBox, outBBox)
def extractCtorArgs(md): wcs = makeSkyWcs(makePropertyListFromDict(md)) kwds = { "pixelToIwc": getPixelToIntermediateWorldCoords(wcs), "bbox": Box2D(Box2I(Point2I(0, 0), Extent2I(md["NAXES1"], md["NAXES2"]))), "crpix": Point2D(md["CRPIX1"] - 1.0, md["CRPIX2"] - 1.0), # -1 for LSST vs. FITS conventions "cd": np.array([[md["CD1_1"], md["CD1_2"]], [md["CD2_1"], md["CD2_2"]]]), } return kwds