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

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

Public Member Functions
	__init__ (self, minimum, dataRange, Q=8)
	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 (preserving colours independent of brightness)

x = asinh(Q (I - minimum)/range)/Q

Notes
-----
This reduces to a linear stretch if Q == 0

See http://adsabs.harvard.edu/abs/2004PASP..116..133L

Definition at line 282 of file _rgbContinued.py.

Constructor & Destructor Documentation

__init__()

lsst.afw.display.rgb._rgbContinued.AsinhMapping.__init__	(		self,
			minimum,
			dataRange,
			Q = 8 )

Definition at line 294 of file _rgbContinued.py.

    def __init__(self, minimum, dataRange, Q=8):
        Mapping.__init__(self, minimum)
 
        # 32bit floating point machine epsilon; sys.float_info.epsilon is 64bit
        epsilon = 1.0/2**23
        if abs(Q) < epsilon:
            Q = 0.1
        else:
            Qmax = 1e10
            if Q > Qmax:
                Q = Qmax
 
        if False:
            self._slope = self._uint8Max/Q  # gradient at origin is self._slope
        else:
            frac = 0.1                  # gradient estimated using frac*range is _slope
            self._slope = frac*self._uint8Max/np.arcsinh(frac*Q)
 
        self._soften = Q/float(dataRange)
 

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 )

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

protected

Definition at line 307 of file _rgbContinued.py.

_soften

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

protected

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/g844c57033c+03ddc13274/python/lsst/afw/display/rgb/_rgbContinued.py