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

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

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

Public Attributes
	minimum

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

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

Reimplemented from lsst.afw.display.rgb._rgbContinued.AsinhMapping.

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

intensity()

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

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

def 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

minimum

lsst.afw.display.rgb._rgbContinued.Mapping.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-0.7.0/Linux64/afw/22.0.1-42-gca6935d93+ba5e5ca3eb/python/lsst/afw/display/rgb/_rgbContinued.py