lsst.display.matplotlib.matplotlib.DisplayImpl Class Reference

Inheritance diagram for lsst.display.matplotlib.matplotlib.DisplayImpl:

Public Member Functions
	__init__ (self, display, verbose=False, interpretMaskBits=True, mtvOrigin=afwImage.PARENT, fastMaskDisplay=False, reopenPlot=False, useSexagesimal=False, dpi=None, *args, **kwargs)
	savefig (self, *args, **kwargs)
	show_colorbar (self, show=True, where="right", axSize="5%", axPad=None, **kwargs)
	useSexagesimal (self, useSexagesimal)
	wait (self, prompt="[c(ontinue) p(db)] :", allowPdb=True)

Protected Member Functions
	_close (self)
	Close the display, cleaning up any allocated resources.
	_show (self)
	_setMaskTransparency (self, transparency, maskplane)
	_getMaskTransparency (self, maskplane=None)
	_mtv (self, image, mask=None, wcs=None, title="")
	_i_mtv (self, data, wcs, title, isMask)
	_i_setImage (self, image, mask=None, wcs=None)
	_setImageColormap (self, cmap)
	_buffer (self, enable=True)
	_flush (self)
	_erase (self)
	_dot (self, symb, c, r, size, ctype, fontFamily="helvetica", textAngle=None)
	_drawLines (self, points, ctype)
	_scale (self, algorithm, minval, maxval, unit, *args, **kwargs)
	_i_scale (self, algorithm, minval, maxval, unit, *args, **kwargs)
	_zoom (self, zoomfac)
	_pan (self, colc, rowc)
	_getEvent (self, timeout=-1)

Protected Attributes
	_figure
	_display
	_maskTransparency
	_interpretMaskBits
	_fastMaskDisplay
	_useSexagesimal
	_mtvOrigin
	_mappable_ax
	_colorbar_ax
	_image_colormap
	_scaleArgs
	_normalize
	_image
	_mask
	_wcs
	_title
	_xy0
	_zoomfac
	_width
	_height
	_xcen
	_ycen

Detailed Description

Provide a matplotlib backend for afwDisplay

Recommended backends in notebooks are:
  %matplotlib notebook
or
  %matplotlib ipympl
or
  %matplotlib qt
  %gui qt
or
  %matplotlib inline
or
  %matplotlib osx

Apparently only qt supports Display.interact(); the list of interactive
backends is given by lsst.display.matplotlib.interactiveBackends

Definition at line 80 of file matplotlib.py.

Constructor & Destructor Documentation

__init__()

lsst.display.matplotlib.matplotlib.DisplayImpl.__init__	(		self,
			display,
			verbose = False,
			interpretMaskBits = True,
			mtvOrigin = afwImage.PARENT,
			fastMaskDisplay = False,
			reopenPlot = False,
			useSexagesimal = False,
			dpi = None,
		*	args,
		**	kwargs )

Initialise a matplotlib display

@param fastMaskDisplay      If True only show the first bitplane that's
                            set in each pixel
                            (e.g. if (SATURATED & DETECTED)
                            ignore DETECTED)
                            Not really what we want, but a bit faster
@param interpretMaskBits    Interpret the mask value under the cursor
@param mtvOrigin            Display pixel coordinates with LOCAL origin
                            (bottom left == 0,0 not XY0)
@param reopenPlot           If true, close the plot before opening it.
                            (useful with e.g. %ipympl)
@param useSexagesimal       If True, display coordinates in sexagesimal
                            E.g. hh:mm:ss.ss (default:False)
                            May be changed by calling
                                  display.useSexagesimal()
@param dpi                  Number of dpi (passed to pyplot.figure)

The `frame` argument to `Display` may be a matplotlib figure; this
permits code such as
   fig, axes = plt.subplots(1, 2)

   disp = afwDisplay.Display(fig)
   disp.scale('asinh', 'zscale', Q=0.5)

   for axis, exp in zip(axes, exps):
      plt.sca(axis)    # make axis active
      disp.mtv(exp)

Definition at line 98 of file matplotlib.py.

                 reopenPlot=False, useSexagesimal=False, dpi=None, *args, **kwargs):
        """
        Initialise a matplotlib display
 
        @param fastMaskDisplay      If True only show the first bitplane that's
                                    set in each pixel
                                    (e.g. if (SATURATED & DETECTED)
                                    ignore DETECTED)
                                    Not really what we want, but a bit faster
        @param interpretMaskBits    Interpret the mask value under the cursor
        @param mtvOrigin            Display pixel coordinates with LOCAL origin
                                    (bottom left == 0,0 not XY0)
        @param reopenPlot           If true, close the plot before opening it.
                                    (useful with e.g. %ipympl)
        @param useSexagesimal       If True, display coordinates in sexagesimal
                                    E.g. hh:mm:ss.ss (default:False)
                                    May be changed by calling
                                          display.useSexagesimal()
        @param dpi                  Number of dpi (passed to pyplot.figure)
 
        The `frame` argument to `Display` may be a matplotlib figure; this
        permits code such as
           fig, axes = plt.subplots(1, 2)
 
           disp = afwDisplay.Display(fig)
           disp.scale('asinh', 'zscale', Q=0.5)
 
           for axis, exp in zip(axes, exps):
              plt.sca(axis)    # make axis active
              disp.mtv(exp)
        """
        if hasattr(display.frame, "number"):   # the "display" quacks like a matplotlib figure
            figure = display.frame
        else:
            figure = None
 
        virtualDevice.DisplayImpl.__init__(self, display, verbose)
 
        if reopenPlot:
            pyplot.close(display.frame)
 
        if figure is not None:
            self._figure = figure
        else:
            self._figure = pyplot.figure(display.frame, dpi=dpi)
            self._figure.clf()
 
        self._display = display
        self._maskTransparency = {None: 0.7}
        self._interpretMaskBits = interpretMaskBits  # interpret mask bits in mtv
        self._fastMaskDisplay = fastMaskDisplay
        self._useSexagesimal = [useSexagesimal]  # use an array so we can modify the value in format_coord
        self._mtvOrigin = mtvOrigin
        self._mappable_ax = None
        self._colorbar_ax = None
        self._image_colormap = pyplot.cm.gray
        #
        self.__alpha = unicodedata.lookup("GREEK SMALL LETTER alpha")  # used in cursor display string
        self.__delta = unicodedata.lookup("GREEK SMALL LETTER delta")  # used in cursor display string
        #
        # Support self._scale()
        #
        self._scaleArgs = dict()
        self._normalize = None
        #
        # Support self._erase(), reporting pixel/mask values, and
        # zscale/minmax; set in mtv
        #
        self._i_setImage(None)
 

Member Function Documentation

_buffer()

lsst.display.matplotlib.matplotlib.DisplayImpl._buffer ( self, enable = True )

protected

Definition at line 522 of file matplotlib.py.

    def _buffer(self, enable=True):
        if enable:
            pyplot.ioff()
        else:
            pyplot.ion()
            self._figure.show()
 

_close()

lsst.display.matplotlib.matplotlib.DisplayImpl._close ( self )

protected

Close the display, cleaning up any allocated resources.

Definition at line 170 of file matplotlib.py.

    def _close(self):
        """!Close the display, cleaning up any allocated resources"""
        self._image = None
        self._mask = None
        self._wcs = None
        self._figure.gca().format_coord = lambda x, y: None  # keeps a copy of _wcs
 

_dot()

lsst.display.matplotlib.matplotlib.DisplayImpl._dot ( self, symb, c, r, size, ctype, fontFamily = "helvetica", textAngle = None )

protected

Draw a symbol at (col,row) = (c,r) [0-based coordinates]
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)
    An afwGeom.ellipses.Axes Draw the ellipse (argument size is
                             ignored)

Any other value is interpreted as a string to be drawn. Strings obey the
fontFamily (which may be extended with other characteristics, e.g.
"times bold italic".  Text will be drawn rotated by textAngle
(textAngle is ignored otherwise).

Definition at line 541 of file matplotlib.py.

             fontFamily="helvetica", textAngle=None):
        """Draw a symbol at (col,row) = (c,r) [0-based coordinates]
    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)
            An afwGeom.ellipses.Axes Draw the ellipse (argument size is
                                     ignored)
 
    Any other value is interpreted as a string to be drawn. Strings obey the
    fontFamily (which may be extended with other characteristics, e.g.
    "times bold italic".  Text will be drawn rotated by textAngle
    (textAngle is ignored otherwise).
    """
        if not ctype:
            ctype = afwDisplay.GREEN
 
        axis = self._figure.gca()
        x0, y0 = self._xy0
 
        if isinstance(symb, afwGeom.ellipses.Axes):
            from matplotlib.patches import Ellipse
 
            # Following matplotlib.patches.Ellipse documentation 'width' and
            # 'height' are diameters while 'angle' is rotation in degrees
            # (anti-clockwise)
            axis.add_artist(Ellipse((c + x0, r + y0), height=2*symb.getA(), width=2*symb.getB(),
                                    angle=90.0 + math.degrees(symb.getTheta()),
                                    edgecolor=mapCtype(ctype), facecolor='none'))
        elif symb == 'o':
            from matplotlib.patches import CirclePolygon as Circle
 
            axis.add_artist(Circle((c + x0, r + y0), radius=size, color=mapCtype(ctype), fill=False))
        else:
            from matplotlib.lines import Line2D
 
            for ds9Cmd in ds9Regions.dot(symb, c + x0, r + y0, size, fontFamily="helvetica", textAngle=None):
                tmp = ds9Cmd.split('#')
                cmd = tmp.pop(0).split()
 
                cmd, args = cmd[0], cmd[1:]
 
                if cmd == "line":
                    args = np.array(args).astype(float) - 1.0
 
                    x = np.empty(len(args)//2)
                    y = np.empty_like(x)
                    i = np.arange(len(args), dtype=int)
                    x = args[i%2 == 0]
                    y = args[i%2 == 1]
 
                    axis.add_line(Line2D(x, y, color=mapCtype(ctype)))
                elif cmd == "text":
                    x, y = np.array(args[0:2]).astype(float) - 1.0
                    axis.text(x, y, symb, color=mapCtype(ctype),
                              horizontalalignment='center', verticalalignment='center')
                else:
                    raise RuntimeError(ds9Cmd)
 

_drawLines()

lsst.display.matplotlib.matplotlib.DisplayImpl._drawLines ( self, points, ctype )

protected

Connect the points, a list of (col,row)
Ctype is the name of a colour (e.g. 'red')

Definition at line 604 of file matplotlib.py.

    def _drawLines(self, points, ctype):
        """Connect the points, a list of (col,row)
        Ctype is the name of a colour (e.g. 'red')"""
 
        from matplotlib.lines import Line2D
 
        if not ctype:
            ctype = afwDisplay.GREEN
 
        points = np.array(points)
        x = points[:, 0] + self._xy0[0]
        y = points[:, 1] + self._xy0[1]
 
        self._figure.gca().add_line(Line2D(x, y, color=mapCtype(ctype)))
 

_erase()

lsst.display.matplotlib.matplotlib.DisplayImpl._erase ( self )

protected

Erase the display

Definition at line 532 of file matplotlib.py.

    def _erase(self):
        """Erase the display"""
 
        for axis in self._figure.axes:
            axis.lines = []
            axis.texts = []
 
        self._figure.canvas.draw_idle()
 

_flush()

lsst.display.matplotlib.matplotlib.DisplayImpl._flush ( self )

protected

Definition at line 529 of file matplotlib.py.

    def _flush(self):
        pass
 

_getEvent()

lsst.display.matplotlib.matplotlib.DisplayImpl._getEvent ( self, timeout = -1 )

protected

Listen for a key press, returning (key, x, y)

Definition at line 726 of file matplotlib.py.

    def _getEvent(self, timeout=-1):
        """Listen for a key press, returning (key, x, y)"""
 
        if timeout < 0:
            timeout = 24*3600           # -1 generates complaints in QTimer::singleShot.  A day is a long time
 
        mpBackend = matplotlib.get_backend()
        if mpBackend not in interactiveBackends:
            print("The %s matplotlib backend doesn't support display._getEvent()" %
                  (matplotlib.get_backend(),), file=sys.stderr)
            return interface.Event('q')
 
        event = None
 
        # We set up a blocking event loop. On receipt of a keypress, the
        # callback records the event and unblocks the loop.
 
        def recordKeypress(keypress):
            """Matplotlib callback to record keypress and unblock"""
            nonlocal event
            event = interface.Event(keypress.key, keypress.xdata, keypress.ydata)
            self._figure.canvas.stop_event_loop()
 
        conn = self._figure.canvas.mpl_connect("key_press_event", recordKeypress)
        try:
            self._figure.canvas.start_event_loop(timeout=timeout)  # Blocks on keypress
        finally:
            self._figure.canvas.mpl_disconnect(conn)
        return event
 
 
# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 
 

_getMaskTransparency()

lsst.display.matplotlib.matplotlib.DisplayImpl._getMaskTransparency ( self, maskplane = None )

protected

Return the current mask transparency

Definition at line 312 of file matplotlib.py.

    def _getMaskTransparency(self, maskplane=None):
        """Return the current mask transparency"""
        return self._maskTransparency[maskplane if maskplane in self._maskTransparency else None]
 

_i_mtv()

lsst.display.matplotlib.matplotlib.DisplayImpl._i_mtv ( self, data, wcs, title, isMask )

protected

Internal routine to display an Image or Mask on a DS9 display

Definition at line 398 of file matplotlib.py.

    def _i_mtv(self, data, wcs, title, isMask):
        """Internal routine to display an Image or Mask on a DS9 display"""
 
        title = str(title) if title else ""
        dataArr = data.getArray()
 
        if isMask:
            maskPlanes = data.getMaskPlaneDict()
            nMaskPlanes = max(maskPlanes.values()) + 1
 
            planes = {}                      # build inverse dictionary
            for key in maskPlanes:
                planes[maskPlanes[key]] = key
 
            planeList = range(nMaskPlanes)
 
            maskArr = np.zeros_like(dataArr, dtype=np.int32)
 
            colorNames = ['black']
            colorGenerator = self.display.maskColorGenerator(omitBW=True)
            for p in planeList:
                color = self.display.getMaskPlaneColor(planes[p]) if p in planes else None
 
                if not color:            # none was specified
                    color = next(colorGenerator)
                elif color.lower() == afwDisplay.IGNORE:
                    color = 'black'     # we'll set alpha = 0 anyway
 
                colorNames.append(color)
            #
            # Convert those colours to RGBA so we can have per-mask-plane
            # transparency and build a colour map
            #
            # Pixels equal to 0 don't get set (as no bits are set), so leave
            # them transparent and start our colours at [1] --
            # hence "i + 1" below
            #
            colors = mpColors.to_rgba_array(colorNames)
            alphaChannel = 3            # the alpha channel; the A in RGBA
            colors[0][alphaChannel] = 0.0      # it's black anyway
            for i, p in enumerate(planeList):
                if colorNames[i + 1] == 'black':
                    alpha = 0.0
                else:
                    alpha = 1 - self._getMaskTransparency(planes[p] if p in planes else None)
 
                colors[i + 1][alphaChannel] = alpha
 
            cmap = mpColors.ListedColormap(colors)
            norm = mpColors.NoNorm()
        else:
            cmap = self._image_colormap
            norm = self._normalize
 
        ax = self._figure.gca()
        bbox = data.getBBox()
        extent = (bbox.getBeginX() - 0.5, bbox.getEndX() - 0.5,
                  bbox.getBeginY() - 0.5, bbox.getEndY() - 0.5)
 
        with pyplot.rc_context(dict(interactive=False)):
            if isMask:
                for i, p in reversed(list(enumerate(planeList))):
                    if colors[i + 1][alphaChannel] == 0:  # colors[0] is reserved
                        continue
 
                    bitIsSet = (dataArr & (1 << p)) != 0
                    if bitIsSet.sum() == 0:
                        continue
 
                    maskArr[bitIsSet] = i + 1  # + 1 as we set colorNames[0] to black
 
                    if not self._fastMaskDisplay:  # we draw each bitplane separately
                        ax.imshow(maskArr, origin='lower', interpolation='nearest',
                                  extent=extent, cmap=cmap, norm=norm)
                        maskArr[:] = 0
 
                if self._fastMaskDisplay:  # we only draw the lowest bitplane
                    ax.imshow(maskArr, origin='lower', interpolation='nearest',
                              extent=extent, cmap=cmap, norm=norm)
            else:
                # If we're playing with subplots and have reset the axis
                # the cached colorbar axis belongs to the old one, so set
                # it to None
                if self._mappable_ax and self._mappable_ax[1] != self._figure.gca():
                    self._colorbar_ax = None
 
                mappable = ax.imshow(dataArr, origin='lower', interpolation='nearest',
                                     extent=extent, cmap=cmap, norm=norm)
                self._mappable_ax = (mappable, ax)
 
        self._figure.canvas.draw_idle()
 

_i_scale()

lsst.display.matplotlib.matplotlib.DisplayImpl._i_scale ( self, algorithm, minval, maxval, unit, * args, ** kwargs )

protected

Definition at line 641 of file matplotlib.py.

    def _i_scale(self, algorithm, minval, maxval, unit, *args, **kwargs):
 
        maskedPixels = kwargs.get("maskedPixels", [])
        if isinstance(maskedPixels, str):
            maskedPixels = [maskedPixels]
        bitmask = afwImage.Mask.getPlaneBitMask(maskedPixels)
 
        sctrl = afwMath.StatisticsControl()
        sctrl.setAndMask(bitmask)
 
        if minval == "minmax":
            if self._image is None:
                raise RuntimeError("You may only use minmax if an image is loaded into the display")
 
            mi = afwImage.makeMaskedImage(self._image, self._mask)
            stats = afwMath.makeStatistics(mi, afwMath.MIN | afwMath.MAX, sctrl)
            minval = stats.getValue(afwMath.MIN)
            maxval = stats.getValue(afwMath.MAX)
        elif minval == "zscale":
            if bitmask:
                print("scale(..., 'zscale', maskedPixels=...) is not yet implemented")
 
        if algorithm is None:
            self._normalize = None
        elif algorithm == "asinh":
            if minval == "zscale":
                if self._image is None:
                    raise RuntimeError("You may only use zscale if an image is loaded into the display")
 
                self._normalize = AsinhZScaleNormalize(image=self._image, Q=kwargs.get("Q", 8.0))
            else:
                self._normalize = AsinhNormalize(minimum=minval,
                                                 dataRange=maxval - minval, Q=kwargs.get("Q", 8.0))
        elif algorithm == "linear":
            if minval == "zscale":
                if self._image is None:
                    raise RuntimeError("You may only use zscale if an image is loaded into the display")
 
                self._normalize = ZScaleNormalize(image=self._image,
                                                  nSamples=kwargs.get("nSamples", 1000),
                                                  contrast=kwargs.get("contrast", 0.25))
            else:
                self._normalize = LinearNormalize(minimum=minval, maximum=maxval)
        else:
            raise RuntimeError("Unsupported stretch algorithm \"%s\"" % algorithm)

_i_setImage()

lsst.display.matplotlib.matplotlib.DisplayImpl._i_setImage ( self, image, mask = None, wcs = None )

protected

Save the current image, mask, wcs, and XY0

Definition at line 490 of file matplotlib.py.

    def _i_setImage(self, image, mask=None, wcs=None):
        """Save the current image, mask, wcs, and XY0"""
        self._image = image
        self._mask = mask
        self._wcs = wcs
        self._xy0 = self._image.getXY0() if self._image else (0, 0)
 
        self._zoomfac = None
        if self._image is None:
            self._width, self._height = 0, 0
        else:
            self._width, self._height = self._image.getDimensions()
 
        self._xcen = 0.5*self._width
        self._ycen = 0.5*self._height
 

_mtv()

lsst.display.matplotlib.matplotlib.DisplayImpl._mtv ( self, image, mask = None, wcs = None, title = "" )

protected

Display an Image and/or Mask on a matplotlib display

Definition at line 316 of file matplotlib.py.

    def _mtv(self, image, mask=None, wcs=None, title=""):
        """Display an Image and/or Mask on a matplotlib display
        """
        title = str(title) if title else ""
 
        #
        # Save a reference to the image as it makes erase() easy and permits
        # printing cursor values and minmax/zscale stretches.  We also save XY0
        #
        self._i_setImage(image, mask, wcs)
 
        #  We need to know the pixel values to support e.g. 'zscale' and
        # 'minmax', so do the scaling now
        if self._scaleArgs.get('algorithm'):  # someone called self.scale()
            self._i_scale(self._scaleArgs['algorithm'], self._scaleArgs['minval'], self._scaleArgs['maxval'],
                          self._scaleArgs['unit'], *self._scaleArgs['args'], **self._scaleArgs['kwargs'])
 
        ax = self._figure.gca()
        ax.cla()
 
        self._i_mtv(image, wcs, title, False)
 
        if mask:
            self._i_mtv(mask, wcs, title, True)
 
        self.show_colorbar()
 
        if title:
            ax.set_title(title)
 
        self._title = title
 
        def format_coord(x, y, wcs=self._wcs, x0=self._xy0[0], y0=self._xy0[1],
                         origin=afwImage.PARENT, bbox=self._image.getBBox(afwImage.PARENT),
                         _useSexagesimal=self._useSexagesimal):
 
            fmt = '(%1.2f, %1.2f)'
            if self._mtvOrigin == afwImage.PARENT:
                msg = fmt % (x, y)
            else:
                msg = (fmt + "L") % (x - x0, y - y0)
 
            col = int(x + 0.5)
            row = int(y + 0.5)
            if bbox.contains(geom.PointI(col, row)):
                if wcs is not None:
                    raDec = wcs.pixelToSky(x, y)
                    ra = raDec[0].asDegrees()
                    dec = raDec[1].asDegrees()
 
                    if _useSexagesimal[0]:
                        from astropy import units as u
                        from astropy.coordinates import Angle as apAngle
 
                        kwargs = dict(sep=':', pad=True, precision=2)
                        ra = apAngle(ra*u.deg).to_string(unit=u.hour, **kwargs)
                        dec = apAngle(dec*u.deg).to_string(unit=u.deg, **kwargs)
                    else:
                        ra = "%9.4f" % ra
                        dec = "%9.4f" % dec
 
                    msg += r" (%s, %s): (%s, %s)" % (self.__alpha, self.__delta, ra, dec)
 
                msg += ' %1.3f' % (self._image[col, row])
                if self._mask:
                    val = self._mask[col, row]
                    if self._interpretMaskBits:
                        msg += " [%s]" % self._mask.interpret(val)
                    else:
                        msg += " 0x%x" % val
 
            return msg
 
        ax.format_coord = format_coord
        # Stop images from reporting their value as we've already
        # printed it nicely
        for a in ax.get_images():
            a.get_cursor_data = lambda ev: None  # disabled
 
        # using tight_layout() is too tight and clips the axes
        self._figure.canvas.draw_idle()
 

_pan()

lsst.display.matplotlib.matplotlib.DisplayImpl._pan ( self, colc, rowc )

protected

Pan to (colc, rowc)

Definition at line 718 of file matplotlib.py.

    def _pan(self, colc, rowc):
        """Pan to (colc, rowc)"""
 
        self._xcen = colc
        self._ycen = rowc
 
        self._zoom(self._zoomfac)
 

_scale()

lsst.display.matplotlib.matplotlib.DisplayImpl._scale ( self, algorithm, minval, maxval, unit, * args, ** kwargs )

protected

Set gray scale

N.b.  Supports extra arguments:
@param maskedPixels  List of names of mask bits to ignore
                     E.g. ["BAD", "INTERP"].
                     A single name is also supported

Definition at line 619 of file matplotlib.py.

    def _scale(self, algorithm, minval, maxval, unit, *args, **kwargs):
        """
        Set gray scale
 
        N.b.  Supports extra arguments:
        @param maskedPixels  List of names of mask bits to ignore
                             E.g. ["BAD", "INTERP"].
                             A single name is also supported
        """
        self._scaleArgs['algorithm'] = algorithm
        self._scaleArgs['minval'] = minval
        self._scaleArgs['maxval'] = maxval
        self._scaleArgs['unit'] = unit
        self._scaleArgs['args'] = args
        self._scaleArgs['kwargs'] = kwargs
 
        try:
            self._i_scale(algorithm, minval, maxval, unit, *args, **kwargs)
        except (AttributeError, RuntimeError):
            # Unable to access self._image; we'll try again when we run mtv
            pass
 

_setImageColormap()

lsst.display.matplotlib.matplotlib.DisplayImpl._setImageColormap ( self, cmap )

protected

Set the colormap used for the image

cmap should be either the name of an attribute of pyplot.cm or an
mpColors.Colormap (e.g. "gray" or pyplot.cm.gray)

Definition at line 506 of file matplotlib.py.

    def _setImageColormap(self, cmap):
        """Set the colormap used for the image
 
        cmap should be either the name of an attribute of pyplot.cm or an
        mpColors.Colormap (e.g. "gray" or pyplot.cm.gray)
 
        """
        if not isinstance(cmap, mpColors.Colormap):
            cmap = getattr(pyplot.cm, cmap)
 
        self._image_colormap = cmap
 

_setMaskTransparency()

lsst.display.matplotlib.matplotlib.DisplayImpl._setMaskTransparency ( self, transparency, maskplane )

protected

Specify mask transparency (percent)

Definition at line 307 of file matplotlib.py.

    def _setMaskTransparency(self, transparency, maskplane):
        """Specify mask transparency (percent)"""
 
        self._maskTransparency[maskplane] = 0.01*transparency
 

_show()

lsst.display.matplotlib.matplotlib.DisplayImpl._show ( self )

protected

Put the plot at the top of the window stacking order

Definition at line 177 of file matplotlib.py.

    def _show(self):
        """Put the plot at the top of the window stacking order"""
 
        try:
            self._figure.canvas._tkcanvas._root().lift()  # tk
        except AttributeError:
            pass
 
        try:
            self._figure.canvas.manager.window.raise_()  # os/x
        except AttributeError:
            pass
 
        try:
            self._figure.canvas.raise_()  # qt[45]
        except AttributeError:
            pass
 

_zoom()

lsst.display.matplotlib.matplotlib.DisplayImpl._zoom ( self, zoomfac )

protected

Zoom by specified amount

Definition at line 690 of file matplotlib.py.

    def _zoom(self, zoomfac):
        """Zoom by specified amount"""
 
        self._zoomfac = zoomfac
 
        if zoomfac is None:
            return
 
        x0, y0 = self._xy0
 
        size = min(self._width, self._height)
        if size < self._zoomfac:        # avoid min == max
            size = self._zoomfac
        xmin, xmax = self._xcen + x0 + size/self._zoomfac*np.array([-1, 1])
        ymin, ymax = self._ycen + y0 + size/self._zoomfac*np.array([-1, 1])
 
        ax = self._figure.gca()
 
        tb = self._figure.canvas.toolbar
        if tb is not None:              # It's None for e.g. %matplotlib inline in jupyter
            tb.push_current()           # save the current zoom in the view stack
 
        ax.set_xlim(xmin, xmax)
        ax.set_ylim(ymin, ymax)
        ax.set_aspect('equal', 'datalim')
 
        self._figure.canvas.draw_idle()
 

savefig()

lsst.display.matplotlib.matplotlib.DisplayImpl.savefig	(		self,
		*	args,
		**	kwargs )

Defer to figure.savefig()

Parameters
----------
args : `list`
  Passed through to figure.savefig()
kwargs : `dict`
  Passed through to figure.savefig()

Definition at line 198 of file matplotlib.py.

    def savefig(self, *args, **kwargs):
        """Defer to figure.savefig()
 
        Parameters
        ----------
        args : `list`
          Passed through to figure.savefig()
        kwargs : `dict`
          Passed through to figure.savefig()
        """
        self._figure.savefig(*args, **kwargs)
 

show_colorbar()

lsst.display.matplotlib.matplotlib.DisplayImpl.show_colorbar	(		self,
			show = True,
			where = "right",
			axSize = "5%",
			axPad = None,
		**	kwargs )

Show (or hide) the colour bar

Parameters
----------
show : `bool`
  Should I show the colour bar?
where : `str`
  Location of colour bar: "right" or "bottom"
axSize : `float` or `str`
  Size of axes to hold the colour bar; fraction of current x-size
axPad : `float` or `str`
  Padding between axes and colour bar; fraction of current x-size
args : `list`
  Passed through to colorbar()
kwargs : `dict`
  Passed through to colorbar()

We set the default padding to put the colourbar in a reasonable
place for roughly square plots, but you may need to fiddle for
plots with extreme axis ratios.

You can only configure the colorbar when it isn't yet visible, but
as you can easily remove it this is not in practice a difficulty.

Definition at line 210 of file matplotlib.py.

    def show_colorbar(self, show=True, where="right", axSize="5%", axPad=None, **kwargs):
        """Show (or hide) the colour bar
 
        Parameters
        ----------
        show : `bool`
          Should I show the colour bar?
        where : `str`
          Location of colour bar: "right" or "bottom"
        axSize : `float` or `str`
          Size of axes to hold the colour bar; fraction of current x-size
        axPad : `float` or `str`
          Padding between axes and colour bar; fraction of current x-size
        args : `list`
          Passed through to colorbar()
        kwargs : `dict`
          Passed through to colorbar()
 
        We set the default padding to put the colourbar in a reasonable
        place for roughly square plots, but you may need to fiddle for
        plots with extreme axis ratios.
 
        You can only configure the colorbar when it isn't yet visible, but
        as you can easily remove it this is not in practice a difficulty.
        """
        if show:
            if self._mappable_ax:
                if self._colorbar_ax is None:
                    orientationDict = dict(right="vertical", bottom="horizontal")
 
                    mappable, ax = self._mappable_ax
 
                    if where in orientationDict:
                        orientation = orientationDict[where]
                    else:
                        print(f"Unknown location {where}; "
                              f"please use one of {', '.join(orientationDict.keys())}")
 
                    if axPad is None:
                        axPad = 0.1 if orientation == "vertical" else 0.3
 
                    divider = make_axes_locatable(ax)
                    self._colorbar_ax = divider.append_axes(where, size=axSize, pad=axPad)
 
                    self._figure.colorbar(mappable, cax=self._colorbar_ax, orientation=orientation, **kwargs)
 
                    try:                # fails with %matplotlib inline
                        pyplot.sca(ax)  # make main window active again
                    except ValueError:
                        pass
        else:
            if self._colorbar_ax is not None:
                self._colorbar_ax.remove()
                self._colorbar_ax = None
 

useSexagesimal()

lsst.display.matplotlib.matplotlib.DisplayImpl.useSexagesimal	(		self,
			useSexagesimal )

Control the formatting coordinates as HH:MM:SS.ss

Parameters
----------
useSexagesimal : `bool`
   Print coordinates as e.g. HH:MM:SS.ss iff True

N.b. can also be set in Display's ctor

Are we formatting coordinates as HH:MM:SS.ss?

Definition at line 265 of file matplotlib.py.

    def useSexagesimal(self, useSexagesimal):
        """Control the formatting coordinates as HH:MM:SS.ss
 
        Parameters
        ----------
        useSexagesimal : `bool`
           Print coordinates as e.g. HH:MM:SS.ss iff True
 
        N.b. can also be set in Display's ctor
        """
 
        """Are we formatting coordinates as HH:MM:SS.ss?"""
        self._useSexagesimal[0] = useSexagesimal
 

wait()

lsst.display.matplotlib.matplotlib.DisplayImpl.wait	(		self,
			prompt = "[c(ontinue) p(db)] :",
			allowPdb = True )

Wait for keyboard input

Parameters
----------
prompt : `str`
   The prompt string.
allowPdb : `bool`
   If true, entering a 'p' or 'pdb' puts you into pdb

Returns the string you entered

Useful when plotting from a programme that exits such as a processCcd
Any key except 'p' continues; 'p' puts you into pdb (unless
allowPdb is False)

Definition at line 279 of file matplotlib.py.

    def wait(self, prompt="[c(ontinue) p(db)] :", allowPdb=True):
        """Wait for keyboard input
 
        Parameters
        ----------
        prompt : `str`
           The prompt string.
        allowPdb : `bool`
           If true, entering a 'p' or 'pdb' puts you into pdb
 
        Returns the string you entered
 
        Useful when plotting from a programme that exits such as a processCcd
        Any key except 'p' continues; 'p' puts you into pdb (unless
        allowPdb is False)
        """
        while True:
            s = input(prompt)
            if allowPdb and s in ("p", "pdb"):
                import pdb
                pdb.set_trace()
                continue
 
            return s

Member Data Documentation

_colorbar_ax

lsst.display.matplotlib.matplotlib.DisplayImpl._colorbar_ax

protected

Definition at line 154 of file matplotlib.py.

_display

lsst.display.matplotlib.matplotlib.DisplayImpl._display

protected

Definition at line 147 of file matplotlib.py.

_fastMaskDisplay

lsst.display.matplotlib.matplotlib.DisplayImpl._fastMaskDisplay

protected

Definition at line 150 of file matplotlib.py.

_figure

lsst.display.matplotlib.matplotlib.DisplayImpl._figure

protected

Definition at line 142 of file matplotlib.py.

_height

lsst.display.matplotlib.matplotlib.DisplayImpl._height

protected

Definition at line 499 of file matplotlib.py.

_image

lsst.display.matplotlib.matplotlib.DisplayImpl._image

protected

Definition at line 172 of file matplotlib.py.

_image_colormap

lsst.display.matplotlib.matplotlib.DisplayImpl._image_colormap

protected

Definition at line 155 of file matplotlib.py.

_interpretMaskBits

lsst.display.matplotlib.matplotlib.DisplayImpl._interpretMaskBits

protected

Definition at line 149 of file matplotlib.py.

_mappable_ax

lsst.display.matplotlib.matplotlib.DisplayImpl._mappable_ax

protected

Definition at line 153 of file matplotlib.py.

_mask

lsst.display.matplotlib.matplotlib.DisplayImpl._mask

protected

Definition at line 173 of file matplotlib.py.

_maskTransparency

lsst.display.matplotlib.matplotlib.DisplayImpl._maskTransparency

protected

Definition at line 148 of file matplotlib.py.

_mtvOrigin

lsst.display.matplotlib.matplotlib.DisplayImpl._mtvOrigin

protected

Definition at line 152 of file matplotlib.py.

_normalize

lsst.display.matplotlib.matplotlib.DisplayImpl._normalize

protected

Definition at line 163 of file matplotlib.py.

_scaleArgs

lsst.display.matplotlib.matplotlib.DisplayImpl._scaleArgs

protected

Definition at line 162 of file matplotlib.py.

_title

lsst.display.matplotlib.matplotlib.DisplayImpl._title

protected

Definition at line 346 of file matplotlib.py.

_useSexagesimal

lsst.display.matplotlib.matplotlib.DisplayImpl._useSexagesimal

protected

Definition at line 151 of file matplotlib.py.

_wcs

lsst.display.matplotlib.matplotlib.DisplayImpl._wcs

protected

Definition at line 174 of file matplotlib.py.

_width

lsst.display.matplotlib.matplotlib.DisplayImpl._width

protected

Definition at line 499 of file matplotlib.py.

_xcen

lsst.display.matplotlib.matplotlib.DisplayImpl._xcen

protected

Definition at line 503 of file matplotlib.py.

_xy0

lsst.display.matplotlib.matplotlib.DisplayImpl._xy0

protected

Definition at line 495 of file matplotlib.py.

_ycen

lsst.display.matplotlib.matplotlib.DisplayImpl._ycen

protected

Definition at line 504 of file matplotlib.py.

_zoomfac

lsst.display.matplotlib.matplotlib.DisplayImpl._zoomfac

protected

Definition at line 497 of file matplotlib.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/display_matplotlib/g0265f82a02+469cd937ee/python/lsst/display/matplotlib/matplotlib.py