lsst.afw.display.rgb.rgbContinued.ZScaleMapping Class Reference

Inheritance diagram for lsst.afw.display.rgb.rgbContinued.ZScaleMapping:

Public Member Functions
def	__init__ (self, image, nSamples=1000, contrast=0.25)
def	mapIntensityToUint8 (self, intensity)
def	makeRgbImage (self, imageR=None, imageG=None, imageB=None, xSize=None, ySize=None, rescaleFactor=None)
def	intensity (self, imageR, imageG, imageB)

Public Attributes
	maximum
	minimum

Detailed Description

A mapping for a linear stretch chosen by the zscale algorithm
(preserving colours independent of brightness)

x = (I - minimum)/range

Parameters
----------
image
    Image whose parameters are desired
nSamples : `int`
    The number of samples to use to estimate the zscale parameters
contrast : `float`

Definition at line 259 of file rgbContinued.py.

Constructor & Destructor Documentation

__init__()

def lsst.afw.display.rgb.rgbContinued.ZScaleMapping.__init__	(		self,
			image,
			nSamples = 1000,
			contrast = 0.25
	)

Reimplemented from lsst.afw.display.rgb.rgbContinued.LinearMapping.

Definition at line 274 of file rgbContinued.py.

    def __init__(self, image, nSamples=1000, contrast=0.25):
        if not hasattr(image, "getArray"):
            image = afwImage.ImageF(image)
        z1, z2 = getZScale(image, nSamples, contrast)
 
        LinearMapping.__init__(self, z1, z2, image)
 
 

Member Function Documentation

intensity()

def lsst.afw.display.rgb.rgbContinued.Mapping.intensity (   self,   imageR,   imageG,   imageB  )

inherited

Return the total intensity from the red, blue, and green intensities

Notes
-----
This is a naive computation, and may be overridden by subclasses

Definition at line 160 of file rgbContinued.py.

    def intensity(self, imageR, imageG, imageB):
        """Return the total intensity from the red, blue, and green intensities
 
        Notes
        -----
        This is a naive computation, and may be overridden by subclasses
        """
        return computeIntensity(imageR, imageG, imageB)
 

makeRgbImage()

def lsst.afw.display.rgb.rgbContinued.Mapping.makeRgbImage (   self,   imageR = None,   imageG = None,   imageB = None,   xSize = None,   ySize = None,   rescaleFactor = None  )

inherited

Convert 3 arrays, imageR, imageG, and imageB into a numpy RGB image

imageR : `lsst.afw.image.Image` or `numpy.ndarray`, (Nx, Ny)
    Image to map to red (if `None`, use the image passed to the ctor)
imageG : `lsst.afw.image.Image` or `numpy.ndarray`, (Nx, Ny), optional
    Image to map to green (if `None`, use imageR)
imageB : `lsst.afw.image.Image` or `numpy.ndarray`, (Nx, Ny), optional
    Image to map to blue (if `None`, use imageR)
xSize : `int`, optional
    Desired width of RGB image. If ``ySize`` is `None`, preserve aspect ratio
ySize : `int`, optional
    Desired height of RGB image
rescaleFactor : `float`, optional
    Make size of output image ``rescaleFactor*size`` of the input image

Definition at line 98 of file rgbContinued.py.

                     xSize=None, ySize=None, rescaleFactor=None):
        """Convert 3 arrays, imageR, imageG, and imageB into a numpy RGB image
 
        imageR : `lsst.afw.image.Image` or `numpy.ndarray`, (Nx, Ny)
            Image to map to red (if `None`, use the image passed to the ctor)
        imageG : `lsst.afw.image.Image` or `numpy.ndarray`, (Nx, Ny), optional
            Image to map to green (if `None`, use imageR)
        imageB : `lsst.afw.image.Image` or `numpy.ndarray`, (Nx, Ny), optional
            Image to map to blue (if `None`, use imageR)
        xSize : `int`, optional
            Desired width of RGB image. If ``ySize`` is `None`, preserve aspect ratio
        ySize : `int`, optional
            Desired height of RGB image
        rescaleFactor : `float`, optional
            Make size of output image ``rescaleFactor*size`` of the input image
        """
        if imageR is None:
            if self._image is None:
                raise RuntimeError(
                    "You must provide an image (or pass one to the constructor)")
            imageR = self._image
 
        if imageG is None:
            imageG = imageR
        if imageB is None:
            imageB = imageR
 
        imageRGB = [imageR, imageG, imageB]
        for i, c in enumerate(imageRGB):
            if hasattr(c, "getImage"):
                c = imageRGB[i] = c.getImage()
            if hasattr(c, "getArray"):
                imageRGB[i] = c.getArray()
 
        if xSize is not None or ySize is not None:
            assert rescaleFactor is None, "You may not specify a size and rescaleFactor"
            h, w = imageRGB[0].shape
            if ySize is None:
                ySize = int(xSize*h/float(w) + 0.5)
            elif xSize is None:
                xSize = int(ySize*w/float(h) + 0.5)
 
            size = (ySize, xSize)  # n.b. y, x order for scipy
        elif rescaleFactor is not None:
            size = float(rescaleFactor)  # an int is intepreted as a percentage
        else:
            size = None
 
        if size is not None:
            try:
                import scipy.misc
            except ImportError as e:
                raise RuntimeError(
                    f"Unable to rescale as scipy.misc is unavailable: {e}")
 
            for i, im in enumerate(imageRGB):
                imageRGB[i] = scipy.misc.imresize(
                    im, size, interp='bilinear', mode='F')
 
        return np.dstack(self._convertImagesToUint8(*imageRGB)).astype(np.uint8)
 

mapIntensityToUint8()

def lsst.afw.display.rgb.rgbContinued.LinearMapping.mapIntensityToUint8 (   self,   intensity  )

inherited

Return an array which, when multiplied by an image, returns that
image mapped to the range of a uint8, [0, 255] (but not converted to uint8)

The intensity is assumed to have had ``minimum`` subtracted (as that
can be done per-band)

Reimplemented from lsst.afw.display.rgb.rgbContinued.Mapping.

Definition at line 246 of file rgbContinued.py.

    def mapIntensityToUint8(self, intensity):
        """Return an array which, when multiplied by an image, returns that
        image mapped to the range of a uint8, [0, 255] (but not converted to uint8)
 
        The intensity is assumed to have had ``minimum`` subtracted (as that
        can be done per-band)
        """
        with np.errstate(invalid='ignore', divide='ignore'):  # n.b. np.where can't and doesn't short-circuit
            return np.where(intensity <= 0, 0,
                            np.where(intensity >= self._range,
                                     self._uint8Max/intensity, self._uint8Max/self._range))
 
 

Member Data Documentation

maximum

lsst.afw.display.rgb.rgbContinued.LinearMapping.maximum

inherited

Definition at line 238 of file rgbContinued.py.

minimum

lsst.afw.display.rgb.rgbContinued.Mapping.minimum

inherited

Definition at line 95 of file rgbContinued.py.

---

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

• /j/snowflake/release/lsstsw/stack/0.4.3/Linux64/afw/21.0.0-22-g2a5702db6+f385fa6f38/python/lsst/afw/display/rgb/rgbContinued.py