lsst.afw.display.interface.Display Class Reference

Classes
class	_Buffering

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

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

Public Attributes
	frame
	name

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())
*args
    Arguments to pass to the backend
**kwargs
    Arguments to pass to the backend

Definition at line 118 of file interface.py.

Constructor & Destructor Documentation

__init__()

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

Definition at line 152 of file interface.py.

    def __init__(self, frame=None, backend=None, *args, **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, *args, **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__()

def lsst.afw.display.interface.Display.__del__

(

self

)

Definition at line 209 of file interface.py.

    def __del__(self):
        self.close()
 

Member Function Documentation

__enter__()

def lsst.afw.display.interface.Display.__enter__

(

self

)

Support for python's with statement

Definition at line 199 of file interface.py.

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

__exit__()

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

Support for python's with statement

Definition at line 204 of file interface.py.

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

__getattr__()

def 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 212 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__()

def lsst.afw.display.interface.Display.__str__

(

self

)

Definition at line 258 of file interface.py.

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

Buffering()

def lsst.afw.display.interface.Display.Buffering

(

self

)

Return a class intended to be used with python's with statement

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

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

Definition at line 572 of file interface.py.

    def Buffering(self):
        """Return a class intended to be used with python's with statement
 
        Examples
        --------
        .. code-block:: py
 
           with display.Buffering():
               display.dot("+", xc, yc)
        """
        return self._Buffering(self._impl)
 

close()

def lsst.afw.display.interface.Display.close

(

self

)

Definition at line 238 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()

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

static

Delete and close all known displays

Definition at line 399 of file interface.py.

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

dot()

def lsst.afw.display.interface.Display.dot	(		self,
			symb,
			c,
			r,
			size = 2,
			ctype = None,
			origin = afwImage.PARENT,
		*	args,
		**	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
    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.
*args
    Extra arguments to backend
**kwargs
    Extra keyword arguments to backend

Definition at line 594 of file interface.py.

    def dot(self, symb, c, r, size=2, ctype=None, origin=afwImage.PARENT, *args, **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
            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.
        *args
            Extra arguments to backend
        **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()

def lsst.afw.display.interface.Display.erase

(

self

)

Erase the specified display frame

Definition at line 589 of file interface.py.

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

flush()

def lsst.afw.display.interface.Display.flush

(

self

)

Flush the buffers

Definition at line 584 of file interface.py.

    def flush(self):
        """Flush the buffers
        """
        self._impl._flush()
 

getActiveCallbackKeys()

def 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 814 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()

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

static

Definition at line 275 of file interface.py.

    def getDefaultBackend():
        return Display._defaultBackend
 

getDefaultFrame()

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

static

Get the default frame for display

Definition at line 285 of file interface.py.

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

getDisplay()

def lsst.afw.display.interface.Display.getDisplay (   frame = None,   backend = None,   create = True,   verbose = False, *  args, **  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
*args
    arguments passed to `Display` constructor
**kwargs
    keyword arguments passed to `Display` constructor

Definition at line 364 of file interface.py.

    def getDisplay(frame=None, backend=None, create=True, verbose=False, *args, **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
        *args
            arguments passed to `Display` constructor
        **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, *args, **kwargs)
 
        Display._displays[frame].verbose = verbose
        return Display._displays[frame]
 

getMaskPlaneColor()

def 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 462 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:
            return self._maskPlaneColors.get(name)
 

getMaskTransparency()

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

Return the current display's mask transparency

Definition at line 497 of file interface.py.

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

incrDefaultFrame()

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

static

Increment the default frame for display

Definition at line 291 of file interface.py.

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

interact()

def lsst.afw.display.interface.Display.interact

(

self

)

Enter an interactive loop, listening for key presses in display and firing callbacks.

Exit with ``q``, ``CR``, ``ESC``, or any other callback function that returns a `True` value.

Definition at line 762 of file interface.py.

    def interact(self):
        """Enter an interactive loop, listening for key presses in display and firing callbacks.
 
        Exit with ``q``, ``CR``, ``ESC``, or any other callback function that returns a `True` value.
        """
        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.warn("No callback registered for {0}".format(k))
            else:
                try:
                    interactFinished = self._callbacks[k](k, x, y)
                except Exception as e:
                    logger.error(
                        "Display._callbacks['{0}']({0},{1},{2}) failed: {3}".format(k, x, y, e))
 

line()

def 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`

Definition at line 653 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`
        """
        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()

def 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 406 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()

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

Display an `~lsst.afw.image.Image` or `~lsst.afw.image.Mask` on a display

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 512 of file interface.py.

    def mtv(self, data, title="", wcs=None):
        """Display an `~lsst.afw.image.Image` or `~lsst.afw.image.Mask` on a display
 
        Notes
        -----
        Historical note: the name "mtv" comes from Jim Gunn's forth imageprocessing
        system, Mirella (named after Mirella Freni); The "m" stands for Mirella.
        """
        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 = data.getMaskedImage(), data.getWcs()
        elif isinstance(data, afwImage.DecoratedImage):  # it's a DecoratedImage; display it
            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)
        # it's a Mask; display it, bitplane by bitplane
        elif isinstance(data, afwImage.Mask):
            #
            # 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.getArray()), data, wcs, title)
        # it's a MaskedImage; display Image and overlay Mask
        elif isinstance(data, afwImage.MaskedImage):
            self._impl._mtv(data.getImage(), data.getMask(), wcs, title)
        else:
            raise RuntimeError(f"Unsupported type {data!r}")

pan()

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

Pan to a location

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

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

Definition at line 745 of file interface.py.

    def pan(self, colc=None, rowc=None, origin=afwImage.PARENT):
        """Pan to a location
 
        Parameters
        ----------
        colc, rowc
            the 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()

def lsst.afw.display.interface.Display.scale	(		self,
			algorithm,
			min,
			max = None,
			unit = None,
		*	args,
		**	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)
*args
    Optional arguments to the backend
**kwargs
    Optional keyword arguments to the backend

Definition at line 694 of file interface.py.

    def scale(self, algorithm, min, max=None, unit=None, *args, **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)
        *args
            Optional arguments to the backend
        **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, *args, **kwargs)

setCallback()

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

Set the callback for a key

Parameters
----------
k
    The key to assign the callback to
func : callable
    The callback assigned to ``k``
noRaise : `bool`

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

Definition at line 784 of file interface.py.

    def setCallback(self, k, func=None, noRaise=False):
        """Set the callback for a key
 
        Parameters
        ----------
        k
            The key to assign the callback to
        func : callable
            The callback assigned to ``k``
        noRaise : `bool`
 
        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()

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

static

Definition at line 265 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()

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

static

Set the default frame for display

Definition at line 279 of file interface.py.

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

setDefaultImageColormap()

def 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 331 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()

def 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 305 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()

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

static

Definition at line 298 of file interface.py.

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

setImageColormap()

def 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 347 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()

def 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 435 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()

def 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 476 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()

def lsst.afw.display.interface.Display.show

(

self

)

Uniconify and Raise display.

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

Definition at line 503 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]

def lsst.afw.display.interface.Display.verbose

(

self

)

The backend's verbosity

Definition at line 248 of file interface.py.

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

verbose() [2/2]

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

Definition at line 254 of file interface.py.

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

zoom()

def 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 723 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

frame

lsst.afw.display.interface.Display.frame

Definition at line 165 of file interface.py.

name

lsst.afw.display.interface.Display.name

Definition at line 167 of file interface.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/afw/22.0.1-42-gca6935d93+ba5e5ca3eb/python/lsst/afw/display/interface.py