lsst.afw.display.utils Namespace Reference

Classes
class	Mosaic

Functions
	_getDisplayFromDisplayOrFrame (display, frame=None)
	drawBBox (bbox, borderWidth=0.0, origin=None, display="deferToFrame", ctype=None, bin=1, frame=None)
	drawFootprint (foot, borderWidth=0.5, origin=None, XY0=None, frame=None, ctype=None, bin=1, peaks=False, symb="+", size=0.4, ctypePeak=None, display="deferToFrame")
	drawCoaddInputs (exposure, frame=None, ctype=None, bin=1, display="deferToFrame")

Function Documentation

_getDisplayFromDisplayOrFrame()

lsst.afw.display.utils._getDisplayFromDisplayOrFrame ( display, frame = None )

protected

Return an `lsst.afw.display.Display` given either a display or a frame ID.

Notes
-----
If the two arguments are consistent, return the desired display; if they are not,
raise a `RuntimeError` exception.

If the desired display is `None`, return `None`;
if ``(display, frame) == ("deferToFrame", None)``, return the default display

Definition at line 34 of file utils.py.

def _getDisplayFromDisplayOrFrame(display, frame=None):
    """Return an `lsst.afw.display.Display` given either a display or a frame ID.
 
    Notes
    -----
    If the two arguments are consistent, return the desired display; if they are not,
    raise a `RuntimeError` exception.
 
    If the desired display is `None`, return `None`;
    if ``(display, frame) == ("deferToFrame", None)``, return the default display
    """
 
    # import locally to allow this file to be imported by __init__
    import lsst.afw.display as afwDisplay
 
    if display in ("deferToFrame", None):
        if display is None and frame is None:
            return None
 
        # "deferToFrame" is the default value, and  means "obey frame"
        display = None
 
    if display and not hasattr(display, "frame"):
        raise RuntimeError(f"display == {display} doesn't support .frame")
 
    if frame and display and display.frame != frame:
        raise RuntimeError("Please specify display *or* frame")
 
    if display:
        frame = display.frame
 
    display = afwDisplay.getDisplay(frame, create=True)
 
    return display
 
 

drawBBox()

lsst.afw.display.utils.drawBBox	(		bbox,
			borderWidth = 0.0,
			origin = None,
			display = "deferToFrame",
			ctype = None,
			bin = 1,
			frame = None )

Draw a bounding box on a display frame with the specified ctype.

Parameters
----------
bbox : `lsst.geom.Box2I` or `lsst.geom.Box2D`
    The box to draw
borderWidth : `float`
    Include this many pixels
origin
    If specified, the box is shifted by ``origin``
display : `str`
ctype : `str`
    The desired color, either e.g. `lsst.afw.display.RED` or a color name known to X11
bin : `int`
    All BBox coordinates are divided by bin, as is right and proper for overlaying on a binned image
frame

Definition at line 346 of file utils.py.

def drawBBox(bbox, borderWidth=0.0, origin=None, display="deferToFrame", ctype=None, bin=1, frame=None):
    """Draw a bounding box on a display frame with the specified ctype.
 
    Parameters
    ----------
    bbox : `lsst.geom.Box2I` or `lsst.geom.Box2D`
        The box to draw
    borderWidth : `float`
        Include this many pixels
    origin
        If specified, the box is shifted by ``origin``
    display : `str`
    ctype : `str`
        The desired color, either e.g. `lsst.afw.display.RED` or a color name known to X11
    bin : `int`
        All BBox coordinates are divided by bin, as is right and proper for overlaying on a binned image
    frame
    """
    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
 
    display = _getDisplayFromDisplayOrFrame(display, frame)
    display.line([(x0 - borderWidth, y0 - borderWidth),
                  (x0 - borderWidth, y1 + borderWidth),
                  (x1 + borderWidth, y1 + borderWidth),
                  (x1 + borderWidth, y0 - borderWidth),
                  (x0 - borderWidth, y0 - borderWidth),
                  ], ctype=ctype)
 
 

drawCoaddInputs()

lsst.afw.display.utils.drawCoaddInputs	(		exposure,
			frame = None,
			ctype = None,
			bin = 1,
			display = "deferToFrame" )

Draw the bounding boxes of input exposures to a coadd on a display
frame with the specified ctype, assuming ``display.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

Definition at line 458 of file utils.py.

def drawCoaddInputs(exposure, frame=None, ctype=None, bin=1, display="deferToFrame"):
    """Draw the bounding boxes of input exposures to a coadd on a display
    frame with the specified ctype, assuming ``display.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 = lsst.geom.PointD() - lsst.geom.PointD(exposure.getXY0())
 
    display = _getDisplayFromDisplayOrFrame(display, frame)
 
    with display.Buffering():
        for record in catalog:
            ccdBox = lsst.geom.Box2D(record.getBBox())
            ccdCorners = ccdBox.getCorners()
            coaddCorners = [coaddWcs.skyToPixel(record.getWcs().pixelToSky(point)) + offset
                            for point in ccdCorners]
            display.line([(coaddCorners[i].getX()/bin, coaddCorners[i].getY()/bin)
                          for i in range(-1, 4)], ctype=ctype)

drawFootprint()

lsst.afw.display.utils.drawFootprint	(		foot,
			borderWidth = 0.5,
			origin = None,
			XY0 = None,
			frame = None,
			ctype = None,
			bin = 1,
			peaks = False,
			symb = "+",
			size = 0.4,
			ctypePeak = None,
			display = "deferToFrame" )

Draw an `lsst.afw.detection.Footprint` on a display frame with the specified ctype.

Parameters
----------
foot : `lsst.afw.detection.Footprint`
borderWidth : `float`
    Include an extra borderWidth pixels
origin
    If ``origin`` is present, it's arithmetically added to the Footprint
XY0
    if ``XY0`` is present is subtracted from the Footprint
frame
ctype : `str`
    The desired color, either e.g. `lsst.afw.display.RED` or a color name known to X11
bin : `int`
    All Footprint coordinates are divided by bin, as is right and proper
    for overlaying on a binned image
peaks : `bool`
    If peaks is `True`, also show the object's Peaks using the specified
    ``symb`` and ``size`` and ``ctypePeak``
symb : `str`
size : `float`
ctypePeak : `str`
    The desired color for peaks, either e.g. `lsst.afw.display.RED` or a color name known to X11
display : `str`

Definition at line 388 of file utils.py.

                  peaks=False, symb="+", size=0.4, ctypePeak=None, display="deferToFrame"):
    """Draw an `lsst.afw.detection.Footprint` on a display frame with the specified ctype.
 
    Parameters
    ----------
    foot : `lsst.afw.detection.Footprint`
    borderWidth : `float`
        Include an extra borderWidth pixels
    origin
        If ``origin`` is present, it's arithmetically added to the Footprint
    XY0
        if ``XY0`` is present is subtracted from the Footprint
    frame
    ctype : `str`
        The desired color, either e.g. `lsst.afw.display.RED` or a color name known to X11
    bin : `int`
        All Footprint coordinates are divided by bin, as is right and proper
        for overlaying on a binned image
    peaks : `bool`
        If peaks is `True`, also show the object's Peaks using the specified
        ``symb`` and ``size`` and ``ctypePeak``
    symb : `str`
    size : `float`
    ctypePeak : `str`
        The desired color for peaks, either e.g. `lsst.afw.display.RED` or a color name known to X11
    display : `str`
    """
 
    if XY0:
        if origin:
            raise RuntimeError("You may not specify both origin and XY0")
        origin = (-XY0[0], -XY0[1])
 
    display = _getDisplayFromDisplayOrFrame(display, frame)
    with display.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
 
            display.line([(x0 - borderWidth, y - borderWidth),
                          (x0 - borderWidth, y + borderWidth),
                          (x1 + borderWidth, y + borderWidth),
                          (x1 + borderWidth, y - borderWidth),
                          (x0 - borderWidth, y - borderWidth),
                          ], 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
 
                display.dot(symb, x, y, size=size, ctype=ctypePeak)