def setUp(self): im = afwImage.ImageF(self.monetFile("small.fits")) self.mi = afwImage.MaskedImageF(im, afwImage.MaskU(im.getDimensions()), afwImage.ImageF(im.getDimensions())); self.ds = afwDetection.FootprintSet(self.mi, afwDetection.Threshold(100)) if display: ds9.mtv(self.mi.getImage()) ds9.erase() for foot in self.ds.getFootprints(): bbox = foot.getBBox() x0, y0 = bbox.getMinX(), bbox.getMinY() x1, y1 = bbox.getMaxX(), bbox.getMaxY() xc = (x0 + x1)/2.0 yc = (y0 + y1)/2.0 if display: ds9.dot("+", xc, yc, ctype=ds9.BLUE) if False: x0 -= 0.5; y0 -= 0.5 x1 += 0.5; y1 += 0.5 ds9.line([(x0, y0), (x1, y0), (x1, y1), (x0, y1), (x0, y0)], ctype=ds9.RED) self.control = algorithms.GaussianCentroidControl() schema = afwTable.SourceTable.makeMinimalSchema() self.centroider = algorithms.MeasureSourcesBuilder().addAlgorithm(self.control).build(schema) self.ssMeasured = afwTable.SourceCatalog(schema) self.ssMeasured.table.defineCentroid(self.control.name) self.ssTruth = afwTable.SourceCatalog(schema) self.readTruth(self.monetFile("positions.dat-original"))
def drawFootprint(foot, borderWidth=0.5, origin=None, frame=None, ctype=None, bin=1): """Draw an afwDetection::Footprint on a ds9 frame with the specified ctype. Include an extra borderWidth pixels If origin is present, it's Added to the Footprint All Footprint coordinates are divided by bin, as is right and proper for overlaying on a binned image """ ds9.cmdBuffer.pushSize() borderWidth /= bin for s in foot.getSpans(): y, x0, x1 = s.getY(), s.getX0(), s.getX1() if origin: x0 += origin[0]; x1 += origin[0] y += origin[1] x0 /= bin; x1 /= bin; y /= bin ds9.line([(x0 - borderWidth, y - borderWidth), (x0 - borderWidth, y + borderWidth), (x1 + borderWidth, y + borderWidth), (x1 + borderWidth, y - borderWidth), (x0 - borderWidth, y - borderWidth), ], frame=frame, ctype=ctype) ds9.cmdBuffer.popSize()
def display(self, xy0=None, frame=1, ctype=None): """Display polygon on existing frame in ds9""" import lsst.afw.geom as afwGeom import lsst.afw.display.ds9 as ds9 xy0 = afwGeom.Extent2D(0, 0) if xy0 is None else afwGeom.Extent2D(xy0) with ds9.Buffering(): for p1, p2 in self.getEdges(): ds9.line((p1 - xy0, p2 - xy0), frame=frame, ctype=ctype)
def displayDipoles(self, exposure, sources): """!Display debugging information on the detected dipoles @param exposure Image the dipoles were measured on @param sources The set of diaSources that were measured""" import lsstDebug display = lsstDebug.Info(__name__).display displayDiaSources = lsstDebug.Info(__name__).displayDiaSources maskTransparency = lsstDebug.Info(__name__).maskTransparency if not maskTransparency: maskTransparency = 90 ds9.setMaskTransparency(maskTransparency) ds9.mtv(exposure, frame=lsstDebug.frame) if display and displayDiaSources: with ds9.Buffering(): for source in sources: cenX, cenY = source.get("ipdiffim_DipolePsfFlux_centroid") if np.isinf(cenX) or np.isinf(cenY): cenX, cenY = source.getCentroid() isdipole = source.get("classification.dipole") if isdipole and np.isfinite(isdipole): # Dipole ctype = "green" else: # Not dipole ctype = "red" ds9.dot("o", cenX, cenY, size=2, ctype=ctype, frame=lsstDebug.frame) negCenX = source.get( "ip_diffim_PsfDipoleFlux_neg_centroid_x") negCenY = source.get( "ip_diffim_PsfDipoleFlux_neg_centroid_y") posCenX = source.get( "ip_diffim_PsfDipoleFlux_pos_centroid_x") posCenY = source.get( "ip_diffim_PsfDipoleFlux_pos_centroid_y") if (np.isinf(negCenX) or np.isinf(negCenY) or np.isinf(posCenX) or np.isinf(posCenY)): continue ds9.line([(negCenX, negCenY), (posCenX, posCenY)], ctype="yellow", frame=lsstDebug.frame) lsstDebug.frame += 1
def testDrawing(self): """Test drawing lines and glyphs""" ds9.erase() exp = afwImage.ExposureF(300, 350) ds9.mtv(exp, title="parent") # tells display0 about the image's xy0 with ds9.Buffering(): ds9.dot('o', 200, 220) vertices = [(200, 220), (210, 230), (224, 230), (214, 220), (200, 220)] ds9.line(vertices, ctype=ds9.CYAN) ds9.line(vertices[:-1], symbs="+x+x", size=3)
def testImage(self): """Test Polygon.createImage""" for i, num in enumerate(range(3, 30)): poly = self.polygon(num, 25, 75, 75) box = afwGeom.Box2I(afwGeom.Point2I(15, 15), afwGeom.Extent2I(115, 115)) image = poly.createImage(box) if DEBUG: import lsst.afw.display.ds9 as ds9 ds9.mtv(image, frame=i+1, title="Polygon nside=%d" % num) for p1, p2 in poly.getEdges(): ds9.line((p1, p2), frame=i+1) self.assertAlmostEqual(image.getArray().sum()/poly.calculateArea(), 1.0, 6)
def getBackground(image, backgroundConfig, nx=0, ny=0, algorithm=None): """ Make a new Exposure which is exposure - background """ backgroundConfig.validate() if not nx: nx = image.getWidth() // backgroundConfig.binSize + 1 if not ny: ny = image.getHeight() // backgroundConfig.binSize + 1 displayBackground = lsstDebug.Info(__name__).displayBackground if displayBackground: import itertools ds9.mtv(image, frame=1) xPosts = numpy.rint( numpy.linspace(0, image.getWidth() + 1, num=nx, endpoint=True)) yPosts = numpy.rint( numpy.linspace(0, image.getHeight() + 1, num=ny, endpoint=True)) with ds9.Buffering(): for (xMin, xMax), (yMin, yMax) in itertools.product( zip(xPosts[:-1], xPosts[1:]), zip(yPosts[:-1], yPosts[1:])): ds9.line([(xMin, yMin), (xMin, yMax), (xMax, yMax), (xMax, yMin), (xMin, yMin)], frame=1) sctrl = afwMath.StatisticsControl() sctrl.setAndMask( reduce(lambda x, y: x | image.getMask().getPlaneBitMask(y), backgroundConfig.ignoredPixelMask, 0x0)) sctrl.setNanSafe(backgroundConfig.isNanSafe) pl = pexLogging.Debug("meas.utils.sourceDetection.getBackground") pl.debug( 3, "Ignoring mask planes: %s" % ", ".join(backgroundConfig.ignoredPixelMask)) if not algorithm: algorithm = backgroundConfig.algorithm bctrl = afwMath.BackgroundControl(algorithm, nx, ny, backgroundConfig.undersampleStyle, sctrl, backgroundConfig.statisticsProperty) if backgroundConfig.useApprox: actrl = afwMath.ApproximateControl( afwMath.ApproximateControl.CHEBYSHEV, backgroundConfig.approxOrder) bctrl.setApproximateControl(actrl) return afwMath.makeBackground(image, bctrl)
def testImage(self): """Test Polygon.createImage""" for i, num in enumerate(range(3, 30)): poly = self.polygon(num, 25, 75, 75) box = afwGeom.Box2I(afwGeom.Point2I(15, 15), afwGeom.Extent2I(115, 115)) image = poly.createImage(box) if DEBUG: import lsst.afw.display.ds9 as ds9 ds9.mtv(image, frame=i + 1, title="Polygon nside=%d" % num) for p1, p2 in poly.getEdges(): ds9.line((p1, p2), frame=i + 1) self.assertAlmostEqual( image.getArray().sum() / poly.calculateArea(), 1.0, 6)
def setUp(self): im = afwImage.ImageF(self.monetFile("small.fits")) self.mi = afwImage.MaskedImageF(im, afwImage.Mask(im.getDimensions()), afwImage.ImageF(im.getDimensions())) self.ds = afwDetection.FootprintSet(self.mi, afwDetection.Threshold(100)) if display: ds9.mtv(self.mi.getImage()) ds9.erase() for foot in self.ds.getFootprints(): bbox = foot.getBBox() x0, y0 = bbox.getMinX(), bbox.getMinY() x1, y1 = bbox.getMaxX(), bbox.getMaxY() xc = (x0 + x1) / 2.0 yc = (y0 + y1) / 2.0 if display: ds9.dot("+", xc, yc, ctype=ds9.BLUE) if False: x0 -= 0.5 y0 -= 0.5 x1 += 0.5 y1 += 0.5 ds9.line([(x0, y0), (x1, y0), (x1, y1), (x0, y1), (x0, y0)], ctype=ds9.RED) msConfig = measBase.SingleFrameMeasurementConfig() msConfig.algorithms.names = ["base_GaussianCentroid"] msConfig.plugins["base_GaussianCentroid"].doFootprintCheck = False msConfig.slots.centroid = "base_GaussianCentroid" msConfig.slots.shape = None msConfig.slots.apFlux = None msConfig.slots.modelFlux = None msConfig.slots.psfFlux = None msConfig.slots.instFlux = None msConfig.slots.calibFlux = None schema = afwTable.SourceTable.makeMinimalSchema() self.task = measBase.SingleFrameMeasurementTask(schema, config=msConfig) self.ssMeasured = afwTable.SourceCatalog(schema) self.ssMeasured.table.defineCentroid("base_GaussianCentroid") self.ssTruth = afwTable.SourceCatalog(schema) self.ssTruth.table.defineCentroid("base_GaussianCentroid") self.readTruth(self.monetFile("positions.dat-original"))
def measureExposure(self, exposure, positions, title="Fringe"): """Measure fringe amplitudes for an exposure The fringe amplitudes are measured as the statistic within a square aperture. The statistic within a larger aperture are subtracted so as to remove the background. @param exposure Exposure to measure @param positions Array of (x,y) for fringe measurement @param title Title for display @return Array of fringe measurements """ stats = afwMath.StatisticsControl() stats.setNumSigmaClip(self.config.stats.clip) stats.setNumIter(self.config.stats.iterations) stats.setAndMask(exposure.getMaskedImage().getMask().getPlaneBitMask( self.config.stats.badMaskPlanes)) num = self.config.num fringes = numpy.ndarray(num) for i in range(num): x, y = positions[i] small = measure(exposure.getMaskedImage(), x, y, self.config.small, self.config.stats.stat, stats) large = measure(exposure.getMaskedImage(), x, y, self.config.large, self.config.stats.stat, stats) fringes[i] = small - large import lsstDebug display = lsstDebug.Info(__name__).display if display: frame = getFrame() ds9.mtv(exposure, frame=frame, title=title) if False: with ds9.Buffering(): for x, y in positions: corners = numpy.array([[-1, -1], [1, -1], [1, 1], [-1, 1], [-1, -1]]) + [[x, y]] ds9.line(corners * self.config.small, frame=frame, ctype="green") ds9.line(corners * self.config.large, frame=frame, ctype="blue") return fringes
def testFootprintToBBoxList(self): """Test footprintToBBoxList""" region = afwGeom.Box2I(afwGeom.Point2I(0, 0), afwGeom.Extent2I(12, 10)) foot = afwDetect.Footprint(0, region) for y, x0, x1 in [ (3, 3, 5), (3, 7, 7), (4, 2, 3), (4, 5, 7), (5, 2, 3), (5, 5, 8), (6, 3, 5), ]: foot.addSpan(y, x0, x1) idImage = afwImage.ImageU(region.getDimensions()) idImage.set(0) foot.insertIntoImage(idImage, 1) if display: ds9.mtv(idImage) idImageFromBBox = idImage.Factory(idImage, True) idImageFromBBox.set(0) bboxes = afwDetect.footprintToBBoxList(foot) for bbox in bboxes: x0, y0, x1, y1 = bbox.getMinX(), bbox.getMinY(), bbox.getMaxX( ), bbox.getMaxY() for y in range(y0, y1 + 1): for x in range(x0, x1 + 1): idImageFromBBox.set(x, y, 1) if display: x0 -= 0.5 y0 -= 0.5 x1 += 0.5 y1 += 0.5 ds9.line([(x0, y0), (x1, y0), (x1, y1), (x0, y1), (x0, y0)], ctype=ds9.RED) idImageFromBBox -= idImage # should be blank stats = afwMath.makeStatistics(idImageFromBBox, afwMath.MAX) self.assertEqual(stats.getValue(), 0)
def testCandidateList(self): if False and display: ds9.mtv(self.mi) for cell in self.cellSet.getCellList(): x0, y0, x1, y1 = (cell.getBBox().getX0(), cell.getBBox().getY0(), cell.getBBox().getX1(), cell.getBBox().getY1()) print((x0, y0, " ", x1, y1)) x0 -= 0.5 y0 -= 0.5 x1 += 0.5 y1 += 0.5 ds9.line([(x0, y0), (x1, y0), (x1, y1), (x0, y1), (x0, y0)], ctype=ds9.RED) self.assertFalse(self.cellSet.getCellList()[0].empty()) self.assertTrue(self.cellSet.getCellList()[1].empty()) self.assertFalse(self.cellSet.getCellList()[2].empty()) stamps = [] for cell in self.cellSet.getCellList(): for cand in cell: # # Swig doesn't know that we PsfCandidate; all it knows is # that we have a SpatialCellCandidate, and # SpatialCellCandidates don't know about getMaskedImage; so # cast the pointer to PsfCandidate<float> and all will be well # cand = algorithms.PsfCandidateF.cast(cell[0]) width, height = 15, 17 cand.setWidth(width) cand.setHeight(height) im = cand.getMaskedImage() stamps.append(im) self.assertEqual(im.getWidth(), width) self.assertEqual(im.getHeight(), height) if display: mos = displayUtils.Mosaic() ds9.mtv(mos.makeMosaic(stamps), frame=1)
def getBackground(image, backgroundConfig, nx=0, ny=0, algorithm=None): """ Make a new Exposure which is exposure - background """ backgroundConfig.validate(); if not nx: nx = image.getWidth()//backgroundConfig.binSize + 1 if not ny: ny = image.getHeight()//backgroundConfig.binSize + 1 displayBackground = lsstDebug.Info(__name__).displayBackground if displayBackground: import itertools ds9.mtv(image, frame=1) xPosts = numpy.rint(numpy.linspace(0, image.getWidth() + 1, num=nx, endpoint=True)) yPosts = numpy.rint(numpy.linspace(0, image.getHeight() + 1, num=ny, endpoint=True)) with ds9.Buffering(): for (xMin, xMax), (yMin, yMax) in itertools.product(zip(xPosts[:-1], xPosts[1:]), zip(yPosts[:-1], yPosts[1:])): ds9.line([(xMin, yMin), (xMin, yMax), (xMax, yMax), (xMax, yMin), (xMin, yMin)], frame=1) sctrl = afwMath.StatisticsControl() sctrl.setAndMask(reduce(lambda x, y: x | image.getMask().getPlaneBitMask(y), backgroundConfig.ignoredPixelMask, 0x0)) sctrl.setNanSafe(backgroundConfig.isNanSafe) pl = pexLogging.Debug("meas.utils.sourceDetection.getBackground") pl.debug(3, "Ignoring mask planes: %s" % ", ".join(backgroundConfig.ignoredPixelMask)) if not algorithm: algorithm = backgroundConfig.algorithm bctrl = afwMath.BackgroundControl(algorithm, nx, ny, backgroundConfig.undersampleStyle, sctrl, backgroundConfig.statisticsProperty) if backgroundConfig.useApprox: actrl = afwMath.ApproximateControl(afwMath.ApproximateControl.CHEBYSHEV, backgroundConfig.approxOrder) bctrl.setApproximateControl(actrl) return afwMath.makeBackground(image, bctrl)
def drawFootprint(foot, borderWidth=0.5, origin=None, XY0=None, frame=None, ctype=None, bin=1, peaks=False, symb="+", size=0.4, ctypePeak=None): """Draw an afwDetection::Footprint on a ds9 frame with the specified ctype. Include an extra borderWidth pixels If origin is present, it's Added to the Footprint; if XY0 is present is Subtracted from the Footprint If peaks is True, also show the object's Peaks using the specified symbol and size and ctypePeak All Footprint coordinates are divided by bin, as is right and proper for overlaying on a binned image """ if XY0: if origin: raise RuntimeError("You may not specify both origin and XY0") origin = (-XY0[0], -XY0[1]) with ds9.Buffering(): borderWidth /= bin for s in foot.getSpans(): y, x0, x1 = s.getY(), s.getX0(), s.getX1() if origin: x0 += origin[0]; x1 += origin[0] y += origin[1] x0 /= bin; x1 /= bin; y /= bin ds9.line([(x0 - borderWidth, y - borderWidth), (x0 - borderWidth, y + borderWidth), (x1 + borderWidth, y + borderWidth), (x1 + borderWidth, y - borderWidth), (x0 - borderWidth, y - borderWidth), ], frame=frame, ctype=ctype) if peaks: for p in foot.getPeaks(): x, y = p.getIx(), p.getIy() if origin: x += origin[0]; y += origin[1] x /= bin; y /= bin ds9.dot(symb, x, y, size=size, ctype=ctypePeak, frame=frame)
def testCandidateList(self): if False and display: ds9.mtv(self.mi) for cell in self.cellSet.getCellList(): x0, y0, x1, y1 = ( cell.getBBox().getX0(), cell.getBBox().getY0(), cell.getBBox().getX1(), cell.getBBox().getY1()) print x0, y0, " ", x1, y1 x0 -= 0.5 y0 -= 0.5 x1 += 0.5 y1 += 0.5 ds9.line([(x0, y0), (x1, y0), (x1, y1), (x0, y1), (x0, y0)], ctype=ds9.RED) self.assertFalse(self.cellSet.getCellList()[0].empty()) self.assertTrue(self.cellSet.getCellList()[1].empty()) self.assertFalse(self.cellSet.getCellList()[2].empty()) stamps = [] for cell in self.cellSet.getCellList(): for cand in cell: # # Swig doesn't know that we inherited from SpatialCellMaskedImageCandidate; all # it knows is that we have a SpatialCellCandidate, and SpatialCellCandidates # don't know about getMaskedImage; so cast the pointer to # SpatialCellMaskedImageCandidate<float> and all will be well # cand = afwMath.cast_SpatialCellMaskedImageCandidateF(cell[0]) width, height = 15, 17 cand.setWidth(width) cand.setHeight(height) im = cand.getMaskedImage() stamps.append(im) self.assertEqual(im.getWidth(), width) self.assertEqual(im.getHeight(), height) if display: mos = displayUtils.Mosaic() ds9.mtv(mos.makeMosaic(stamps), frame=1)
def drawCoaddInputs(exposure, frame=None, ctype=None, bin=1): """Draw the bounding boxes of input exposures to a coadd on a ds9 frame with the specified ctype, assuming ds9.mtv() has already been called on the given exposure on this frame. All coordinates are divided by bin, as is right and proper for overlaying on a binned image """ coaddWcs = exposure.getWcs() catalog = exposure.getInfo().getCoaddInputs().ccds offset = afwGeom.Point2D() - afwGeom.Point2D(exposure.getXY0()) with ds9.Buffering(): for record in catalog: ccdBox = afwGeom.Box2D(record.getBBox()) ccdCorners = ccdBox.getCorners() coaddCorners = [coaddWcs.skyToPixel(record.getWcs().pixelToSky(point)) + offset for point in ccdCorners] ds9.line([(coaddCorners[i].getX() / bin, coaddCorners[i].getY() / bin) for i in range(-1, 4)], frame=frame, ctype=ctype)
def setUp(self): im = afwImage.ImageF(self.monetFile("small.fits")) self.mi = afwImage.MaskedImageF(im, afwImage.MaskU(im.getDimensions()), afwImage.ImageF(im.getDimensions())); self.ds = afwDetection.FootprintSet(self.mi, afwDetection.Threshold(100)) if display: ds9.mtv(self.mi.getImage()) ds9.erase() for foot in self.ds.getFootprints(): bbox = foot.getBBox() x0, y0 = bbox.getMinX(), bbox.getMinY() x1, y1 = bbox.getMaxX(), bbox.getMaxY() xc = (x0 + x1)/2.0 yc = (y0 + y1)/2.0 if display: ds9.dot("+", xc, yc, ctype=ds9.BLUE) if False: x0 -= 0.5; y0 -= 0.5 x1 += 0.5; y1 += 0.5 ds9.line([(x0, y0), (x1, y0), (x1, y1), (x0, y1), (x0, y0)], ctype=ds9.RED) msConfig = measBase.SingleFrameMeasurementConfig() msConfig.algorithms.names = ["base_GaussianCentroid"] msConfig.slots.centroid = "base_GaussianCentroid" msConfig.slots.shape = None msConfig.slots.apFlux = None msConfig.slots.modelFlux = None msConfig.slots.psfFlux = None msConfig.slots.instFlux = None msConfig.slots.calibFlux = None schema = afwTable.SourceTable.makeMinimalSchema() self.task = measBase.SingleFrameMeasurementTask(schema, config=msConfig) self.ssMeasured = afwTable.SourceCatalog(schema) self.ssMeasured.table.defineCentroid("base_GaussianCentroid") self.ssTruth = afwTable.SourceCatalog(schema) self.ssTruth.table.defineCentroid("base_GaussianCentroid") self.readTruth(self.monetFile("positions.dat-original"))
def displayDipoles(self, exposure, sources): """!Display debugging information on the detected dipoles @param exposure Image the dipoles were measured on @param sources The set of diaSources that were measured""" import lsstDebug display = lsstDebug.Info(__name__).display displayDiaSources = lsstDebug.Info(__name__).displayDiaSources maskTransparency = lsstDebug.Info(__name__).maskTransparency if not maskTransparency: maskTransparency = 90 ds9.setMaskTransparency(maskTransparency) ds9.mtv(exposure, frame=lsstDebug.frame) if display and displayDiaSources: with ds9.Buffering(): for source in sources: cenX, cenY = source.get("ipdiffim_DipolePsfFlux_centroid") if np.isinf(cenX) or np.isinf(cenY): cenX, cenY = source.getCentroid() isdipole = source.get("classification.dipole") if isdipole and np.isfinite(isdipole): # Dipole ctype= "green" else: # Not dipole ctype = "red" ds9.dot("o", cenX, cenY, size=2, ctype=ctype, frame=lsstDebug.frame) negCenX = source.get("ip_diffim_PsfDipoleFlux_neg_centroid_x") negCenY = source.get("ip_diffim_PsfDipoleFlux_neg_centroid_y") posCenX = source.get("ip_diffim_PsfDipoleFlux_pos_centroid_x") posCenY = source.get("ip_diffim_PsfDipoleFlux_pos_centroid_y") if (np.isinf(negCenX) or np.isinf(negCenY) or np.isinf(posCenX) or np.isinf(posCenY)): continue ds9.line([(negCenX, negCenY), (posCenX, posCenY)], ctype="yellow", frame=lsstDebug.frame) lsstDebug.frame += 1
def testFootprintToBBoxList(self): """Test footprintToBBoxList""" region = afwGeom.Box2I(afwGeom.Point2I(0,0), afwGeom.Extent2I(12,10)) foot = afwDetect.Footprint(0, region) for y, x0, x1 in [(3, 3, 5), (3, 7, 7), (4, 2, 3), (4, 5, 7), (5, 2, 3), (5, 5, 8), (6, 3, 5), ]: foot.addSpan(y, x0, x1) idImage = afwImage.ImageU(region.getDimensions()) idImage.set(0) foot.insertIntoImage(idImage, 1) if display: ds9.mtv(idImage) idImageFromBBox = idImage.Factory(idImage, True) idImageFromBBox.set(0) bboxes = afwDetect.footprintToBBoxList(foot) for bbox in bboxes: x0, y0, x1, y1 = bbox.getMinX(), bbox.getMinY(), bbox.getMaxX(), bbox.getMaxY() for y in range(y0, y1 + 1): for x in range(x0, x1 + 1): idImageFromBBox.set(x, y, 1) if display: x0 -= 0.5 y0 -= 0.5 x1 += 0.5 y1 += 0.5 ds9.line([(x0, y0), (x1, y0), (x1, y1), (x0, y1), (x0, y0)], ctype=ds9.RED) idImageFromBBox -= idImage # should be blank stats = afwMath.makeStatistics(idImageFromBBox, afwMath.MAX) self.assertEqual(stats.getValue(), 0)
def testCandidateList(self): if False and display: ds9.mtv(self.mi) for cell in self.cellSet.getCellList(): x0, y0, x1, y1 = (cell.getBBox().getX0(), cell.getBBox().getY0(), cell.getBBox().getX1(), cell.getBBox().getY1()) print((x0, y0, " ", x1, y1)) x0 -= 0.5 y0 -= 0.5 x1 += 0.5 y1 += 0.5 ds9.line([(x0, y0), (x1, y0), (x1, y1), (x0, y1), (x0, y0)], ctype=ds9.RED) self.assertFalse(self.cellSet.getCellList()[0].empty()) self.assertTrue(self.cellSet.getCellList()[1].empty()) self.assertFalse(self.cellSet.getCellList()[2].empty()) stamps = [] for cell in self.cellSet.getCellList(): for cand in cell: cand = cell[0] width, height = 15, 17 cand.setWidth(width) cand.setHeight(height) im = cand.getMaskedImage() stamps.append(im) self.assertEqual(im.getWidth(), width) self.assertEqual(im.getHeight(), height) if display: mos = displayUtils.Mosaic() ds9.mtv(mos.makeMosaic(stamps), frame=1)
def measureExposure(self, exposure, positions, title="Fringe"): """Measure fringe amplitudes for an exposure The fringe amplitudes are measured as the statistic within a square aperture. The statistic within a larger aperture are subtracted so as to remove the background. @param exposure Exposure to measure @param positions Array of (x,y) for fringe measurement @param title Title for display @return Array of fringe measurements """ stats = afwMath.StatisticsControl() stats.setNumSigmaClip(self.config.stats.clip) stats.setNumIter(self.config.stats.iterations) stats.setAndMask(exposure.getMaskedImage().getMask().getPlaneBitMask(self.config.stats.badMaskPlanes)) num = self.config.num fringes = numpy.ndarray(num) for i in range(num): x, y = positions[i] small = measure(exposure.getMaskedImage(), x, y, self.config.small, self.config.stats.stat, stats) large = measure(exposure.getMaskedImage(), x, y, self.config.large, self.config.stats.stat, stats) fringes[i] = small - large import lsstDebug display = lsstDebug.Info(__name__).display if display: frame = getFrame() ds9.mtv(exposure, frame=frame, title=title) if False: with ds9.Buffering(): for x,y in positions: corners = numpy.array([[-1, -1], [ 1, -1], [ 1, 1], [-1, 1], [-1, -1]]) + [[x, y]] ds9.line(corners * self.config.small, frame=frame, ctype="green") ds9.line(corners * self.config.large, frame=frame, ctype="blue") return fringes
def setUp(self): im = afwImage.ImageF(self.monetFile("small.fits")) self.mi = afwImage.MaskedImageF(im, afwImage.MaskU(im.getDimensions()), afwImage.ImageF(im.getDimensions())) self.ds = afwDetection.FootprintSet(self.mi, afwDetection.Threshold(100)) if display: ds9.mtv(self.mi.getImage()) ds9.erase() for foot in self.ds.getFootprints(): bbox = foot.getBBox() x0, y0 = bbox.getMinX(), bbox.getMinY() x1, y1 = bbox.getMaxX(), bbox.getMaxY() xc = (x0 + x1) / 2.0 yc = (y0 + y1) / 2.0 if display: ds9.dot("+", xc, yc, ctype=ds9.BLUE) if False: x0 -= 0.5 y0 -= 0.5 x1 += 0.5 y1 += 0.5 ds9.line([(x0, y0), (x1, y0), (x1, y1), (x0, y1), (x0, y0)], ctype=ds9.RED) self.control = algorithms.GaussianCentroidControl() schema = afwTable.SourceTable.makeMinimalSchema() self.centroider = algorithms.MeasureSourcesBuilder().addAlgorithm( self.control).build(schema) self.ssMeasured = afwTable.SourceCatalog(schema) self.ssMeasured.table.defineCentroid(self.control.name) self.ssTruth = afwTable.SourceCatalog(schema) self.readTruth(self.monetFile("positions.dat-original"))
def drawBBox(bbox, borderWidth=0.0, origin=None, frame=None, ctype=None, bin=1): """Draw an afwImage::BBox on a ds9 frame with the specified ctype. Include an extra borderWidth pixels If origin is present, it's Added to the BBox All BBox coordinates are divided by bin, as is right and proper for overlaying on a binned image """ x0, y0 = bbox.getMinX(), bbox.getMinY() x1, y1 = bbox.getMaxX(), bbox.getMaxY() if origin: x0 += origin[0]; x1 += origin[0] y0 += origin[1]; y1 += origin[1] x0 /= bin; y0 /= bin x1 /= bin; y1 /= bin borderWidth /= bin ds9.line([(x0 - borderWidth, y0 - borderWidth), (x0 - borderWidth, y1 + borderWidth), (x1 + borderWidth, y1 + borderWidth), (x1 + borderWidth, y0 - borderWidth), (x0 - borderWidth, y0 - borderWidth), ], frame=frame, ctype=ctype)
size = 1.6 # half-size of box to draw with ds9.Buffering(): for ev, success in zip(events, status): if not success: if display and (ev.grade == -1 and displayUnknown or ev.grade >= 0 and displayRejects): ds9.dot("+", ev.x, ev.y, size=0.5, ctype=ctypes[ev.grade]) if displayGrades: ds9.dot(str(ev.grade), ev.x + 1.5, ev.y, frame=0, ctype=ctypes[ev.grade]) continue if display: ds9.line([(ev.x - size, ev.y - size), (ev.x + size, ev.y - size), (ev.x + size, ev.y + size), (ev.x - size, ev.y + size), (ev.x - size, ev.y - size)], frame=0, ctype=ctypes[ev.grade]) if displayGrades: ds9.dot(str(ev.grade), ev.x + size + 1, ev.y - size, frame=0, ctype=ctypes[ev.grade]) if outputHistFile: with open(outputHistFile, "w") as fd: table.dump_head(fd, "unknown", sum(status)) table.dump_hist(fd) #table.dump_table() if plot: fe55.plot_hist({None : table}, title="Event = %g Split = %g Source = %s" % (thresh, split, "unknown"), subplots=subplots)
def testDetection(self): """Test CR detection.""" # # Subtract background # bctrl = afwMath.BackgroundControl(afwMath.Interpolate.NATURAL_SPLINE) bctrl.setNxSample(int(self.mi.getWidth() / 256) + 1) bctrl.setNySample(int(self.mi.getHeight() / 256) + 1) bctrl.getStatisticsControl().setNumSigmaClip(3.0) bctrl.getStatisticsControl().setNumIter(2) im = self.mi.getImage() try: backobj = afwMath.makeBackground(im, bctrl) except Exception as e: print >> sys.stderr, e, bctrl.setInterpStyle(afwMath.Interpolate.CONSTANT) backobj = afwMath.makeBackground(im, bctrl) im -= backobj.getImageF() if display: frame = 0 ds9.mtv(self.mi, frame=frame, title="Raw") # raw frame if self.mi.getWidth() > 256: ds9.pan(944 - self.mi.getX0(), 260 - self.mi.getY0()) # # Mask known bad pixels # measAlgorithmsDir = lsst.utils.getPackageDir('meas_algorithms') badPixels = defects.policyToBadRegionList( os.path.join(measAlgorithmsDir, "policy", "BadPixels.paf")) # did someone lie about the origin of the maskedImage? If so, adjust bad pixel list if self.XY0.getX() != self.mi.getX0() or self.XY0.getY( ) != self.mi.getY0(): dx = self.XY0.getX() - self.mi.getX0() dy = self.XY0.getY() - self.mi.getY0() for bp in badPixels: bp.shift(-dx, -dy) algorithms.interpolateOverDefects(self.mi, self.psf, badPixels) stats = afwMath.makeStatistics(self.mi.getImage(), afwMath.MEANCLIP | afwMath.STDEVCLIP) background = stats.getValue(afwMath.MEANCLIP) crConfig = algorithms.FindCosmicRaysConfig() crs = algorithms.findCosmicRays(self.mi, self.psf, background, pexConfig.makePolicy(crConfig)) if display: ds9.mtv(self.mi, frame=frame + 1, title="CRs removed") if self.mi.getWidth() > 256: ds9.pan(944 - self.mi.getX0(), 260 - self.mi.getY0()) print("Detected %d CRs" % len(crs)) if display and False: for cr in crs: bbox = cr.getBBox() bbox.shift(afwGeom.ExtentI(-self.mi.getX0(), -self.mi.getY0())) ds9.line([(bbox.getMinX() - 0.5, bbox.getMinY() - 0.5), (bbox.getMaxX() + 0.5, bbox.getMinY() - 0.5), (bbox.getMaxX() + 0.5, bbox.getMaxY() + 0.5), (bbox.getMinX() - 0.5, bbox.getMaxY() + 0.5), (bbox.getMinX() - 0.5, bbox.getMinY() - 0.5)], frame=frame + 1) if self.nCR is not None: self.assertEqual(len(crs), self.nCR)
def getBackground(image, backgroundConfig, nx=0, ny=0, algorithm=None): """!Estimate the background of an image (a thin layer on lsst.afw.math.makeBackground) \param[in] image image whose background is to be computed \param[in] backgroundConfig configuration (a BackgroundConfig) \param[in] nx number of x bands; 0 for default \param[in] ny number of y bands; 0 for default \param[in] algorithm name of interpolation algorithm; see lsst.afw.math.BackgroundControl for details """ backgroundConfig.validate(); logger = pexLogging.getDefaultLog() logger = pexLogging.Log(logger,"lsst.meas.algorithms.detection.getBackground") if not nx: nx = image.getWidth()//backgroundConfig.binSize + 1 if not ny: ny = image.getHeight()//backgroundConfig.binSize + 1 displayBackground = lsstDebug.Info(__name__).displayBackground if displayBackground: import itertools ds9.mtv(image, frame=1) xPosts = numpy.rint(numpy.linspace(0, image.getWidth() + 1, num=nx, endpoint=True)) yPosts = numpy.rint(numpy.linspace(0, image.getHeight() + 1, num=ny, endpoint=True)) with ds9.Buffering(): for (xMin, xMax), (yMin, yMax) in itertools.product(zip(xPosts[:-1], xPosts[1:]), zip(yPosts[:-1], yPosts[1:])): ds9.line([(xMin, yMin), (xMin, yMax), (xMax, yMax), (xMax, yMin), (xMin, yMin)], frame=1) sctrl = afwMath.StatisticsControl() sctrl.setAndMask(reduce(lambda x, y: x | image.getMask().getPlaneBitMask(y), backgroundConfig.ignoredPixelMask, 0x0)) sctrl.setNanSafe(backgroundConfig.isNanSafe) pl = pexLogging.Debug("lsst.meas.algorithms.detection.getBackground") pl.debug(3, "Ignoring mask planes: %s" % ", ".join(backgroundConfig.ignoredPixelMask)) if not algorithm: algorithm = backgroundConfig.algorithm bctrl = afwMath.BackgroundControl(algorithm, nx, ny, backgroundConfig.undersampleStyle, sctrl, backgroundConfig.statisticsProperty) # TODO: The following check should really be done within afw/math. With the # current code structure, it would need to be accounted for in the # doGetImage() funtion in BackgroundMI.cc (which currently only checks # against the interpoation settings which is not appropriate when # useApprox=True) and/or the makeApproximate() function in # afw/Approximate.cc. # See ticket DM-2920: "Clean up code in afw for Approximate background # estimation" (which includes a note to remove the following and the # similar checks in pipe_tasks/matchBackgrounds.py once implemented) # # Check that config setting of approxOrder/binSize make sense # (i.e. ngrid (= shortDimension/binSize) > approxOrderX) and perform # appropriate undersampleStlye behavior. if backgroundConfig.useApprox: if not backgroundConfig.approxOrderY in (backgroundConfig.approxOrderX,-1): raise ValueError("Error: approxOrderY not in (approxOrderX, -1)") order = backgroundConfig.approxOrderX minNumberGridPoints = backgroundConfig.approxOrderX + 1 if min(nx,ny) <= backgroundConfig.approxOrderX: logger.warn("Too few points in grid to constrain fit: min(nx, ny) < approxOrder) "+ "[min(%d, %d) < %d]" % (nx, ny, backgroundConfig.approxOrderX)) if backgroundConfig.undersampleStyle == "THROW_EXCEPTION": raise ValueError("Too few points in grid (%d, %d) for order (%d) and binsize (%d)" % ( nx, ny, backgroundConfig.approxOrderX, backgroundConfig.binSize)) elif backgroundConfig.undersampleStyle == "REDUCE_INTERP_ORDER": if order < 1: raise ValueError("Cannot reduce approxOrder below 0. " + "Try using undersampleStyle = \"INCREASE_NXNYSAMPLE\" instead?") order = min(nx, ny) - 1 logger.warn("Reducing approxOrder to %d" % order) elif backgroundConfig.undersampleStyle == "INCREASE_NXNYSAMPLE": newBinSize = min(image.getWidth(),image.getHeight())//(minNumberGridPoints-1) if newBinSize < 1: raise ValueError("Binsize must be greater than 0") newNx = image.getWidth()//newBinSize + 1 newNy = image.getHeight()//newBinSize + 1 bctrl.setNxSample(newNx) bctrl.setNySample(newNy) logger.warn("Decreasing binSize from %d to %d for a grid of (%d, %d)" % (backgroundConfig.binSize, newBinSize, newNx, newNy)) actrl = afwMath.ApproximateControl(afwMath.ApproximateControl.CHEBYSHEV, order, order, backgroundConfig.weighting) bctrl.setApproximateControl(actrl) return afwMath.makeBackground(image, bctrl)
def run(ioMgr, frameId, ccdId, config, display=False): data = {'visit': frameId, 'ccd':ccdId} raws = ioMgr.readRaw(data)[0] wcsIn = raws.getWcs() exposure = ioMgr.read('calexp', data, ignore=True)[0] wcsTrue = exposure.getWcs() exposure.setWcs(wcsIn) if display: ds9.mtv(exposure, frame=1) bscSet = ioMgr.read('bsc', data, ignore=True)[0].getSources() srcSet = [s for s in bscSet if goodStar(s)] print "# of srcSet: ", len(srcSet) distConfig = config['distortion'] ccd = pipUtil.getCcd(exposure) dist = pipDist.createDistortion(ccd, distConfig) distSrc = dist.actualToIdeal(srcSet) if display: for (s, d) in zip(srcSet, distSrc): xs = s.getXAstrom() ys = s.getYAstrom() xd = d.getXAstrom() yd = d.getYAstrom() #ds9.dot("o", xs, ys, size=10, frame=1) #ds9.dot("o", xd, yd, size=10, frame=1, ctype=ds9.RED) #ds9.line([[xs,ys], [xd,yd]], frame=1) xMin, xMax, yMin, yMax = float("INF"), float("-INF"), float("INF"), float("-INF") for x, y in ((0.0, 0.0), (0.0, exposure.getHeight()), (exposure.getWidth(), 0.0), (exposure.getWidth(), exposure.getHeight())): point = afwGeom.Point2D(x, y) point = dist.actualToIdeal(point) x, y = point.getX(), point.getY() if x < xMin: xMin = x if x > xMax: xMax = x if y < yMin: yMin = y if y > yMax: yMax = y xMin = int(xMin) yMin = int(yMin) size = (int(xMax - xMin + 0.5), int(yMax - yMin + 0.5)) for s in distSrc: s.setXAstrom(s.getXAstrom() - xMin) s.setYAstrom(s.getYAstrom() - yMin) sortedDistSrc = sorted(distSrc, key=lambda x:x.getPsfFlux(), reverse=True) if display: for i, d in enumerate(sortedDistSrc): #ds9.dot('o', d.getXAstrom(), d.getYAstrom(), size=15, frame=1) if i >= 99: break ds9.line([[0, 0], [0+size[0], 0]], frame=1) ds9.line([[0+size[0], 0], [0+size[0], 0+size[1]]], frame=1) ds9.line([[0+size[0], 0+size[1]], [0, 0+size[1]]], frame=1) ds9.line([[0, 0+size[1]], [0, 0]], frame=1) log = Log.getDefaultLog() pol = policy.Policy() pol.set('matchThreshold', 30) solver = measAst.createSolver(pol, log) (W,H) = size filterName = 'r' idName = 'id' wcsIn.shiftReferencePixel(-xMin, -yMin) catSet = hscAst.queryReferenceCatalog(solver, distSrc, wcsIn, (W,H), filterName, idName) print "# of catSet: ", len(catSet) if display: for c in catSet: ds9.dot("o", c.getXAstrom()+xMin, c.getYAstrom()+yMin, size=15, ctype=ds9.RED, frame=1) start = datetime.datetime.today() matchList = hscAst.match(distSrc, catSet) end = datetime.datetime.today() wcsIn.shiftReferencePixel(xMin, yMin) matchList2 = [] for m in matchList: for s in srcSet: if (s.getId() == m.second.getId()): x0 = m.first.getXAstrom() + xMin y0 = m.first.getYAstrom() + yMin x1 = m.second.getXAstrom() y1 = m.second.getYAstrom() x1 = s.getXAstrom() y1 = s.getYAstrom() #print x0, y0, x1, y1, m.second.getId() if display: ds9.dot("o", x1, y1, size=10, frame=1) ds9.line([[x0, y0], [x1, y1]], ctype=ds9.RED, frame=1) m2 = afwDet.SourceMatch(m.first, s, 0.0) matchList2.append(m2) elapsedtime = end - start print "%6d %d %3d %6.2f" % (frameId, ccdId, len(matchList), elapsedtime.seconds + elapsedtime.microseconds/1000000.)
class CosmicRayTestCase(unittest.TestCase): """A test case for Cosmic Ray detection""" def setUp(self): self.FWHM = 5 # pixels self.psf = algorithms.DoubleGaussianPsf( 29, 29, self.FWHM / (2 * sqrt(2 * log(2)))) self.mi = afwImage.MaskedImageF(imageFile) self.XY0 = afwGeom.PointI(0, 0) # origin of the subimage we use if imageFile == imageFile0: if True: # use full image, trimmed to data section self.XY0 = afwGeom.PointI(32, 2) self.mi = self.mi.Factory( self.mi, afwGeom.BoxI(self.XY0, afwGeom.PointI(2079, 4609)), afwImage.LOCAL) self.mi.setXY0(afwGeom.PointI(0, 0)) self.nCR = 1076 # number of CRs we should detect else: # use sub-image if True: self.XY0 = afwGeom.PointI(824, 140) self.nCR = 10 else: self.XY0 = afwGeom.PointI(280, 2750) self.nCR = 2 self.mi = self.mi.Factory( self.mi, afwGeom.BoxI(self.XY0, afwGeom.ExtentI(256, 256), afwImage.LOCAL)) self.mi.setXY0(afwGeom.PointI(0, 0)) else: self.nCR = None self.mi.getMask().addMaskPlane("DETECTED") def tearDown(self): del self.mi del self.psf def testDetection(self): """Test CR detection""" # # Subtract background # bctrl = afwMath.BackgroundControl(afwMath.Interpolate.NATURAL_SPLINE) bctrl.setNxSample(int(self.mi.getWidth() / 256) + 1) bctrl.setNySample(int(self.mi.getHeight() / 256) + 1) bctrl.getStatisticsControl().setNumSigmaClip(3.0) bctrl.getStatisticsControl().setNumIter(2) im = self.mi.getImage() try: backobj = afwMath.makeBackground(im, bctrl) except Exception, e: print >> sys.stderr, e, bctrl.setInterpStyle(afwMath.Interpolate.CONSTANT) backobj = afwMath.makeBackground(im, bctrl) im -= backobj.getImageF() if display: frame = 0 ds9.mtv(self.mi, frame=frame, title="Raw") # raw frame if self.mi.getWidth() > 256: ds9.pan(944 - self.mi.getX0(), 260 - self.mi.getY0()) # # Mask known bad pixels # badPixels = defects.policyToBadRegionList( os.path.join(os.environ["MEAS_ALGORITHMS_DIR"], "policy", "BadPixels.paf")) # did someone lie about the origin of the maskedImage? If so, adjust bad pixel list if self.XY0.getX() != self.mi.getX0() or self.XY0.getY( ) != self.mi.getY0(): dx = self.XY0.getX() - self.mi.getX0() dy = self.XY0.getY() - self.mi.getY0() for bp in badPixels: bp.shift(-dx, -dy) algorithms.interpolateOverDefects(self.mi, self.psf, badPixels) stats = afwMath.makeStatistics(self.mi.getImage(), afwMath.MEANCLIP | afwMath.STDEVCLIP) background = stats.getValue(afwMath.MEANCLIP) crConfig = algorithms.FindCosmicRaysConfig() crs = algorithms.findCosmicRays(self.mi, self.psf, background, pexConfig.makePolicy(crConfig)) if display: ds9.mtv(self.mi, frame=frame + 1, title="CRs removed") if self.mi.getWidth() > 256: ds9.pan(944 - self.mi.getX0(), 260 - self.mi.getY0()) print "Detected %d CRs" % len(crs) if display and False: for cr in crs: bbox = cr.getBBox() bbox.shift(afwGeom.ExtentI(-self.mi.getX0(), -self.mi.getY0())) ds9.line([(bbox.getMinX() - 0.5, bbox.getMinY() - 0.5), (bbox.getMaxX() + 0.5, bbox.getMinY() - 0.5), (bbox.getMaxX() + 0.5, bbox.getMaxY() + 0.5), (bbox.getMinX() - 0.5, bbox.getMaxY() + 0.5), (bbox.getMinX() - 0.5, bbox.getMinY() - 0.5)], frame=frame + 1) if self.nCR is not None: self.assertEqual(len(crs), self.nCR)
with ds9.Buffering(): for x, y in cenPos: ds9.dot("+", x, y, frame=frame) if showAmps: nx, ny = namp for i in range(nx): for j in range(ny): xc = numpy.array([0, 1, 1, 0, 0]) yc = numpy.array([0, 0, 1, 1, 0]) corners = [] for k in range(len(xc)): corners.append([psfWidth//2 + w/nx*(i + xc[k]), psfHeight//2 + h/ny*(j + yc[k])]) ds9.line(corners, frame=frame) return im #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- def saveSpatialCellSet(psfCellSet, fileName="foo.fits", frame=None): """Write the contents of a SpatialCellSet to a many-MEF fits file""" mode = "w" for cell in psfCellSet.getCellList(): for cand in cell.begin(False): # include bad candidates cand = algorithmsLib.cast_PsfCandidateF(cand) dx = afwImage.positionToIndex(cand.getXCenter(), True)[1] dy = afwImage.positionToIndex(cand.getYCenter(), True)[1]
def SpatialCellSetDemo(filename=None): """A demonstration of the use of a SpatialCellSet""" im, fs = readImage(filename) if display: ds9.mtv(im, frame=0, title="Input") # # Create an (empty) SpatialCellSet # cellSet = afwMath.SpatialCellSet( afwGeom.Box2I(afwGeom.Point2I(0, 0), im.getDimensions()), 260, 200) if display: for i in range(len(cellSet.getCellList())): cell = cellSet.getCellList()[i] ds9.line([ (cell.getBBox().getMinX(), cell.getBBox().getMinY()), (cell.getBBox().getMinX(), cell.getBBox().getMaxY()), (cell.getBBox().getMaxX(), cell.getBBox().getMaxY()), (cell.getBBox().getMaxX(), cell.getBBox().getMinY()), (cell.getBBox().getMinX(), cell.getBBox().getMinY()), ], frame=0) ds9.dot(cell.getLabel(), (cell.getBBox().getMinX() + cell.getBBox().getMaxX()) / 2, (cell.getBBox().getMinY() + cell.getBBox().getMaxY()) / 2) # # Populate cellSet # for foot in fs.getFootprints(): bbox = foot.getBBox() xc = (bbox.getMinX() + bbox.getMaxX()) / 2.0 yc = (bbox.getMinY() + bbox.getMaxY()) / 2.0 tc = testSpatialCellLib.ExampleCandidate(xc, yc, im, bbox) cellSet.insertCandidate(tc) # # OK, the SpatialCellList is populated. Let's do something with it # visitor = testSpatialCellLib.ExampleCandidateVisitor() cellSet.visitCandidates(visitor) print("There are %d candidates" % (visitor.getN())) ctypes = [ "red", "yellow", "cyan", ] for i in range(cellSet.getCellList().size()): cell = cellSet.getCellList()[i] cell.visitCandidates(visitor) j = 0 for cand in cell: cand = cand w, h = cand.getBBox().getDimensions() if w * h < 75: # print "%d %5.2f %5.2f %d" % (i, cand.getXCenter(), # cand.getYCenter(), w*h) cand.setStatus(afwMath.SpatialCellCandidate.BAD) if display: ds9.dot("o", cand.getXCenter(), cand.getYCenter(), size=4, ctype=ctypes[i % len(ctypes)]) else: if display: ds9.dot("%s:%d" % (cand.getId(), j), cand.getXCenter(), cand.getYCenter(), size=4, ctype=ctypes[i % len(ctypes)]) j += 1 im = cand.getMaskedImage() if 0 and display: ds9.mtv(im, title="Candidate", frame=1) # # Now count the good and bad candidates # for i in range(len(cellSet.getCellList())): cell = cellSet.getCellList()[i] cell.visitCandidates(visitor) cell.setIgnoreBad(False) # include BAD in cell.size() print( "%s nobj=%d N_good=%d NPix_good=%d" % (cell.getLabel(), cell.size(), visitor.getN(), visitor.getNPix())) cellSet.setIgnoreBad(True) # don't visit BAD candidates cellSet.visitCandidates(visitor) print("There are %d good candidates" % (visitor.getN()))
pix = wcs.skyToPixel(m.first.getCoord()) dr[i] = numpy.hypot(pix[0] - x, pix[1] - y) x, y = toObserved(x, y) ds9.dot("o", x, y, size=10, frame=frame, ctype=ds9.YELLOW) print "<dr> = %.4g +- %.4g [%d matches]" % (dr.mean(), dr.std(), len(matches)) else: for s in sources: x0, y0 = s.getX(), s.getY() ds9.dot("+", x0, y0, size=20, frame=frame, ctype=ds9.GREEN) if correctDistortion: x, y = toObserved(x0, y0) ds9.dot("o", x, y, frame=frame, ctype=ds9.GREEN) ds9.line([(x0, y0), (x, y)], frame=frame, ctype=ds9.GREEN) for s in catalog: pix = wcs.skyToPixel(s.getCoord()) ds9.dot("x", pix[0], pix[1], size=20, frame=frame, ctype=ds9.RED) def getDistorter(exposure): try: detector = exposure.getDetector() distorter = detector.getDistortion() def toUndistort(x, y): dist = distorter.undistort(afwGeom.Point2D(x, y), detector) return dist.getX(), dist.getY() def toDistort(x, y): dist = distorter.distort(afwGeom.Point2D(x, y), detector) return dist.getX(), dist.getY()
def SpatialCellSetDemo(filename=None): """A demonstration of the use of a SpatialCellSet""" im, fs = readImage(filename) if display: ds9.mtv(im, frame=0, title="Input") # # Create an (empty) SpatialCellSet # cellSet = afwMath.SpatialCellSet(afwGeom.Box2I(afwGeom.Point2I(0, 0), im.getDimensions()), 260, 200) if display: for i in range(len(cellSet.getCellList())): cell = cellSet.getCellList()[i] ds9.line([(cell.getBBox().getMinX(), cell.getBBox().getMinY()), (cell.getBBox().getMinX(), cell.getBBox().getMaxY()), (cell.getBBox().getMaxX(), cell.getBBox().getMaxY()), (cell.getBBox().getMaxX(), cell.getBBox().getMinY()), (cell.getBBox().getMinX(), cell.getBBox().getMinY()), ], frame=0) ds9.dot(cell.getLabel(), (cell.getBBox().getMinX() + cell.getBBox().getMaxX())/2, (cell.getBBox().getMinY() + cell.getBBox().getMaxY())/2) # # Populate cellSet # for foot in fs.getFootprints(): bbox = foot.getBBox() xc = (bbox.getMinX() + bbox.getMaxX())/2.0 yc = (bbox.getMinY() + bbox.getMaxY())/2.0 tc = testSpatialCellLib.ExampleCandidate(xc, yc, im, bbox) cellSet.insertCandidate(tc) # # OK, the SpatialCellList is populated. Let's do something with it # visitor = testSpatialCellLib.ExampleCandidateVisitor() cellSet.visitCandidates(visitor) print "There are %d candidates" % (visitor.getN()) ctypes = ["red", "yellow", "cyan", ] for i in range(cellSet.getCellList().size()): cell = cellSet.getCellList()[i] cell.visitCandidates(visitor) j = 0 for cand in cell: # # Swig doesn't know that we're a SpatialCellImageCandidate; all it knows is that we have # a SpatialCellCandidate so we need an explicit (dynamic) cast # cand = testSpatialCellLib.cast_ExampleCandidate(cand) w, h = cand.getBBox().getDimensions() if w*h < 75: #print "%d %5.2f %5.2f %d" % (i, cand.getXCenter(), cand.getYCenter(), w*h) cand.setStatus(afwMath.SpatialCellCandidate.BAD) if display: ds9.dot("o", cand.getXCenter(), cand.getYCenter(), size=4, ctype=ctypes[i%len(ctypes)]) else: if display: ds9.dot("%s:%d" % (cand.getId(), j), cand.getXCenter(), cand.getYCenter(), size=4, ctype=ctypes[i%len(ctypes)]) j += 1 im = cand.getMaskedImage() if 0 and display: ds9.mtv(im, title="Candidate", frame=1) # # Now count the good and bad candidates # for i in range(len(cellSet.getCellList())): cell = cellSet.getCellList()[i] cell.visitCandidates(visitor) cell.setIgnoreBad(False) # include BAD in cell.size() print "%s nobj=%d N_good=%d NPix_good=%d" % \ (cell.getLabel(), cell.size(), visitor.getN(), visitor.getNPix()) cellSet.setIgnoreBad(True) # don't visit BAD candidates cellSet.visitCandidates(visitor) print "There are %d good candidates" % (visitor.getN())