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

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

Public Member Functions
	__init__ (self, image, Q=8, pedestal=None)
	mapIntensityToUint8 (self, intensity)
	makeRgbImage (self, imageR=None, imageG=None, imageB=None, xSize=None, ySize=None, rescaleFactor=None)
	intensity (self, imageR, imageG, imageB)

Public Attributes
	minimum = minimum

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

Protected Attributes
	_slope = self._uint8Max/Q
	_soften = Q/float(dataRange)
	_uint8Max = float(np.iinfo(np.uint8).max)
	_image = image

Detailed Description

A mapping for an asinh stretch, estimating the linear stretch by zscale

x = asinh(Q (I - z1)/(z2 - z1))/Q

Parameters
----------
image
    The image to analyse, or a list of 3 images to be converted to an intensity image
Q : `int`
    The asinh softening parameter
pedestal : `float` or sequence of `float`, optional
    The value, or array of 3 values, to subtract from the images

    N.b. pedestal, if not None, is removed from the images when calculating the zscale
    stretch, and added back into Mapping.minimum[]

See also
--------
AsinhMapping

Definition at line 324 of file _rgbContinued.py.

Constructor & Destructor Documentation

__init__()

lsst.afw.display.rgb._rgbContinued.AsinhZScaleMapping.__init__	(		self,
			image,
			Q = 8,
			pedestal = None )

Definition at line 346 of file _rgbContinued.py.

    def __init__(self, image, Q=8, pedestal=None):
        try:
            assert len(image) in (1, 3,), "Please provide 1 or 3 images"
        except TypeError:
            image = [image]
 
        if pedestal is not None:
            try:
                assert len(pedestal) in (
                    1, 3,), "Please provide 1 or 3 pedestals"
            except TypeError:
                pedestal = 3*[pedestal]
 
            image = list(image)        # needs to be mutable
            for i, im in enumerate(image):
                if pedestal[i] != 0.0:
                    if hasattr(im, "getImage"):
                        im = im.getImage()
                    if hasattr(im, "getArray"):
                        im = im.getArray()
 
                    image[i] = im - pedestal[i]  # n.b. a copy
        else:
            pedestal = len(image)*[0.0]
 
        image = computeIntensity(*image)
 
        zscale = ZScaleMapping(image)
        # zscale.minimum is always a triple
        dataRange = zscale.maximum - zscale.minimum[0]
        minimum = zscale.minimum
 
        for i, level in enumerate(pedestal):
            minimum[i] += level
 
        AsinhMapping.__init__(self, minimum, dataRange, Q)
        self._image = image             # support self.makeRgbImage()
 
 

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.AsinhMapping.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 314 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.arcsinh(intensity*self._soften)*self._slope/intensity)
 
 

Member Data Documentation

_image

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

protectedinherited

Definition at line 96 of file _rgbContinued.py.

_slope

lsst.afw.display.rgb._rgbContinued.AsinhMapping._slope = self._uint8Max/Q

protectedinherited

Definition at line 307 of file _rgbContinued.py.

_soften

lsst.afw.display.rgb._rgbContinued.AsinhMapping._soften = Q/float(dataRange)

protectedinherited

Definition at line 312 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.

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-10.0.0/Linux64/afw/gdb1c4ca869+16879ca1a6/python/lsst/afw/display/rgb/_rgbContinued.py