def drawLabels(self, labels=None, frame=None): """Draw the list labels at the corners of each panel. If labels is None, use the ones specified by Mosaic.append()""" if frame is None: return if not labels: labels = self.labels if not labels: return if len(labels) != self.nImage: raise RuntimeError, ("You provided %d labels for %d panels" % (len(labels), self.nImage)) with ds9.Buffering(): for i in range(len(labels)): if labels[i]: label, ctype = labels[i], None try: label, ctype = label except: pass if not label: continue ds9.dot(str(label), self.getBBox(i).getMinX(), self.getBBox(i).getMinY(), frame=frame, ctype=ctype)
def showKernelSpatialCells(maskedIm, kernelCellSet, showChi2=False, symb="o", ctype=None, ctypeUnused=None, ctypeBad=None, size=3, frame=None, title="Spatial Cells"): """Show the SpatialCells. If symb is something that ds9.dot understands (e.g. "o"), the top nMaxPerCell candidates will be indicated with that symbol, using ctype and size""" ds9.mtv(maskedIm, frame=frame, title=title) with ds9.Buffering(): origin = [-maskedIm.getX0(), -maskedIm.getY0()] for cell in kernelCellSet.getCellList(): displayUtils.drawBBox(cell.getBBox(), origin=origin, frame=frame) goodies = ctypeBad is None for cand in cell.begin(goodies): xc, yc = cand.getXCenter() + origin[0], cand.getYCenter() + origin[1] if cand.getStatus() == afwMath.SpatialCellCandidate.BAD: color = ctypeBad elif cand.getStatus() == afwMath.SpatialCellCandidate.GOOD: color = ctype elif cand.getStatus() == afwMath.SpatialCellCandidate.UNKNOWN: color = ctypeUnused else: continue if color: ds9.dot(symb, xc, yc, frame=frame, ctype=color, size=size) if showChi2: rchi2 = cand.getChi2() if rchi2 > 1e100: rchi2 = np.nan ds9.dot("%d %.1f" % (cand.getId(), rchi2), xc - size, yc - size - 4, frame=frame, ctype=color, size=size)
def testLinearRamp(self): """Fit a ramp""" binsize = 1 ramp, rampCoeffs, xVec, yVec = self.makeRamp(binsize) # Add a (labelled) bad value ramp.set(ramp.getWidth()//2, ramp.getHeight()//2, (0, 0x1, np.nan)) if display: ds9.mtv(ramp, title="Input", frame=0) # Here's the range that the approximation should be valid (and also the # bbox of the image returned by getImage) bbox = afwGeom.BoxI(afwGeom.PointI(0, 0), afwGeom.PointI(binsize*ramp.getWidth() - 1, binsize*ramp.getHeight() - 1)) order = 3 # 1 would be enough to fit the ramp actrl = afwMath.ApproximateControl( afwMath.ApproximateControl.CHEBYSHEV, order) approx = afwMath.makeApproximate(xVec, yVec, ramp, bbox, actrl) for i, aim in enumerate([approx.getImage(), approx.getMaskedImage().getImage(), ]): if i == 0 and display: ds9.mtv(aim, title="interpolated", frame=1) with ds9.Buffering(): for x in xVec: for y in yVec: ds9.dot('+', x, y, size=0.4, frame=1) for x, y in aim.getBBox().getCorners(): self.assertEqual( aim.get(x, y), rampCoeffs[0] + rampCoeffs[1]*x + rampCoeffs[1]*y)
def main(rootDir, visit, ccd, frame=1, title="", scale="zscale", zoom="to fit", trans=60, useEllipse=False): # make a butler and specify your dataId butler = dafPersist.Butler(rootDir) dataId = {'visit': visit, 'ccd':ccd} # get the exposure from the butler exposure = butler.get('calexp', dataId) # put the settings in a dict object and call ds9.mtv() settings = {'scale':scale, 'zoom': zoom, 'mask' : 'transparency %d' %(trans)} ds9.mtv(exposure, frame=frame, title=title, settings=settings) # now get the source catalog and overplot the points sources = butler.get('src', dataId) with ds9.Buffering(): for i,source in enumerate(sources): color = ds9.RED size = 5.0 if useEllipse: # show an ellipse symbol symbol = "@:{ixx},{ixy},{iyy}".format(ixx=source.getIxx(), ixy=source.getIxy(), iyy=source.getIyy()) else: # just a simple point (symbols +, x, *, o are all accepted) symbol = "o" ds9.dot(symbol, source.getX(), source.getY(), ctype=color, size=size, frame=frame, silent=True)
def run(display=False): exposure = loadData() schema = afwTable.SourceTable.makeMinimalSchema() # # Create the detection and measurement Tasks # config = SourceDetectionTask.ConfigClass() config.reEstimateBackground = False detectionTask = SourceDetectionTask(config=config, schema=schema) config = SingleFrameMeasurementTask.ConfigClass() # Use the minimum set of plugins required. config.plugins.names.clear() for plugin in [ "base_SdssCentroid", "base_SdssShape", "base_CircularApertureFlux", "base_PixelFlags" ]: config.plugins.names.add(plugin) config.plugins["base_CircularApertureFlux"].radii = [7.0] # Use of the PSF flux is hardcoded in secondMomentStarSelector config.slots.psfFlux = "base_CircularApertureFlux_7_0" measureTask = SingleFrameMeasurementTask(schema, config=config) # # Create the measurePsf task # config = MeasurePsfTask.ConfigClass() psfDeterminer = config.psfDeterminer.apply() psfDeterminer.config.sizeCellX = 128 psfDeterminer.config.sizeCellY = 128 psfDeterminer.config.spatialOrder = 1 psfDeterminer.config.nEigenComponents = 3 measurePsfTask = MeasurePsfTask(config=config, schema=schema) # # Create the output table # tab = afwTable.SourceTable.make(schema) # # Process the data # sources = detectionTask.run(tab, exposure, sigma=2).sources measureTask.measure(exposure, sources) result = measurePsfTask.run(exposure, sources) psf = result.psf cellSet = result.cellSet if display: # display on ds9 (see also --debug argparse option) frame = 1 ds9.mtv(exposure, frame=frame) with ds9.Buffering(): for s in sources: xy = s.getCentroid() ds9.dot('+', *xy, frame=frame) if s.get("calib.psf.candidate"): ds9.dot('x', *xy, ctype=ds9.YELLOW, frame=frame) if s.get("calib.psf.used"): ds9.dot('o', *xy, size=4, ctype=ds9.RED, frame=frame)
def main(rootDir, visit, ccd, filter=None, frame=1, title="", scale="zscale", zoom="to fit", trans=60, useEllipse=False, maskOnly=False): if ccd.find(",") < 0: ccd = int(ccd) pipeVersion = dafPersist.eupsVersions.EupsVersions().versions['hscPipe'] if StrictVersion(pipeVersion) >= StrictVersion('3.9.0'): coaddData = "deepCoadd_calexp" coaddCat = "meas" else: coaddData = "deepCoadd" coaddCat = "src" print "Read in %s image"%coaddData # make a butler and specify your dataId butler = dafPersist.Butler(rootDir) if filter: dataId = {'tract': visit, 'patch':ccd, 'filter': filter} exposure = butler.get(coaddData, dataId, immediate=True) butlerTarget='deepCoadd_' sources = butler.get(butlerTarget + coaddCat, dataId) else: dataId = {'visit': visit, 'ccd':ccd} exposure = butler.get("calexp", dataId, immediate=True) butlerTarget="" sources = butler.get(butlerTarget + 'src', dataId) # put the settings in a dict object and call ds9.mtv() settings = {'scale':scale, 'zoom': zoom, 'mask' : 'transparency %d' %(trans)} ds9.setMaskPlaneColor('FAKE', color=ds9.CYAN) if not maskOnly: ds9.mtv(exposure, frame=frame, title=title, settings=settings) else: msk = exposure.getMaskedImage().getMask() msk &= msk.getPlaneBitMask('FAKE') ds9.mtv(msk, frame=frame, title=title, settings=settings) with ds9.Buffering(): print len(sources) x0, y0 = exposure.getXY0() print x0, y0 for i,source in enumerate(sources): color = ds9.RED size = 5.0 if useEllipse: # show an ellipse symbol symbol = "@:{ixx},{ixy},{iyy}".format(ixx=source.getIxx(), ixy=source.getIxy(), iyy=source.getIyy()) else: # just a simple point (symbols +, x, *, o are all accepted) symbol = "o" ds9.dot(symbol, source.getX()-x0, source.getY()-y0, ctype=color, size=size, frame=frame, silent=True)
def showSourceSetSky(sSet, wcs, xy0, frame=0, ctype=ds9.GREEN, symb="+", size=2): """Draw the (RA, Dec) positions of a set of Sources. Image has the XY0.""" with ds9.Buffering(): for s in sSet: (xc, yc) = wcs.skyToPixel(s.getCoord().getRa(), s.getCoord().getDec()) xc -= xy0[0] yc -= xy0[1] ds9.dot(symb, xc, yc, frame=frame, ctype=ctype, size=size)
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 view(cat=None, exp=None, tract=None, patch=None, ID=None, coords=None, filter='I', frame=0, scale="zscale",\ zoom="to fit", trans=80, draw_ells=True, maxsep=None, shape_model='shape.hsm.moments', pcolor=ds9.GREEN, ccolor=ds9.RED): if cat is None: assert (tract is not None) and ( patch is not None), 'if no cat is given, must give tract and patch' exp = butler.get("deepCoadd_calexp", tract=tract, patch=patch, filter='HSC-' + filter, immediate=True) cat = butler.get("deepCoadd_meas", tract=tract, patch=patch, filter='HSC-' + filter, immediate=True) else: assert exp is not None, 'if cat is given, must also give exp' x0, y0 = exp.getXY0() settings = { 'scale': scale, 'zoom': zoom, 'mask': 'transparency %d' % (trans) } ds9.mtv(exp, frame=frame, settings=settings) ######################################################### # maxsep is used if you only want to draw ellipses around # objects within a distance maxsep from a candidate ######################################################### if maxsep is not None: if ID is not None: obj = cat.find(ID) ra0, dec0 = obj.getRa().asDegrees(), obj.getDec().asDegrees() else: ra0, dec0 = coords ra, dec = cat.get('coord.ra') * 180. / np.pi, cat.get( 'coord.dec') * 180. / np.pi seps = angsep(ra0, dec0, ra, dec) cut = seps < maxsep cat = cat[seps < maxsep].copy(deep=True) if draw_ells: with ds9.Buffering(): for i, source in enumerate(cat): ellcolor = pcolor if source.get('parent') == 0 else ccolor ixx, ixy, iyy = [ source.get(shape_model + _x) for _x in ['.xx', '.xy', '.yy'] ] symbol = "@:{ixx},{ixy},{iyy}".format(ixx=ixx, ixy=ixy, iyy=iyy) ds9.dot(symbol, source.getX() - x0, source.getY() - y0, ctype=ellcolor, frame=frame)
def showPsfResiduals(exposure, sourceSet, magType="psf", scale=10, frame=None): mimIn = exposure.getMaskedImage() mimIn = mimIn.Factory(mimIn, True) # make a copy to subtract from psf = exposure.getPsf() psfWidth, psfHeight = psf.getLocalKernel().getDimensions() # # Make the image that we'll paste our residuals into. N.b. they can overlap the edges # w, h = int(mimIn.getWidth()/scale), int(mimIn.getHeight()/scale) im = mimIn.Factory(w + psfWidth, h + psfHeight) cenPos = [] for s in sourceSet: x, y = s.getX(), s.getY() sx, sy = int(x/scale + 0.5), int(y/scale + 0.5) smim = im.Factory(im, afwGeom.BoxI(afwGeom.PointI(sx, sy), afwGeom.ExtentI(psfWidth, psfHeight))) sim = smim.getImage() try: if magType == "ap": flux = s.getApFlux() elif magType == "model": flux = s.getModelFlux() elif magType == "psf": flux = s.getPsfFlux() else: raise RuntimeError("Unknown flux type %s" % magType) subtractPsf(psf, mimIn, x, y, flux) except Exception as e: print(e) try: expIm = mimIn.getImage().Factory(mimIn.getImage(), afwGeom.BoxI(afwGeom.PointI(int(x) - psfWidth//2, int(y) - psfHeight//2), afwGeom.ExtentI(psfWidth, psfHeight)), ) except pexExcept.Exception: continue cenPos.append([x - expIm.getX0() + sx, y - expIm.getY0() + sy]) sim += expIm if frame is not None: ds9.mtv(im, frame=frame) with ds9.Buffering(): for x, y in cenPos: ds9.dot("+", x, y, frame=frame) return im
def plotPeaks(fps, ctype): if fps is None: return with ds9.Buffering(): for fp in fps.getFootprints(): for pp in fp.getPeaks(): ds9.dot("+", pp.getFx() - x0, pp.getFy() - y0, 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 testGrowFootprints3(self): """Test that we can grow footprints, correctly merging those that now totally overwritten""" self.im = afwImage.MaskedImageF(14, 11) self.im.getImage().set(0) self.peaks = [] I = 11 for x, y in [(4, 7), (5, 7), (6, 7), (7, 7), (8, 7), (4, 6), (8, 6), (4, 5), (8, 5), (4, 4), (8, 4), (4, 3), (8, 3), ]: self.im.getImage().set(x, y, I) I -= 1e-3 self.im.getImage().set(4, 7, 15) self.peaks.append([(4, 7,),]) self.im.getImage().set(6, 5, 30) self.peaks[0].append((6, 5,)) self.fs = afwDetect.FootprintSet(self.im, afwDetect.Threshold(10), "BINNED1") # # The disappearing Footprint special case only shows up if the outer Footprint is grown # _after_ the inner one. So arrange the order properly feet = self.fs.getFootprints() feet[0], feet[1] = feet[1], feet[0] msk = self.im.getMask() grow = 2 self.fs = afwDetect.FootprintSet(self.fs, grow, False) afwDetect.setMaskFromFootprintList(msk, self.fs.getFootprints(), msk.getPlaneBitMask("DETECTED_NEGATIVE")) if display: frame = 0 ds9.mtv(self.im, frame=frame) with ds9.Buffering(): for i, foot in enumerate(self.fs.getFootprints()): for p in foot.getPeaks(): ds9.dot("+", p.getIx(), p.getIy(), size=0.4, frame=frame) if i < len(self.peaks): for trueX, trueY in self.peaks[i]: ds9.dot("x", trueX, trueY, size=0.4, ctype=ds9.RED, frame=frame) self.assertEqual(len(self.fs.getFootprints()), 1) self.assertEqual(len(self.fs.getFootprints()[0].getPeaks()), len(self.peaks[0]))
def showSourceSet(sSet, xy0=(0, 0), frame=0, ctype=ds9.GREEN, symb="+", size=2): """Draw the (XAstrom, YAstrom) positions of a set of Sources. Image has the given XY0""" with ds9.Buffering(): for s in sSet: xc, yc = s.getXAstrom() - xy0[0], s.getYAstrom() - xy0[1] if symb == "id": ds9.dot(str(splitId(s.getId(), True)["objId"]), xc, yc, frame=frame, ctype=ctype, size=size) else: ds9.dot(symb, xc, yc, frame=frame, ctype=ctype, size=size)
def testText(self): """Test drawing text""" ds9.erase() exp = afwImage.ExposureF(300, 350) ds9.mtv(exp, title="parent") # tells display0 about the image's xy0 with ds9.Buffering(): ds9.dot('hello', 200, 200) ds9.dot('hello', 200, 210, size=1.25) ds9.dot('hello', 200, 220, size=3, fontFamily="times") ds9.dot('hello', 200, 230, fontFamily="helvetica bold italic")
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 run(display=False): exposure = loadData() schema = afwTable.SourceTable.makeMinimalSchema() # # Create the detection task # config = SourceDetectionTask.ConfigClass() config.thresholdPolarity = "both" config.background.isNanSafe = True config.thresholdValue = 3 detectionTask = SourceDetectionTask(config=config, schema=schema) # # And the measurement Task # config = SingleFrameMeasurementTask.ConfigClass() config.algorithms.names = ["base_SdssCentroid", "base_SdssShape", "base_CircularApertureFlux"] config.algorithms["base_CircularApertureFlux"].radii = [1, 2, 4, 8, 16] # pixels config.slots.instFlux = None config.slots.modelFlux = None config.slots.psfFlux = None algMetadata = dafBase.PropertyList() measureTask = SingleFrameMeasurementTask(schema, algMetadata=algMetadata, config=config) radii = algMetadata.get("base_CircularApertureFlux_radii") # # Create the output table # tab = afwTable.SourceTable.make(schema) # # Process the data # result = detectionTask.run(tab, exposure) sources = result.sources print("Found %d sources (%d +ve, %d -ve)" % (len(sources), result.fpSets.numPos, result.fpSets.numNeg)) measureTask.run(sources, exposure) if display: # display on ds9 (see also --debug argparse option) frame = 1 ds9.mtv(exposure, frame=frame) with ds9.Buffering(): for s in sources: xy = s.getCentroid() ds9.dot('+', *xy, ctype=ds9.CYAN if s.get("flags.negative") else ds9.GREEN, frame=frame) ds9.dot(s.getShape(), *xy, ctype=ds9.RED, frame=frame) for i in range(s.get("flux.aperture.nProfile")): ds9.dot('o', *xy, size=radii[i], ctype=ds9.YELLOW, frame=frame)
def selectStars(self, exposure, sourceCat, matches=None): """!Return a list of PSF candidates that represent likely stars A list of PSF candidates may be used by a PSF fitter to construct a PSF. @param[in] exposure the exposure containing the sources @param[in] sourceCat catalog of sources that may be stars (an lsst.afw.table.SourceCatalog) @param[in] matches a match vector as produced by meas_astrom; required (defaults to None to match the StarSelector API and improve error handling) @return an lsst.pipe.base.Struct containing: - starCat catalog of selected stars (a subset of sourceCat) """ import lsstDebug debugInfo = lsstDebug.Info(__name__) display = debugInfo.display pauseAtEnd = debugInfo.pauseAtEnd # pause when done if matches is None: raise RuntimeError("CatalogStarSelectorTask requires matches") mi = exposure.getMaskedImage() if display: frame = 1 ds9.mtv(mi, frame=frame, title="PSF candidates") isGoodSource = CheckSource(sourceCat, self.config.fluxLim, self.config.fluxMax, self.config.badFlags) starCat = SourceCatalog(sourceCat.schema) with ds9.Buffering(): for ref, source, d in matches: if not ref.get("resolved"): if not isGoodSource(source): symb, ctype = "+", ds9.RED else: starCat.append(source) symb, ctype = "+", ds9.GREEN if display: ds9.dot(symb, source.getX() - mi.getX0(), source.getY() - mi.getY0(), size=4, frame=frame, ctype=ctype) if display and pauseAtEnd: input("Continue? y[es] p[db] ") return Struct(starCat=starCat, )
def showPeaks(im=None, fs=None, frame=0): """Show the image and peaks""" if frame is None: return if im: ds9.mtv(im, frame=frame) if fs: with ds9.Buffering(): # turn on buffering of ds9's slow "region" writes for foot in fs.getFootprints(): for p in foot.getPeaks(): ds9.dot("+", p.getIx(), p.getIy(), size=0.4, ctype=ds9.RED, frame=frame)
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 main(rootDir, visit, ccd, frame=1, title="", scale="zscale", zoom="to fit", trans=60, useEllipse=False): # butler を開き読み込みたいデータの dataId を指定する butler = dafPersist.Butler(rootDir) dataId = {'visit': visit, 'ccd': ccd} # butler から一次処理済データを読み込む exposure = butler.get('calexp', dataId) # 読み込みたい天体情報を設定し、ds9.mtv() を読み込む settings = { 'scale': scale, 'zoom': zoom, 'mask': 'transparency %d' % (trans) } ds9.mtv(exposure, frame=frame, title=title, settings=settings) # 天体カタログを取得し、データ点を重ねて表示する sources = butler.get('src', dataId) with ds9.Buffering(): for i, source in enumerate(sources): color = ds9.RED size = 5.0 if useEllipse: # 楕円体のシンボルで表示 symbol = "@:{ixx},{ixy},{iyy}".format(ixx=source.getIxx(), ixy=source.getIxy(), iyy=source.getIyy()) else: # シンプルなシンボルで表示(例えば、 +, x, *, o が使える) symbol = "o" ds9.dot(symbol, source.getX(), source.getY(), ctype=color, size=size, frame=frame, silent=True)
def checkPeaks(self, dwidth=0, dheight=0, frame=3): """Check that we got the peaks right""" feet = self.fs.getFootprints() # # Check that we found all the peaks # self.assertEqual(sum([len(f.getPeaks()) for f in feet]), sum([len(f.getPeaks()) for f in feet])) if display: ds9.mtv(self.im, frame=frame) with ds9.Buffering(): for i, foot in enumerate(feet): for p in foot.getPeaks(): ds9.dot("+", p.getIx(), p.getIy(), size=0.4, frame=frame) if i < len(self.peaks): for trueX, trueY, peakVal in self.peaks[i]: ds9.dot("x", trueX, trueY, size=0.4, ctype=ds9.RED, frame=frame) for i, foot in enumerate(feet): npeak = None # # Peaks that touch the edge are handled differently, as only the single highest/lowest pixel # is treated as a Peak # if (dwidth != 0 or dheight != 0): if (foot.getBBox().getMinX() == 0 or foot.getBBox().getMaxX() == self.im.getWidth() - 1 or foot.getBBox().getMinY() == 0 or foot.getBBox().getMaxY() == self.im.getHeight() - 1): npeak = 1 if npeak is None: npeak = len(self.peaks[i]) if npeak != len(foot.getPeaks()): print "RHL", foot.repr() #print "RHL", [(p.repr().split(":")[0], p.getIx(), p.getIy()) for p in foot.getPeaks()] print "RHL", [(p.getId(), p.getIx(), p.getIy()) for p in foot.getPeaks()] print "RHL", [p[0:2] for p in self.peaks[i]] self.assertEqual(len(foot.getPeaks()), npeak) for j, p in enumerate(foot.getPeaks()): trueX, trueY, peakVal = self.peaks[i][j] if (p.getIx(), p.getIy()) != (trueX, trueY): print "RHL", [(pp.getId(), pp.getIx(), pp.getIy()) for pp in foot.getPeaks()] print "RHL", [pp[0:2] for pp in self.peaks[i]] self.assertEqual((p.getIx(), p.getIy()), (trueX, trueY))
def showPsfSpatialCells(exposure, psfCellSet, nMaxPerCell=-1, showChi2=False, showMoments=False, symb=None, ctype=None, ctypeUnused=None, ctypeBad=None, size=2, frame=None): """Show the SpatialCells. If symb is something that ds9.dot understands (e.g. "o"), the top nMaxPerCell candidates will be indicated with that symbol, using ctype and size""" with ds9.Buffering(): origin = [-exposure.getMaskedImage().getX0(), -exposure.getMaskedImage().getY0()] for cell in psfCellSet.getCellList(): displayUtils.drawBBox(cell.getBBox(), origin=origin, frame=frame) if nMaxPerCell < 0: nMaxPerCell = 0 i = 0 goodies = ctypeBad is None for cand in cell.begin(goodies): if nMaxPerCell > 0: i += 1 cand = algorithmsLib.cast_PsfCandidateF(cand) xc, yc = cand.getXCenter() + origin[0], cand.getYCenter() + origin[1] if i > nMaxPerCell: if not ctypeUnused: continue color = ctypeBad if cand.isBad() else ctype if symb: if i > nMaxPerCell: ct = ctypeUnused else: ct = ctype ds9.dot(symb, xc, yc, frame=frame, ctype=ct, size=size) source = cand.getSource() if showChi2: rchi2 = cand.getChi2() if rchi2 > 1e100: rchi2 = numpy.nan ds9.dot("%d %.1f" % (splitId(source.getId(), True)["objId"], rchi2), xc - size, yc - size - 4, frame=frame, ctype=color, size=2) if showMoments: ds9.dot("%.2f %.2f %.2f" % (source.getIxx(), source.getIxy(), source.getIyy()), xc-size, yc + size + 4, frame=frame, ctype=color, size=size)
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 showImage(self, image, sources, title, frame): """Display an image Images are only displayed if 'display' is turned on. @param image: Image to display @param sources: Sources to mark on the display @param title: Title to give frame @param frame: Frame on which to display """ if not display: return ds9.mtv(image, title=title, frame=frame) with ds9.Buffering(): for s in sources: center = s.getCentroid() ds9.dot("o", center.getX(), center.getY(), frame=frame)
def main(rootDir, visit, ccd, filter=None, frame=1, title="", scale="zscale", zoom="to fit", trans=60, useEllipse=False): if ccd.find(",") < 0: ccd = int(ccd) # make a butler and specify your dataId butler = dafPersist.Butler(rootDir) if filter: dataId = {'tract': visit, 'patch':ccd, 'filter': filter} exposure = butler.get("deepCoadd", dataId) butlerTarget='deepCoadd_' else: dataId = {'visit': visit, 'ccd':ccd} exposure = butler.get("calexp", dataId) butlerTarget="" # put the settings in a dict object and call ds9.mtv() settings = {'scale':scale, 'zoom': zoom, 'mask' : 'transparency %d' %(trans)} ds9.mtv(exposure, frame=frame, title=title, settings=settings) # now get the source catalog and overplot the points sources = butler.get(butlerTarget+'src', dataId) with ds9.Buffering(): print len(sources) x0, y0 = exposure.getXY0() print x0, y0 for i,source in enumerate(sources): color = ds9.RED size = 5.0 if useEllipse: # show an ellipse symbol symbol = "@:{ixx},{ixy},{iyy}".format(ixx=source.getIxx(), ixy=source.getIxy(), iyy=source.getIyy()) else: # just a simple point (symbols +, x, *, o are all accepted) symbol = "o" ds9.dot(symbol, source.getX()-x0, source.getY()-y0, ctype=color, size=size, frame=frame, silent=True)
def process(self, dataRef): """Process focus CCD in preparation for focus measurement @param dataRef: Data reference for CCD @return Struct(sources: source measurements, ccdId: CCD number, filterName: name of filter, dims: exposure dimensions ) """ import lsstDebug display = lsstDebug.Info(__name__).display exp = self.isr.runDataRef(dataRef).exposure if display: import lsst.afw.display.ds9 as ds9 ds9.mtv(exp, title="Post-ISR", frame=1) self.installPsf.run(exposure=exp) bg, exp = measAlg.estimateBackground(exp, self.config.background, subtract=True) if display: ds9.mtv(exp, title="Post-background", frame=2) dmResults = self.detectAndMeasure.run(exp, dataRef.get("expIdInfo")) sources = dmResults.sourceCat self.starSelector.run(exp, sources, isStarField="hscPipeline_focus_candidate") if display: ds9.mtv(exp, title="Post-measurement", frame=3) with ds9.Buffering(): for s in sources: ds9.dot("o", s.getX(), s.getY(), frame=3, ctype=ds9.GREEN if s.get("calib.psf.candidate") else ds9.RED) import pdb;pdb.set_trace() # pause to allow inspection filterName = exp.getFilter().getName() if self.config.doWrite: dataRef.put(sources, "src") dataRef.put(exp, "visitim") return Struct(sources=sources, ccdId=dataRef.dataId["ccd"], filterName=filterName, dims=exp.getDimensions())
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 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 displaySources(self, exposure, matches, reserved, frame=1): """Display sources we'll use for photocal Sources that will be actually used will be green. Sources reserved from the fit will be red. Parameters ---------- exposure : `lsst.afw.image.ExposureF` Exposure to display. matches : `list` of `lsst.afw.table.RefMatch` Matches used for photocal. reserved : `numpy.ndarray` of type `bool` Boolean array indicating sources that are reserved. frame : `int` Frame number for display. """ ds9.mtv(exposure, frame=frame, title="photocal") with ds9.Buffering(): for mm, rr in zip(matches, reserved): x, y = mm.second.getCentroid() ctype = ds9.RED if rr else ds9.GREEN ds9.dot("o", x, y, size=4, frame=frame, ctype=ctype)