lsst.afw.display.rgb.LinearMapping Class Reference

A linear map map of red, blue, green intensities into uint8 values. More...

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

Public Member Functions
def	__init__ (self, minimum=None, maximum=None, image=None)
	A linear stretch from [minimum, maximum]; if one or both are omitted use image minimum/maximum to set them. More...
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
	maximum
	minimum

Detailed Description

A linear map map of red, blue, green intensities into uint8 values.

Definition at line 192 of file rgb.py.

Constructor & Destructor Documentation

__init__()

def lsst.afw.display.rgb.LinearMapping.__init__	(		self,
			minimum = None,
			maximum = None,
			image = None
	)

A linear stretch from [minimum, maximum]; if one or both are omitted use image minimum/maximum to set them.

Parameters

minimum	Intensity that should be mapped to black (a scalar or array for R, G, B)
maximum	Intensity that should be mapped to white (a scalar)
image	Image to estimate minimum/maximum if not explicitly set

Definition at line 195 of file rgb.py.

    def __init__(self, minimum=None, maximum=None, image=None):
        """!A linear stretch from [minimum, maximum]; if one or both are omitted use image minimum/maximum to set them

        @param minimum  Intensity that should be mapped to black (a scalar or array for R, G, B)
        @param maximum  Intensity that should be mapped to white (a scalar)
        @param image    Image to estimate minimum/maximum if not explicitly set
        """

        if minimum is None or maximum is None:
            assert image is not None, "You must provide an image if you don't set both minimum and maximum"

            stats = afwMath.makeStatistics(image, afwMath.MIN | afwMath.MAX)
            if minimum is None:
                minimum = stats.getValue(afwMath.MIN)
            if maximum is None:
                maximum = stats.getValue(afwMath.MAX)

        Mapping.__init__(self, minimum, image)
        self.maximum = maximum

        if maximum is None:
            self._range = None
        else:
            assert maximum - minimum != 0, "minimum and maximum values must not be equal"
            self._range = float(maximum - minimum)

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.LinearMapping.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 221 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.where(intensity >= self._range,
                                     self._uint8Max/intensity, self._uint8Max/self._range))

Member Data Documentation

maximum

lsst.afw.display.rgb.LinearMapping.maximum

Definition at line 213 of file rgb.py.

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