lsst.afw.display.rgb.AsinhMapping Class Reference

A mapping for an asinh stretch (preserving colours independent of brightness) More...

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

Public Member Functions
def	__init__ (self, minimum, dataRange, Q=8)
def	mapIntensityToUint8 (self, intensity)
def	makeRgbImage (self, imageR=None, imageG=None, imageB=None, xSize=None, ySize=None, rescaleFactor=None)
	Convert 3 arrays, imageR, imageG, and imageB into a numpy RGB image. More...
def	intensity (self, imageR, imageG, imageB)
	Return the total intensity from the red, blue, and green intensities. More...

Public Attributes
	minimum

Detailed Description

A mapping for an asinh stretch (preserving colours independent of brightness)

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

This reduces to a linear stretch if Q == 0

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

Definition at line 254 of file rgb.py.

Constructor & Destructor Documentation

__init__()

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

Definition at line 264 of file rgb.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

intensity()

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

inherited

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

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

Definition at line 143 of file rgb.py.

    def intensity(self, imageR, imageG, imageB):
        """!Return the total intensity from the red, blue, and green intensities

        This is a naive computation, and may be overridden by subclasses
        """
        return computeIntensity(imageR, imageG, imageB)

makeRgbImage()

def lsst.afw.display.rgb.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.

Parameters

imageR	Image to map to red (if None, use the image passed to the ctor)
imageG	Image to map to green (if None, use imageR)
imageB	Image to map to blue (if None, use imageR)
xSize	Desired width of RGB image (or None). If ySize is None, preserve aspect ratio
ySize	Desired height of RGB image (or None)
rescaleFactor	Make size of output image rescaleFactor*size of the input image (or None)

N.b. images may be afwImage.Images or numpy arrays

Definition at line 87 of file rgb.py.

                     xSize=None, ySize=None, rescaleFactor=None):
        """!Convert 3 arrays, imageR, imageG, and imageB into a numpy RGB image
        @param imageR Image to map to red (if None, use the image passed to the ctor)
        @param imageG Image to map to green (if None, use imageR)
        @param imageB Image to map to blue (if None, use imageR)
        @param xSize  Desired width of RGB image (or None).  If ySize is None, preserve aspect ratio
        @param ySize  Desired height of RGB image (or None)
        @param rescaleFactor Make size of output image rescaleFactor*size of the input image (or None)

        N.b. images may be afwImage.Images or numpy arrays
        """
        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(
                    "Unable to rescale as scipy.misc is unavailable: %s" % 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.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)

Definition at line 284 of file rgb.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

minimum

lsst.afw.display.rgb.Mapping.minimum

inherited

Definition at line 83 of file rgb.py.

---

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

• /j/snowflake/release/lsstsw/stack/Linux64/afw/16.0-14-gb4f0cd2fa/python/lsst/afw/display/rgb.py