lsst.afw.display.interface.Display Class Reference

Classes
class	_Buffering

Public Member Functions
	__init__ (self, frame=None, backend=None, **kwargs)
	__enter__ (self)
	__exit__ (self, *args)
	__del__ (self)
	__getattr__ (self, name)
	close (self)
	verbose (self)
	verbose (self, value)
	__str__ (self)
	setImageColormap (self, cmap)
	maskColorGenerator (self, omitBW=True)
	setMaskPlaneColor (self, name, color=None)
	getMaskPlaneColor (self, name=None)
	setMaskTransparency (self, transparency=None, name=None)
	getMaskTransparency (self, name=None)
	show (self)
	image (self, data, title="", wcs=None, metadata=None)
	mtv (self, data, title="", wcs=None, metadata=None)
	Buffering (self)
	flush (self)
	erase (self)
	centroids (self, catalog, *, symbol="o", **kwargs)
	dot (self, symb, c, r, size=2, ctype=None, origin=afwImage.PARENT, **kwargs)
	line (self, points, origin=afwImage.PARENT, symbs=False, ctype=None, size=0.5)
	scale (self, algorithm, min, max=None, unit=None, **kwargs)
	zoom (self, zoomfac=None, colc=None, rowc=None, origin=afwImage.PARENT)
	pan (self, colc=None, rowc=None, origin=afwImage.PARENT)
	interact (self)
	alignImages (self, match_type="", lock_match=True)
	setCallback (self, k, func=None, noRaise=False)
	getActiveCallbackKeys (self, onlyActive=True)

Static Public Member Functions
	setDefaultBackend (backend)
	getDefaultBackend ()
	setDefaultFrame (frame=0)
	getDefaultFrame ()
	incrDefaultFrame ()
	setDefaultMaskTransparency (maskPlaneTransparency={})
	setDefaultMaskPlaneColor (name=None, color=None)
	setDefaultImageColormap (cmap)
	getDisplay (frame=None, backend=None, create=True, verbose=False, **kwargs)
	delAllDisplays ()

Public Attributes
	frame = frame
	name = backend

Protected Attributes
	_impl = _makeDisplayImpl(self, backend, **kwargs)
	_xy0 = None
dict	_maskPlaneColors = {}
dict	_callbacks = {}

Static Protected Attributes
dict	_displays = {}
	_defaultBackend = None
int	_defaultFrame = 0
	_defaultMaskPlaneColor
dict	_defaultMaskTransparency = {}
str	_defaultImageColormap = "gray"

Detailed Description

Create an object able to display images and overplot glyphs.

Parameters
----------
frame
    An identifier for the display.
backend : `str`
    The backend to use (defaults to value set by setDefaultBackend()).
**kwargs
    Arguments to pass to the backend.

Definition at line 126 of file interface.py.

Constructor & Destructor Documentation

__init__()

lsst.afw.display.interface.Display.__init__	(		self,
			frame = None,
			backend = None,
		**	kwargs )

Definition at line 158 of file interface.py.

    def __init__(self, frame=None, backend=None, **kwargs):
        if frame is None:
            frame = getDefaultFrame()
 
        if backend is None:
            if Display._defaultBackend is None:
                try:
                    setDefaultBackend("ds9")
                except RuntimeError:
                    setDefaultBackend("virtualDevice")
 
            backend = Display._defaultBackend
 
        self.frame = frame
        self._impl = _makeDisplayImpl(self, backend, **kwargs)
        self.name = backend
 
        self._xy0 = None                # displayed data's XY0
        self.setMaskTransparency(Display._defaultMaskTransparency)
        self._maskPlaneColors = {}
        self.setMaskPlaneColor(Display._defaultMaskPlaneColor)
        self.setImageColormap(Display._defaultImageColormap)
 
        self._callbacks = {}
 
        for ik in range(ord('a'), ord('z') + 1):
            k = f"{ik:c}"
            self.setCallback(k, noRaise=True)
            self.setCallback(k.upper(), noRaise=True)
 
        for k in ('Return', 'Shift_L', 'Shift_R'):
            self.setCallback(k)
 
        for k in ('q', 'Escape'):
            self.setCallback(k, lambda k, x, y: True)
 
        def _h_callback(k, x, y):
            h_callback(k, x, y)
 
            for k in sorted(self._callbacks.keys()):
                doc = self._callbacks[k].__doc__
                print("   %-6s %s" % (k, doc.split("\n")[0] if doc else "???"))
 
        self.setCallback('h', _h_callback)
 
        Display._displays[frame] = self
 

__del__()

lsst.afw.display.interface.Display.__del__

(

self

)

Definition at line 215 of file interface.py.

    def __del__(self):
        self.close()
 

Member Function Documentation

__enter__()

lsst.afw.display.interface.Display.__enter__

(

self

)

Support for python's with statement.

Definition at line 205 of file interface.py.

    def __enter__(self):
        """Support for python's with statement.
        """
        return self
 

__exit__()

lsst.afw.display.interface.Display.__exit__	(		self,
		*	args )

Support for python's with statement.

Definition at line 210 of file interface.py.

    def __exit__(self, *args):
        """Support for python's with statement.
        """
        self.close()
 

__getattr__()

lsst.afw.display.interface.Display.__getattr__	(		self,
			name )

Return the attribute of ``self._impl``, or ``._impl`` if it is
requested.

Parameters:
-----------
name : `str`
    name of the attribute requested.

Returns:
--------
attribute : `object`
    the attribute of self._impl for the requested name.

Definition at line 218 of file interface.py.

    def __getattr__(self, name):
        """Return the attribute of ``self._impl``, or ``._impl`` if it is
        requested.
 
        Parameters:
        -----------
        name : `str`
            name of the attribute requested.
 
        Returns:
        --------
        attribute : `object`
            the attribute of self._impl for the requested name.
        """
 
        if name == '_impl':
            return object.__getattr__(self, name)
 
        if not (hasattr(self, "_impl") and self._impl):
            raise AttributeError("Device has no _impl attached")
 
        try:
            return getattr(self._impl, name)
        except AttributeError:
            raise AttributeError(
                f"Device {self.name} has no attribute \"{name}\"")
 

__str__()

lsst.afw.display.interface.Display.__str__

(

self

)

Definition at line 265 of file interface.py.

    def __str__(self):
        return f"Display[{self.frame}]"
 

alignImages()

lsst.afw.display.interface.Display.alignImages	(		self,
			match_type = "",
			lock_match = True )

Align and optionally lock the orientation of the images being
displayed.

Parameters
----------
match_type : `str`, optional
    Match type to use to align the images; see the interface-specific
    docs for what values to use.
lock_match : `bool`, optional
    Whether to lock the alignment. Panning/zooming in one image will
    preserve the alignment in other images.

Definition at line 850 of file interface.py.

    def alignImages(self, match_type="", lock_match=True):
        """Align and optionally lock the orientation of the images being
        displayed.
 
        Parameters
        ----------
        match_type : `str`, optional
            Match type to use to align the images; see the interface-specific
            docs for what values to use.
        lock_match : `bool`, optional
            Whether to lock the alignment. Panning/zooming in one image will
            preserve the alignment in other images.
        """
        try:
            self._impl._alignImages(match_type, lock_match)
        except AttributeError:
            raise NotImplementedError("This feature only available on some backends.")
 

Buffering()

lsst.afw.display.interface.Display.Buffering

(

self

)

Return a context manager that will buffer repeated display
commands, to e.g. speed up displaying points.

Examples
--------
.. code-block:: py

   with display.Buffering():
       display.dot("+", xc, yc)

Definition at line 623 of file interface.py.

    def Buffering(self):
        """Return a context manager that will buffer repeated display
        commands, to e.g. speed up displaying points.
 
        Examples
        --------
        .. code-block:: py
 
           with display.Buffering():
               display.dot("+", xc, yc)
        """
        return self._Buffering(self._impl)
 

centroids()

lsst.afw.display.interface.Display.centroids	(		self,
			catalog,
		*	,
			symbol = "o",
		**	kwargs )

Draw the sources from a catalog at their pixel centroid positions
as given by `~lsst.afw.table.Catalog.getX()` and
`~lsst.afw.table.Catalog.getY()`.

See `dot` for an explanation of ``symbol`` and available args/kwargs,
which are passed to `dot`.

Parameters
----------
catalog : `lsst.afw.table.Catalog`
    Catalog to display centroids for. Must have valid `slot_Centroid`.

Definition at line 646 of file interface.py.

    def centroids(self, catalog, *, symbol="o", **kwargs):
        """Draw the sources from a catalog at their pixel centroid positions
        as given by `~lsst.afw.table.Catalog.getX()` and
        `~lsst.afw.table.Catalog.getY()`.
 
        See `dot` for an explanation of ``symbol`` and available args/kwargs,
        which are passed to `dot`.
 
        Parameters
        ----------
        catalog : `lsst.afw.table.Catalog`
            Catalog to display centroids for. Must have valid `slot_Centroid`.
        """
        if not catalog.getCentroidSlot().isValid():
            raise RuntimeError("Catalog must have a valid `slot_Centroid` defined to get X/Y positions.")
 
        with self.Buffering():
            for pt in catalog:
                self.dot(symbol, pt.getX(), pt.getY(), **kwargs)
 

close()

lsst.afw.display.interface.Display.close

(

self

)

Definition at line 245 of file interface.py.

    def close(self):
        if getattr(self, "_impl", None) is not None:
            self._impl._close()
            del self._impl
            self._impl = None
 
        if self.frame in Display._displays:
            del Display._displays[self.frame]
 

delAllDisplays()

lsst.afw.display.interface.Display.delAllDisplays ( )

static

Delete and close all known displays.

Definition at line 402 of file interface.py.

    def delAllDisplays():
        """Delete and close all known displays.
        """
        for disp in list(Display._displays.values()):
            disp.close()
        Display._displays = {}
 

dot()

lsst.afw.display.interface.Display.dot	(		self,
			symb,
			c,
			r,
			size = 2,
			ctype = None,
			origin = afwImage.PARENT,
		**	kwargs )

Draw a symbol onto the specified display frame.

Parameters
----------
symb
    Possible values are:

        ``"+"``
            Draw a +
        ``"x"``
            Draw an x
        ``"*"``
            Draw a *
        ``"o"``
            Draw a circle
        ``"@:Mxx,Mxy,Myy"``
            Draw an ellipse with moments (Mxx, Mxy, Myy) (argument size is ignored)
        `lsst.afw.geom.ellipses.BaseCore`
            Draw the ellipse (argument size is ignored). N.b. objects
            derived from `~lsst.afw.geom.ellipses.BaseCore` include
            `~lsst.afw.geom.ellipses.Axes` and `~lsst.afw.geom.ellipses.Quadrupole`.
        Any other value
            Interpreted as a string to be drawn.
c, r : `float`
    The column and row where the symbol is drawn [0-based coordinates].
size : `int`
    Size of symbol, in pixels.
ctype : `str`
    The desired color, either e.g. `lsst.afw.display.RED` or a color name known to X11
origin : `lsst.afw.image.ImageOrigin`
    Coordinate system for the given positions.
**kwargs
    Extra keyword arguments to backend.

Definition at line 666 of file interface.py.

    def dot(self, symb, c, r, size=2, ctype=None, origin=afwImage.PARENT, **kwargs):
        """Draw a symbol onto the specified display frame.
 
        Parameters
        ----------
        symb
            Possible values are:
 
                ``"+"``
                    Draw a +
                ``"x"``
                    Draw an x
                ``"*"``
                    Draw a *
                ``"o"``
                    Draw a circle
                ``"@:Mxx,Mxy,Myy"``
                    Draw an ellipse with moments (Mxx, Mxy, Myy) (argument size is ignored)
                `lsst.afw.geom.ellipses.BaseCore`
                    Draw the ellipse (argument size is ignored). N.b. objects
                    derived from `~lsst.afw.geom.ellipses.BaseCore` include
                    `~lsst.afw.geom.ellipses.Axes` and `~lsst.afw.geom.ellipses.Quadrupole`.
                Any other value
                    Interpreted as a string to be drawn.
        c, r : `float`
            The column and row where the symbol is drawn [0-based coordinates].
        size : `int`
            Size of symbol, in pixels.
        ctype : `str`
            The desired color, either e.g. `lsst.afw.display.RED` or a color name known to X11
        origin : `lsst.afw.image.ImageOrigin`
            Coordinate system for the given positions.
        **kwargs
            Extra keyword arguments to backend.
        """
        if isinstance(symb, int):
            symb = f"{symb:d}"
 
        if origin == afwImage.PARENT and self._xy0 is not None:
            x0, y0 = self._xy0
            r -= y0
            c -= x0
 
        if isinstance(symb, afwGeom.ellipses.BaseCore) or re.search(r"^@:", symb):
            try:
                mat = re.search(r"^@:([^,]+),([^,]+),([^,]+)", symb)
            except TypeError:
                pass
            else:
                if mat:
                    mxx, mxy, myy = [float(_) for _ in mat.groups()]
                    symb = afwGeom.Quadrupole(mxx, myy, mxy)
 
            symb = afwGeom.ellipses.Axes(symb)
 
        self._impl._dot(symb, c, r, size, ctype, **kwargs)
 

erase()

lsst.afw.display.interface.Display.erase

(

self

)

Erase the specified display frame.

Definition at line 641 of file interface.py.

    def erase(self):
        """Erase the specified display frame.
        """
        self._impl._erase()
 

flush()

lsst.afw.display.interface.Display.flush

(

self

)

Flush any buffering that may be provided by the backend.

Definition at line 636 of file interface.py.

    def flush(self):
        """Flush any buffering that may be provided by the backend.
        """
        self._impl._flush()
 

getActiveCallbackKeys()

lsst.afw.display.interface.Display.getActiveCallbackKeys	(		self,
			onlyActive = True )

Return all callback keys

Parameters
----------
onlyActive : `bool`
    If `True` only return keys that do something

Definition at line 902 of file interface.py.

    def getActiveCallbackKeys(self, onlyActive=True):
        """Return all callback keys
 
        Parameters
        ----------
        onlyActive : `bool`
            If `True` only return keys that do something
        """
        return sorted([k for k, func in self._callbacks.items() if
                       not (onlyActive and func == noop_callback)])
 
 
# Callbacks for display events
 
 

getDefaultBackend()

lsst.afw.display.interface.Display.getDefaultBackend ( )

static

Definition at line 281 of file interface.py.

    def getDefaultBackend():
        return Display._defaultBackend
 

getDefaultFrame()

lsst.afw.display.interface.Display.getDefaultFrame ( )

static

Get the default frame for display.

Definition at line 291 of file interface.py.

    def getDefaultFrame():
        """Get the default frame for display.
        """
        return Display._defaultFrame
 

getDisplay()

lsst.afw.display.interface.Display.getDisplay ( frame = None, backend = None, create = True, verbose = False, ** kwargs )

static

Return a specific `Display`, creating it if need be.

Parameters
----------
frame
    The desired frame (`None` => use defaultFrame
    (see `~Display.setDefaultFrame`)).
backend : `str`
    create the specified frame using this backend (or the default if
    `None`) if it doesn't already exist. If ``backend == ""``, it's an
    error to specify a non-existent ``frame``.
create : `bool`
    create the display if it doesn't already exist.
verbose : `bool`
    Allow backend to be chatty.
**kwargs
    keyword arguments passed to `Display` constructor.

Definition at line 368 of file interface.py.

    def getDisplay(frame=None, backend=None, create=True, verbose=False, **kwargs):
        """Return a specific `Display`, creating it if need be.
 
        Parameters
        ----------
        frame
            The desired frame (`None` => use defaultFrame
            (see `~Display.setDefaultFrame`)).
        backend : `str`
            create the specified frame using this backend (or the default if
            `None`) if it doesn't already exist. If ``backend == ""``, it's an
            error to specify a non-existent ``frame``.
        create : `bool`
            create the display if it doesn't already exist.
        verbose : `bool`
            Allow backend to be chatty.
        **kwargs
            keyword arguments passed to `Display` constructor.
        """
 
        if frame is None:
            frame = Display._defaultFrame
 
        if frame not in Display._displays:
            if backend == "":
                raise RuntimeError(f"Frame {frame} does not exist")
 
            Display._displays[frame] = Display(
                frame, backend, verbose=verbose, **kwargs)
 
        Display._displays[frame].verbose = verbose
        return Display._displays[frame]
 

getMaskPlaneColor()

lsst.afw.display.interface.Display.getMaskPlaneColor	(		self,
			name = None )

Return the color associated with the specified mask plane name.

Parameters
----------
name : `str`
    Desired mask plane; if `None`, return entire dict.

Definition at line 468 of file interface.py.

    def getMaskPlaneColor(self, name=None):
        """Return the color associated with the specified mask plane name.
 
        Parameters
        ----------
        name : `str`
            Desired mask plane; if `None`, return entire dict.
        """
        if name is None:
            return self._maskPlaneColors
        else:
            color = self._maskPlaneColors.get(name)
 
            if color is None:
                color = self._defaultMaskPlaneColor.get(name)
 
            return color
 

getMaskTransparency()

lsst.afw.display.interface.Display.getMaskTransparency	(		self,
			name = None )

Return the current display's mask transparency.

Definition at line 507 of file interface.py.

    def getMaskTransparency(self, name=None):
        """Return the current display's mask transparency.
        """
        return self._impl._getMaskTransparency(name)
 

image()

lsst.afw.display.interface.Display.image	(		self,
			data,
			title = "",
			wcs = None,
			metadata = None )

Display an image on a display, with semi-transparent masks
overlaid, if available.

Parameters
----------
data : `lsst.afw.image.Exposure` or `lsst.afw.image.MaskedImage` or `lsst.afw.image.Image`
    Image to display; Exposure and MaskedImage will show transparent
    mask planes.
title : `str`, optional
    Title for the display window.
wcs : `lsst.afw.geom.SkyWcs`, optional
    World Coordinate System to align an `~lsst.afw.image.MaskedImage`
    or `~lsst.afw.image.Image` to; raise an exception if ``data``
    is an `~lsst.afw.image.Exposure`.
metadata : `lsst.daf.base.PropertySet`, optional
    Additional FITS metadata to be sent to display.

Raises
------
RuntimeError
    Raised if an Exposure is passed with a non-None wcs when the
    ``wcs`` kwarg is also non-None.
TypeError
    Raised if data is an incompatible type.

Definition at line 538 of file interface.py.

    def image(self, data, title="", wcs=None, metadata=None):
        """Display an image on a display, with semi-transparent masks
        overlaid, if available.
 
        Parameters
        ----------
        data : `lsst.afw.image.Exposure` or `lsst.afw.image.MaskedImage` or `lsst.afw.image.Image`
            Image to display; Exposure and MaskedImage will show transparent
            mask planes.
        title : `str`, optional
            Title for the display window.
        wcs : `lsst.afw.geom.SkyWcs`, optional
            World Coordinate System to align an `~lsst.afw.image.MaskedImage`
            or `~lsst.afw.image.Image` to; raise an exception if ``data``
            is an `~lsst.afw.image.Exposure`.
        metadata : `lsst.daf.base.PropertySet`, optional
            Additional FITS metadata to be sent to display.
 
        Raises
        ------
        RuntimeError
            Raised if an Exposure is passed with a non-None wcs when the
            ``wcs`` kwarg is also non-None.
        TypeError
            Raised if data is an incompatible type.
        """
        if hasattr(data, "getXY0"):
            self._xy0 = data.getXY0()
        else:
            self._xy0 = None
 
        # It's an Exposure; display the MaskedImage with the WCS
        if isinstance(data, afwImage.Exposure):
            if wcs:
                raise RuntimeError("You may not specify a wcs with an Exposure")
            data, wcs, metadata = data.getMaskedImage(), data.wcs, data.metadata
        # it's a DecoratedImage; display it
        elif isinstance(data, afwImage.DecoratedImage):
            try:
                wcs = afwGeom.makeSkyWcs(data.getMetadata())
            except TypeError:
                wcs = None
            data = data.image
 
            self._xy0 = data.getXY0()   # DecoratedImage doesn't have getXY0()
 
        if isinstance(data, afwImage.Image):  # it's an Image; display it
            self._impl._mtv(data, None, wcs, title, metadata)
        # It's a Mask; display it, bitplane by bitplane.
        elif isinstance(data, afwImage.Mask):
            self.__addMissingMaskPlanes(data)
            # Some displays can't display a Mask without an image; so display
            # an Image too, with pixel values set to the mask.
            self._impl._mtv(afwImage.ImageI(data.array), data, wcs, title, metadata)
        # It's a MaskedImage; display Image and overlay Mask.
        elif isinstance(data, afwImage.MaskedImage):
            self.__addMissingMaskPlanes(data.mask)
            self._impl._mtv(data.image, data.mask, wcs, title, metadata)
        else:
            raise TypeError(f"Unsupported type {data!r}")
 

incrDefaultFrame()

lsst.afw.display.interface.Display.incrDefaultFrame ( )

static

Increment the default frame for display.

Definition at line 297 of file interface.py.

    def incrDefaultFrame():
        """Increment the default frame for display.
        """
        Display._defaultFrame += 1
        return Display._defaultFrame
 

interact()

lsst.afw.display.interface.Display.interact

(

self

)

Enter an interactive loop, listening for key presses or equivalent
UI actions in the display and firing callbacks.

Exit with ``q``, ``CR``, ``ESC``, or any equivalent UI action provided
in the display. The loop may also be exited by returning `True` from a
user-provided callback function.

Definition at line 825 of file interface.py.

    def interact(self):
        """Enter an interactive loop, listening for key presses or equivalent
        UI actions in the display and firing callbacks.
 
        Exit with ``q``, ``CR``, ``ESC``, or any equivalent UI action provided
        in the display. The loop may also be exited by returning `True` from a
        user-provided callback function.
        """
        interactFinished = False
 
        while not interactFinished:
            ev = self._impl._getEvent()
            if not ev:
                continue
            k, x, y = ev.k, ev.x, ev.y      # for now
 
            if k not in self._callbacks:
                logger.warning("No callback registered for %s", k)
            else:
                try:
                    interactFinished = self._callbacks[k](k, x, y)
                except Exception:
                    logger.exception(
                        "Display._callbacks['%s'](%s,%s,%s) failed.", k, x, y)
 

line()

lsst.afw.display.interface.Display.line	(		self,
			points,
			origin = afwImage.PARENT,
			symbs = False,
			ctype = None,
			size = 0.5 )

Draw a set of symbols or connect points

Parameters
----------
points : `list`
    A list of (col, row)
origin : `lsst.afw.image.ImageOrigin`
    Coordinate system for the given positions.
symbs : `bool` or sequence
    If ``symbs`` is `True`, draw points at the specified points using
    the desired symbol, otherwise connect the dots.

    If ``symbs`` supports indexing (which includes a string -- caveat
    emptor) the elements are used to label the points.
ctype : `str`
    ``ctype`` is the name of a color (e.g. 'red').
size : `float`
    Size of points to create if `symbs` is passed.

Definition at line 723 of file interface.py.

    def line(self, points, origin=afwImage.PARENT, symbs=False, ctype=None, size=0.5):
        """Draw a set of symbols or connect points
 
        Parameters
        ----------
        points : `list`
            A list of (col, row)
        origin : `lsst.afw.image.ImageOrigin`
            Coordinate system for the given positions.
        symbs : `bool` or sequence
            If ``symbs`` is `True`, draw points at the specified points using
            the desired symbol, otherwise connect the dots.
 
            If ``symbs`` supports indexing (which includes a string -- caveat
            emptor) the elements are used to label the points.
        ctype : `str`
            ``ctype`` is the name of a color (e.g. 'red').
        size : `float`
            Size of points to create if `symbs` is passed.
        """
        if symbs:
            try:
                symbs[1]
            except TypeError:
                symbs = len(points)*list(symbs)
 
            for i, xy in enumerate(points):
                self.dot(symbs[i], *xy, size=size, ctype=ctype)
        else:
            if len(points) > 0:
                if origin == afwImage.PARENT and self._xy0 is not None:
                    x0, y0 = self._xy0
                    _points = list(points)  # make a mutable copy
                    for i, p in enumerate(points):
                        _points[i] = (p[0] - x0, p[1] - y0)
                    points = _points
 
                self._impl._drawLines(points, ctype)
 

maskColorGenerator()

lsst.afw.display.interface.Display.maskColorGenerator	(		self,
			omitBW = True )

A generator for "standard" colors.

Parameters
----------
omitBW : `bool`
    Don't include `BLACK` and `WHITE`.

Examples
--------

.. code-block:: py

   colorGenerator = interface.maskColorGenerator(omitBW=True)
   for p in planeList:
       print(p, next(colorGenerator))

Definition at line 409 of file interface.py.

    def maskColorGenerator(self, omitBW=True):
        """A generator for "standard" colors.
 
        Parameters
        ----------
        omitBW : `bool`
            Don't include `BLACK` and `WHITE`.
 
        Examples
        --------
 
        .. code-block:: py
 
           colorGenerator = interface.maskColorGenerator(omitBW=True)
           for p in planeList:
               print(p, next(colorGenerator))
        """
        _maskColors = [WHITE, BLACK, RED, GREEN,
                       BLUE, CYAN, MAGENTA, YELLOW, ORANGE]
 
        i = -1
        while True:
            i += 1
            color = _maskColors[i%len(_maskColors)]
            if omitBW and color in (BLACK, WHITE):
                continue
 
            yield color
 

mtv()

lsst.afw.display.interface.Display.mtv	(		self,
			data,
			title = "",
			wcs = None,
			metadata = None )

Display an image on a display, with semi-transparent masks
overlaid, if available.

Notes
-----
Historical note: the name "mtv" comes from Jim Gunn's forth imageprocessing
system, Mirella (named after Mirella Freni); The "m" stands for Mirella.

Definition at line 599 of file interface.py.

    def mtv(self, data, title="", wcs=None, metadata=None):
        """Display an image on a display, with semi-transparent masks
        overlaid, if available.
 
        Notes
        -----
        Historical note: the name "mtv" comes from Jim Gunn's forth imageprocessing
        system, Mirella (named after Mirella Freni); The "m" stands for Mirella.
        """
        self.image(data, title, wcs, metadata)
 

pan()

lsst.afw.display.interface.Display.pan	(		self,
			colc = None,
			rowc = None,
			origin = afwImage.PARENT )

Pan to a location.

Parameters
----------
colc, rowc
    Coordinates to pan to.
origin : `lsst.afw.image.ImageOrigin`
    Coordinate system for the given positions.

See also
--------
Display.zoom

Definition at line 809 of file interface.py.

    def pan(self, colc=None, rowc=None, origin=afwImage.PARENT):
        """Pan to a location.
 
        Parameters
        ----------
        colc, rowc
            Coordinates to pan to.
        origin : `lsst.afw.image.ImageOrigin`
            Coordinate system for the given positions.
 
        See also
        --------
        Display.zoom
        """
        self.zoom(None, colc, rowc, origin)
 

scale()

lsst.afw.display.interface.Display.scale	(		self,
			algorithm,
			min,
			max = None,
			unit = None,
		**	kwargs )

Set the range of the scaling from DN in the image to the image
display.

Parameters
----------
algorithm : `str`
    Desired scaling (e.g. "linear" or "asinh").
min
    Minimum value, or "minmax" or "zscale".
max
    Maximum value (must be `None` for minmax|zscale).
unit
    Units for min and max (e.g. Percent, Absolute, Sigma; `None` if
    min==minmax|zscale).
**kwargs
    Optional keyword arguments to the backend.

Definition at line 762 of file interface.py.

    def scale(self, algorithm, min, max=None, unit=None, **kwargs):
        """Set the range of the scaling from DN in the image to the image
        display.
 
        Parameters
        ----------
        algorithm : `str`
            Desired scaling (e.g. "linear" or "asinh").
        min
            Minimum value, or "minmax" or "zscale".
        max
            Maximum value (must be `None` for minmax|zscale).
        unit
            Units for min and max (e.g. Percent, Absolute, Sigma; `None` if
            min==minmax|zscale).
        **kwargs
            Optional keyword arguments to the backend.
        """
        if min in ("minmax", "zscale"):
            assert max is None, f"You may not specify \"{min}\" and max"
            assert unit is None, f"You may not specify \"{min}\" and unit"
        elif max is None:
            raise RuntimeError("Please specify max")
 
        self._impl._scale(algorithm, min, max, unit, **kwargs)
 

setCallback()

lsst.afw.display.interface.Display.setCallback	(		self,
			k,
			func = None,
			noRaise = False )

Set the callback for a key.

Backend displays may provide an equivalent graphical UI action, but
must make the associated key letter visible in the UI in some way.

Parameters
----------
k : `str`
    The key to assign the callback to.
func : callable
    The callback assigned to ``k``.
noRaise : `bool`
    Do not raise if ``k`` is already in use.

Returns
-------
oldFunc : callable
    The callback previously assigned to ``k``.

Definition at line 868 of file interface.py.

    def setCallback(self, k, func=None, noRaise=False):
        """Set the callback for a key.
 
        Backend displays may provide an equivalent graphical UI action, but
        must make the associated key letter visible in the UI in some way.
 
        Parameters
        ----------
        k : `str`
            The key to assign the callback to.
        func : callable
            The callback assigned to ``k``.
        noRaise : `bool`
            Do not raise if ``k`` is already in use.
 
        Returns
        -------
        oldFunc : callable
            The callback previously assigned to ``k``.
        """
 
        if k in "f":
            if noRaise:
                return
            raise RuntimeError(
                f"Key '{k}' is already in use by display, so I can't add a callback for it")
 
        ofunc = self._callbacks.get(k)
        self._callbacks[k] = func if func else noop_callback
 
        self._impl._setCallback(k, self._callbacks[k])
 
        return ofunc
 

setDefaultBackend()

lsst.afw.display.interface.Display.setDefaultBackend ( backend )

static

Definition at line 271 of file interface.py.

    def setDefaultBackend(backend):
        try:
            _makeDisplayImpl(None, backend)
        except Exception as e:
            raise RuntimeError(
                f"Unable to set backend to {backend}: \"{e}\"")
 
        Display._defaultBackend = backend
 

setDefaultFrame()

lsst.afw.display.interface.Display.setDefaultFrame ( frame = 0 )

static

Set the default frame for display.

Definition at line 285 of file interface.py.

    def setDefaultFrame(frame=0):
        """Set the default frame for display.
        """
        Display._defaultFrame = frame
 

setDefaultImageColormap()

lsst.afw.display.interface.Display.setDefaultImageColormap ( cmap )

static

Set the default colormap for images.

Parameters
----------
cmap : `str`
    Name of colormap, as interpreted by the backend.

Notes
-----
The only colormaps that all backends are required to honor
(if they pay any attention to setImageColormap) are "gray" and "grey".

Definition at line 335 of file interface.py.

    def setDefaultImageColormap(cmap):
        """Set the default colormap for images.
 
        Parameters
        ----------
        cmap : `str`
            Name of colormap, as interpreted by the backend.
 
        Notes
        -----
        The only colormaps that all backends are required to honor
        (if they pay any attention to setImageColormap) are "gray" and "grey".
        """
 
        Display._defaultImageColormap = cmap
 

setDefaultMaskPlaneColor()

lsst.afw.display.interface.Display.setDefaultMaskPlaneColor ( name = None, color = None )

static

Set the default mapping from mask plane names to colors.

Parameters
----------
name : `str` or `dict`
    Name of mask plane, or a dict mapping names to colors
    If name is `None`, use the hard-coded default dictionary.
color
    Desired color, or `None` if name is a dict.

Definition at line 311 of file interface.py.

    def setDefaultMaskPlaneColor(name=None, color=None):
        """Set the default mapping from mask plane names to colors.
 
        Parameters
        ----------
        name : `str` or `dict`
            Name of mask plane, or a dict mapping names to colors
            If name is `None`, use the hard-coded default dictionary.
        color
            Desired color, or `None` if name is a dict.
        """
 
        if name is None:
            name = Display._defaultMaskPlaneColor
 
        if isinstance(name, dict):
            assert color is None
            for k, v in name.items():
                setDefaultMaskPlaneColor(k, v)
            return
        # Set the individual color values
        Display._defaultMaskPlaneColor[name] = color
 

setDefaultMaskTransparency()

lsst.afw.display.interface.Display.setDefaultMaskTransparency ( maskPlaneTransparency = {} )

static

Definition at line 304 of file interface.py.

    def setDefaultMaskTransparency(maskPlaneTransparency={}):
        if hasattr(maskPlaneTransparency, "copy"):
            maskPlaneTransparency = maskPlaneTransparency.copy()
 
        Display._defaultMaskTransparency = maskPlaneTransparency
 

setImageColormap()

lsst.afw.display.interface.Display.setImageColormap	(		self,
			cmap )

Set the colormap to use for images.

 Parameters
----------
cmap : `str`
    Name of colormap, as interpreted by the backend.

Notes
-----
The only colormaps that all backends are required to honor
(if they pay any attention to setImageColormap) are "gray" and "grey".

Definition at line 351 of file interface.py.

    def setImageColormap(self, cmap):
        """Set the colormap to use for images.
 
         Parameters
        ----------
        cmap : `str`
            Name of colormap, as interpreted by the backend.
 
        Notes
        -----
        The only colormaps that all backends are required to honor
        (if they pay any attention to setImageColormap) are "gray" and "grey".
        """
 
        self._impl._setImageColormap(cmap)
 

setMaskPlaneColor()

lsst.afw.display.interface.Display.setMaskPlaneColor	(		self,
			name,
			color = None )

Request that mask plane name be displayed as color.

Parameters
----------
name : `str` or `dict`
    Name of mask plane or a dictionary of name -> colorName.
color : `str`
    The name of the color to use (must be `None` if ``name`` is a
    `dict`).

    Colors may be specified as any X11-compliant string (e.g.
    `"orchid"`), or by one of the following constants in
    `lsst.afw.display` : `BLACK`, `WHITE`, `RED`, `BLUE`,
    `GREEN`, `CYAN`, `MAGENTA`, `YELLOW`.

    If the color is "ignore" (or `IGNORE`) then that mask plane is not
    displayed.

    The advantage of using the symbolic names is that the python
    interpreter can detect typos.

Definition at line 438 of file interface.py.

    def setMaskPlaneColor(self, name, color=None):
        """Request that mask plane name be displayed as color.
 
        Parameters
        ----------
        name : `str` or `dict`
            Name of mask plane or a dictionary of name -> colorName.
        color : `str`
            The name of the color to use (must be `None` if ``name`` is a
            `dict`).
 
            Colors may be specified as any X11-compliant string (e.g.
            `"orchid"`), or by one of the following constants in
            `lsst.afw.display` : `BLACK`, `WHITE`, `RED`, `BLUE`,
            `GREEN`, `CYAN`, `MAGENTA`, `YELLOW`.
 
            If the color is "ignore" (or `IGNORE`) then that mask plane is not
            displayed.
 
            The advantage of using the symbolic names is that the python
            interpreter can detect typos.
        """
        if isinstance(name, dict):
            assert color is None
            for k, v in name.items():
                self.setMaskPlaneColor(k, v)
            return
 
        self._maskPlaneColors[name] = color
 

setMaskTransparency()

lsst.afw.display.interface.Display.setMaskTransparency	(		self,
			transparency = None,
			name = None )

Specify display's mask transparency (percent); or `None` to not set
it when loading masks.

Definition at line 486 of file interface.py.

    def setMaskTransparency(self, transparency=None, name=None):
        """Specify display's mask transparency (percent); or `None` to not set
        it when loading masks.
        """
        if isinstance(transparency, dict):
            assert name is None
            for k, v in transparency.items():
                self.setMaskTransparency(v, k)
            return
 
        if transparency is not None and (transparency < 0 or transparency > 100):
            print(
                "Mask transparency should be in the range [0, 100]; clipping", file=sys.stderr)
            if transparency < 0:
                transparency = 0
            else:
                transparency = 100
 
        if transparency is not None:
            self._impl._setMaskTransparency(transparency, name)
 

show()

lsst.afw.display.interface.Display.show

(

self

)

Uniconify and Raise display.

Notes
-----
Throws an exception if frame doesn't exit.

Definition at line 512 of file interface.py.

    def show(self):
        """Uniconify and Raise display.
 
        Notes
        -----
        Throws an exception if frame doesn't exit.
        """
        return self._impl._show()
 

verbose() [1/2]

lsst.afw.display.interface.Display.verbose

(

self

)

The backend's verbosity.

Definition at line 255 of file interface.py.

    def verbose(self):
        """The backend's verbosity.
        """
        return self._impl.verbose
 

verbose() [2/2]

lsst.afw.display.interface.Display.verbose	(		self,
			value )

Definition at line 261 of file interface.py.

    def verbose(self, value):
        if self._impl:
            self._impl.verbose = value
 

zoom()

lsst.afw.display.interface.Display.zoom	(		self,
			zoomfac = None,
			colc = None,
			rowc = None,
			origin = afwImage.PARENT )

Zoom frame by specified amount, optionally panning also

Definition at line 788 of file interface.py.

    def zoom(self, zoomfac=None, colc=None, rowc=None, origin=afwImage.PARENT):
        """Zoom frame by specified amount, optionally panning also
        """
        if (rowc and colc is None) or (colc and rowc is None):
            raise RuntimeError(
                "Please specify row and column center to pan about")
 
        if rowc is not None:
            if origin == afwImage.PARENT and self._xy0 is not None:
                x0, y0 = self._xy0
                colc -= x0
                rowc -= y0
 
            self._impl._pan(colc, rowc)
 
        if zoomfac is None and rowc is None:
            zoomfac = 2
 
        if zoomfac is not None:
            self._impl._zoom(zoomfac)
 

Member Data Documentation

_callbacks

dict lsst.afw.display.interface.Display._callbacks = {}

protected

Definition at line 181 of file interface.py.

_defaultBackend

lsst.afw.display.interface.Display._defaultBackend = None

staticprotected

Definition at line 139 of file interface.py.

_defaultFrame

int lsst.afw.display.interface.Display._defaultFrame = 0

staticprotected

Definition at line 140 of file interface.py.

_defaultImageColormap

str lsst.afw.display.interface.Display._defaultImageColormap = "gray"

staticprotected

Definition at line 156 of file interface.py.

_defaultMaskPlaneColor

lsst.afw.display.interface.Display._defaultMaskPlaneColor

staticprotected

Initial value:

=  dict(
        BAD=RED,
        CR=MAGENTA,
        EDGE=YELLOW,
        INTERPOLATED=GREEN,
        SATURATED=GREEN,
        DETECTED=BLUE,
        DETECTED_NEGATIVE=CYAN,
        SUSPECT=YELLOW,
        NO_DATA=ORANGE,
        # deprecated names
        INTRP=GREEN,
        SAT=GREEN,
    )

Definition at line 141 of file interface.py.

_defaultMaskTransparency

dict lsst.afw.display.interface.Display._defaultMaskTransparency = {}

staticprotected

Definition at line 155 of file interface.py.

_displays

dict lsst.afw.display.interface.Display._displays = {}

staticprotected

Definition at line 138 of file interface.py.

_impl

lsst.afw.display.interface.Display._impl = _makeDisplayImpl(self, backend, **kwargs)

protected

Definition at line 172 of file interface.py.

_maskPlaneColors

dict lsst.afw.display.interface.Display._maskPlaneColors = {}

protected

Definition at line 177 of file interface.py.

_xy0

lsst.afw.display.interface.Display._xy0 = None

protected

Definition at line 175 of file interface.py.

frame

lsst.afw.display.interface.Display.frame = frame

Definition at line 171 of file interface.py.

name

lsst.afw.display.interface.Display.name = backend

Definition at line 173 of file interface.py.

---

The documentation for this class was generated from the following file:

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-12.0.0/Linux/afw/g083dd6704c+a047e97985/python/lsst/afw/display/interface.py