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

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

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

Public Attributes
	maximum = maximum
	minimum = minimum

Protected Member Functions
	_convertImagesToUint8 (self, imageR, imageG, imageB)

Protected Attributes
	_range = None
	_uint8Max = float(np.iinfo(np.uint8).max)
	_image = image

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

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

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

_convertImagesToUint8()

lsst.afw.display.rgb._rgbContinued.Mapping._convertImagesToUint8 ( self, imageR, imageG, imageB )

protectedinherited

Use the mapping to convert images imageR, imageG, and imageB to a triplet of uint8 images

Definition at line 176 of file _rgbContinued.py.

    def _convertImagesToUint8(self, imageR, imageG, imageB):
        """Use the mapping to convert images imageR, imageG, and imageB to a triplet of uint8 images
        """
        imageR = imageR - self.minimum[0]  # n.b. makes copy
        imageG = imageG - self.minimum[1]
        imageB = imageB - self.minimum[2]
 
        fac = self.mapIntensityToUint8(self.intensity(imageR, imageG, imageB))
 
        imageRGB = [imageR, imageG, imageB]
        with np.errstate(invalid="ignore"):  # suppress NAN warnings
            for c in imageRGB:
                c *= fac
                # individual bands can still be < 0, even if fac isn't
                c[c < 0] = 0
 
        pixmax = self._uint8Max
        # copies -- could work row by row to minimise memory usage
        r0, g0, b0 = imageRGB
 
        # n.b. np.where can't and doesn't short-circuit
        with np.errstate(invalid='ignore', divide='ignore'):
            for i, c in enumerate(imageRGB):
                c = np.where(r0 > g0,
                             np.where(r0 > b0,
                                      np.where(r0 >= pixmax, c*pixmax/r0, c),
                                      np.where(b0 >= pixmax, c*pixmax/b0, c)),
                             np.where(g0 > b0,
                                      np.where(g0 >= pixmax, c*pixmax/g0, c),
                                      np.where(b0 >= pixmax, c*pixmax/b0, c))).astype(np.uint8)
                c[c > pixmax] = pixmax
 
                imageRGB[i] = c
 
        return imageRGB
 
 

intensity()

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

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

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

_image

lsst.afw.display.rgb._rgbContinued.Mapping._image = image

protectedinherited

Definition at line 96 of file _rgbContinued.py.

_range

lsst.afw.display.rgb._rgbContinued.LinearMapping._range = None

protectedinherited

Definition at line 241 of file _rgbContinued.py.

_uint8Max

lsst.afw.display.rgb._rgbContinued.Mapping._uint8Max = float(np.iinfo(np.uint8).max)

protectedinherited

Definition at line 87 of file _rgbContinued.py.

maximum

lsst.afw.display.rgb._rgbContinued.LinearMapping.maximum = maximum

inherited

Definition at line 238 of file _rgbContinued.py.

minimum

lsst.afw.display.rgb._rgbContinued.Mapping.minimum = 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/lsst-scipipe-12.1.0/Linux/afw/g7ae74a0b1c+a25e60b391/python/lsst/afw/display/rgb/_rgbContinued.py