Inheritance diagram for lsst.afw.display.rgb._rgbContinued.Mapping:
Public Member Functions | |
| __init__ (self, minimum=None, image=None) | |
| makeRgbImage (self, imageR=None, imageG=None, imageB=None, xSize=None, ySize=None, rescaleFactor=None) | |
| intensity (self, imageR, imageG, imageB) | |
| mapIntensityToUint8 (self, intensity) | |
Public Attributes | |
| minimum | |
Protected Member Functions | |
| _convertImagesToUint8 (self, imageR, imageG, imageB) | |
Protected Attributes | |
| _uint8Max | |
| _image | |
Detailed Description
Base class to map red, blue, green intensities into uint8 values
Parameters
----------
minimum : `float` or sequence of `float`
Intensity that should be mapped to black. If an array, has three
elements for R, G, B.
image
The image to be used to calculate the mapping.
If provided, also the default for makeRgbImage()
Definition at line 73 of file _rgbContinued.py.
Constructor & Destructor Documentation
◆ __init__()
| lsst.afw.display.rgb._rgbContinued.Mapping.__init__ | ( | self, | |
| minimum = None, | |||
| image = None ) |
Reimplemented in lsst.afw.display.rgb._rgbContinued.ZScaleMapping, lsst.afw.display.rgb._rgbContinued.AsinhZScaleMapping, lsst.afw.display.rgb._rgbContinued.AsinhMapping, and lsst.afw.display.rgb._rgbContinued.LinearMapping.
Definition at line 86 of file _rgbContinued.py.
86 def __init__(self, minimum=None, image=None):
87 self._uint8Max = float(np.iinfo(np.uint8).max)
88
89 try:
90 len(minimum)
91 except TypeError:
92 minimum = 3*[minimum]
93 assert len(minimum) == 3, "Please provide 1 or 3 values for minimum"
94
95 self.minimum = minimum
96 self._image = image
97
Member Function Documentation
◆ _convertImagesToUint8()
|
protected |
Use the mapping to convert images imageR, imageG, and imageB to a triplet of uint8 images
Definition at line 176 of file _rgbContinued.py.
176 def _convertImagesToUint8(self, imageR, imageG, imageB):
177 """Use the mapping to convert images imageR, imageG, and imageB to a triplet of uint8 images
178 """
179 imageR = imageR - self.minimum[0] # n.b. makes copy
180 imageG = imageG - self.minimum[1]
181 imageB = imageB - self.minimum[2]
182
183 fac = self.mapIntensityToUint8(self.intensity(imageR, imageG, imageB))
184
185 imageRGB = [imageR, imageG, imageB]
186 with np.errstate(invalid="ignore"): # suppress NAN warnings
187 for c in imageRGB:
188 c *= fac
189 # individual bands can still be < 0, even if fac isn't
190 c[c < 0] = 0
191
192 pixmax = self._uint8Max
193 # copies -- could work row by row to minimise memory usage
194 r0, g0, b0 = imageRGB
195
196 # n.b. np.where can't and doesn't short-circuit
197 with np.errstate(invalid='ignore', divide='ignore'):
198 for i, c in enumerate(imageRGB):
199 c = np.where(r0 > g0,
200 np.where(r0 > b0,
201 np.where(r0 >= pixmax, c*pixmax/r0, c),
202 np.where(b0 >= pixmax, c*pixmax/b0, c)),
203 np.where(g0 > b0,
204 np.where(g0 >= pixmax, c*pixmax/g0, c),
205 np.where(b0 >= pixmax, c*pixmax/b0, c))).astype(np.uint8)
206 c[c > pixmax] = pixmax
207
208 imageRGB[i] = c
209
210 return imageRGB
211
212
◆ intensity()
| lsst.afw.display.rgb._rgbContinued.Mapping.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
Definition at line 160 of file _rgbContinued.py.
160 def intensity(self, imageR, imageG, imageB):
161 """Return the total intensity from the red, blue, and green intensities
162
163 Notes
164 -----
165 This is a naive computation, and may be overridden by subclasses
166 """
167 return computeIntensity(imageR, imageG, imageB)
168
◆ makeRgbImage()
| lsst.afw.display.rgb._rgbContinued.Mapping.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
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.
99 xSize=None, ySize=None, rescaleFactor=None):
100 """Convert 3 arrays, imageR, imageG, and imageB into a numpy RGB image
101
102 imageR : `lsst.afw.image.Image` or `numpy.ndarray`, (Nx, Ny)
103 Image to map to red (if `None`, use the image passed to the ctor)
104 imageG : `lsst.afw.image.Image` or `numpy.ndarray`, (Nx, Ny), optional
105 Image to map to green (if `None`, use imageR)
106 imageB : `lsst.afw.image.Image` or `numpy.ndarray`, (Nx, Ny), optional
107 Image to map to blue (if `None`, use imageR)
108 xSize : `int`, optional
109 Desired width of RGB image. If ``ySize`` is `None`, preserve aspect ratio
110 ySize : `int`, optional
111 Desired height of RGB image
112 rescaleFactor : `float`, optional
113 Make size of output image ``rescaleFactor*size`` of the input image
114 """
115 if imageR is None:
116 if self._image is None:
117 raise RuntimeError(
118 "You must provide an image (or pass one to the constructor)")
119 imageR = self._image
120
121 if imageG is None:
122 imageG = imageR
123 if imageB is None:
124 imageB = imageR
125
126 imageRGB = [imageR, imageG, imageB]
127 for i, c in enumerate(imageRGB):
128 if hasattr(c, "getImage"):
129 c = imageRGB[i] = c.getImage()
130 if hasattr(c, "getArray"):
131 imageRGB[i] = c.getArray()
132
133 if xSize is not None or ySize is not None:
134 assert rescaleFactor is None, "You may not specify a size and rescaleFactor"
135 h, w = imageRGB[0].shape
136 if ySize is None:
137 ySize = int(xSize*h/float(w) + 0.5)
138 elif xSize is None:
139 xSize = int(ySize*w/float(h) + 0.5)
140
141 size = (ySize, xSize) # n.b. y, x order for scipy
142 elif rescaleFactor is not None:
143 size = float(rescaleFactor) # an int is intepreted as a percentage
144 else:
145 size = None
146
147 if size is not None:
148 try:
149 import scipy.misc
150 except ImportError as e:
151 raise RuntimeError(
152 f"Unable to rescale as scipy.misc is unavailable: {e}")
153
154 for i, im in enumerate(imageRGB):
155 imageRGB[i] = scipy.misc.imresize(
156 im, size, interp='bilinear', mode='F')
157
158 return np.dstack(self._convertImagesToUint8(*imageRGB)).astype(np.uint8)
159
◆ mapIntensityToUint8()
| lsst.afw.display.rgb._rgbContinued.Mapping.mapIntensityToUint8 | ( | self, | |
| intensity ) |
Map an intensity into the range of a uint8, [0, 255] (but not converted to uint8)
Reimplemented in lsst.afw.display.rgb._rgbContinued.LinearMapping, and lsst.afw.display.rgb._rgbContinued.AsinhMapping.
Definition at line 169 of file _rgbContinued.py.
169 def mapIntensityToUint8(self, intensity):
170 """Map an intensity into the range of a uint8, [0, 255] (but not converted to uint8)
171 """
172 with np.errstate(invalid='ignore', divide='ignore'): # n.b. np.where can't and doesn't short-circuit
173 return np.where(intensity <= 0, 0,
174 np.where(intensity < self._uint8Max, intensity, self._uint8Max))
175
Member Data Documentation
◆ _image
|
protected |
Definition at line 96 of file _rgbContinued.py.
◆ _uint8Max
|
protected |
Definition at line 87 of file _rgbContinued.py.
◆ minimum
| lsst.afw.display.rgb._rgbContinued.Mapping.minimum |
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-8.0.0/Linux64/afw/g5a732f18d5+53520f316c/python/lsst/afw/display/rgb/_rgbContinued.py
