我们从Python开源项目中，提取了以下49个代码示例，用于说明如何使用numpy.ubyte()。
def load_raw(filename, volsize): """ inspired by mhd_utils from github""" dim = 3 element_channels = 1 np_type = np.ubyte arr = list(volsize) volume = np.prod(arr[0:dim - 1]) shape = (arr[dim - 1], volume, element_channels) with open(filename,'rb') as fid: data = np.fromfile(fid, count=np.prod(shape),dtype = np_type) data.shape = shape arr.reverse() data = data.reshape(arr) return data
def getColors(self, mode=None): """Return list of all color stops converted to the specified mode. If mode is None, then no conversion is done.""" if isinstance(mode, basestring): mode = self.enumMap[mode.lower()] color = self.color if mode in [self.BYTE, self.QCOLOR] and color.dtype.kind == 'f': color = (color * 255).astype(np.ubyte) elif mode == self.FLOAT and color.dtype.kind != 'f': color = color.astype(float) / 255. if mode == self.QCOLOR: color = [QtGui.QColor(*x) for x in color] return color
def getStops(self, mode): ## Get fully-expanded set of RGBA stops in either float or byte mode. if mode not in self.stopsCache: color = self.color if mode == self.BYTE and color.dtype.kind == 'f': color = (color * 255).astype(np.ubyte) elif mode == self.FLOAT and color.dtype.kind != 'f': color = color.astype(float) / 255. ## to support HSV mode, we need to do a little more work.. #stops = [] #for i in range(len(self.pos)): #pos = self.pos[i] #color = color[i] #imode = self.mode[i] #if imode == self.RGB: #stops.append((x,color)) #else: #ns = self.stopsCache[mode] = (self.pos, color) return self.stopsCache[mode]
def getLookupTable(self, nPts, alpha=None): """ Return an RGB(A) lookup table (ndarray). ============== ============================================================================ **Arguments:** nPts The number of points in the returned lookup table. alpha True, False, or None - Specifies whether or not alpha values are included in the table.If alpha is None, alpha will be automatically determined. ============== ============================================================================ """ if alpha is None: alpha = self.usesAlpha() if alpha: table = np.empty((nPts,4), dtype=np.ubyte) else: table = np.empty((nPts,3), dtype=np.ubyte) for i in range(nPts): x = float(i)/(nPts-1) color = self.getColor(x, toQColor=False) table[i] = color[:table.shape[1]] return table
def test_rescaleData(): dtypes = map(np.dtype, ('ubyte', 'uint16', 'byte', 'int16', 'int', 'float')) for dtype1 in dtypes: for dtype2 in dtypes: data = (np.random.random(size=10) * 2**32 - 2**31).astype(dtype1) for scale, offset in [(10, 0), (10., 0.), (1, -50), (0.2, 0.5), (0.001, 0)]: if dtype2.kind in 'iu': lim = np.iinfo(dtype2) lim = lim.min, lim.max else: lim = (-np.inf, np.inf) s1 = np.clip(float(scale) * (data-float(offset)), *lim).astype(dtype2) s2 = pg.rescaleData(data, scale, offset, dtype2) assert s1.dtype == s2.dtype if dtype2.kind in 'iu': assert np.all(s1 == s2) else: assert np.allclose(s1, s2)
def readQImage(self): """ Read the current buffer pixels out as a QImage. """ w = self.width() h = self.height() self.repaint() pixels = np.empty((h, w, 4), dtype=np.ubyte) pixels[:] = 128 pixels[...,0] = 50 pixels[...,3] = 255 glReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, pixels) # swap B,R channels for Qt tmp = pixels[...,0].copy() pixels[...,0] = pixels[...,2] pixels[...,2] = tmp pixels = pixels[::-1] # flip vertical img = fn.makeQImage(pixels, transpose=False) return img
def boolToUbyte(x): "Convert a boolean vector to a ubyte vector which is much more space efficient." assert isinstance(x,np.ndarray) assert x.dtype in [np.bool] assert len(x.shape) == 1 assert x.shape[0] % 8 == 0 out = 1*x[7::8] + \ 2*x[6::8] + \ 4*x[5::8] + \ 8*x[4::8] + \ 16*x[3::8] + \ 32*x[2::8] + \ 64*x[1::8] + \ 128*x[0::8] out = out.astype(np.ubyte) return out
def ubyteToBool(x): "Convert a byte vector to a bool vector." assert isinstance(x,np.ndarray) assert x.dtype in [np.ubyte] assert len(x.shape) == 1 out = np.zeros(x.shape[0]*8,dtype=np.bool) out[7::8] = 1&x > 0 out[6::8] = 2&x > 0 out[5::8] = 4&x > 0 out[4::8] = 8&x > 0 out[3::8] = 16&x > 0 out[2::8] = 32&x > 0 out[1::8] = 64&x > 0 out[0::8] = 128&x > 0 return out
def load_data(images_url: str, labels_url: str) -> (np.array, np.array): images_decompressed = downloader(images_url) # Big endian 4 ????? ???? unsigned int, ?????? ?? 4 ????? magic, size, rows, cols = struct.unpack(">IIII", images_decompressed[:16]) if magic != 2051: print("Wrong magic for", images_url, "Probably file corrupted") exit(2) image_data = np.array(np.frombuffer(images_decompressed[16:], dtype=np.dtype((np.ubyte, (rows * cols,)))) / 255, dtype=np.float32) labels_decompressed = downloader(labels_url) # Big endian 2 ????? ???? unsigned int, ?????? ?? 4 ????? magic, size = struct.unpack(">II", labels_decompressed[:8]) if magic != 2049: print("Wrong magic for", labels_url, "Probably file corrupted") exit(2) labels = np.frombuffer(labels_decompressed[8:], dtype=np.ubyte) return image_data, labels
def load_MNIST_images(filename): """ returns a 28x28x[number of MNIST images] matrix containing the raw MNIST images :param filename: input data file """ with open(filename, "r") as f: magic = np.fromfile(f, dtype=np.dtype('>i4'), count=1) num_images = int(np.fromfile(f, dtype=np.dtype('>i4'), count=1)) num_rows = int(np.fromfile(f, dtype=np.dtype('>i4'), count=1)) num_cols = int(np.fromfile(f, dtype=np.dtype('>i4'), count=1)) images = np.fromfile(f, dtype=np.ubyte) images = images.reshape((num_images, num_rows * num_cols)).transpose() images = images.astype(np.float64) / 255 f.close() return images
def test_check_argument_list4(): kernel_name = "test_kernel" kernel_string = """__kernel void test_kernel(__global const ushort number, __global half * factors, __global long * numbers) { numbers[get_global_id(0)] = numbers[get_global_id(0)] * factors[get_global_id(0)] + number; } """ args = [numpy.uint16(42), numpy.float16([3, 4, 6]), numpy.int64([300]), numpy.ubyte(32)] try: check_argument_list(kernel_name, kernel_string, args) print("Expected a TypeError to be raised") assert False except TypeError as expected_error: print(str(expected_error)) assert "do not match in size" in str(expected_error) except Exception: print("Expected a TypeError to be raised") assert False
def test_sequential_runner_not_matching_answer2(): kernel_string = """__global__ void vector_add(float *c, float *a, float *b, int n) { int i = blockIdx.x * block_size_x + threadIdx.x; if (i<n) { c[i] = a[i] + b[i]; } } """ args = get_vector_add_args() answer = [np.ubyte([12]), None, None, None] tune_params = {"block_size_x": [128 + 64 * i for i in range(5)]} try: kernel_tuner.tune_kernel( "vector_add", kernel_string, args[-1], args, tune_params, method="diff_evo", verbose=True, answer=answer) print("Expected a TypeError to be raised") assert False except TypeError as expected_error: print(str(expected_error)) assert "Element 0" in str(expected_error) except Exception: print("Expected a TypeError to be raised") assert False
def load_transferfunction(filename): with open(filename,'rb') as fid: data = np.fromfile(fid, count=-1,dtype=np.ubyte) return data
def colorMap(self): """Return a ColorMap object representing the current state of the editor.""" if self.colorMode == 'hsv': raise NotImplementedError('hsv colormaps not yet supported') pos = [] color = [] for t,x in self.listTicks(): pos.append(x) c = t.color color.append([c.red(), c.green(), c.blue(), c.alpha()]) return ColorMap(np.array(pos), np.array(color, dtype=np.ubyte))
def saveFailedTest(data, expect, filename): """Upload failed test images to web server to allow CI test debugging. """ commit = runSubprocess(['git', 'rev-parse', 'HEAD']) name = filename.split('/') name.insert(-1, commit.strip()) filename = '/'.join(name) host = 'data.pyqtgraph.org' # concatenate data, expect, and diff into a single image ds = data.shape es = expect.shape shape = (max(ds[0], es[0]) + 4, ds[1] + es[1] + 8 + max(ds[1], es[1]), 4) img = np.empty(shape, dtype=np.ubyte) img[..., :3] = 100 img[..., 3] = 255 img[2:2+ds[0], 2:2+ds[1], :ds[2]] = data img[2:2+es[0], ds[1]+4:ds[1]+4+es[1], :es[2]] = expect diff = makeDiffImage(data, expect) img[2:2+diff.shape[0], -diff.shape[1]-2:-2] = diff png = makePng(img) conn = httplib.HTTPConnection(host) req = urllib.urlencode({'name': filename, 'data': base64.b64encode(png)}) conn.request('POST', '/upload.py', req) response = conn.getresponse().read() conn.close() print("\nImage comparison failed. Test result: %s %s Expected result: " "%s %s" % (data.shape, data.dtype, expect.shape, expect.dtype)) print("Uploaded to: \nhttp://%s/data/%s" % (host, filename)) if not response.startswith(b'OK'): print("WARNING: Error uploading data to %s" % host) print(response)
def makeDiffImage(im1, im2): """Return image array showing the differences between im1 and im2. Handles images of different shape. Alpha channels are not compared. """ ds = im1.shape es = im2.shape diff = np.empty((max(ds[0], es[0]), max(ds[1], es[1]), 4), dtype=int) diff[..., :3] = 128 diff[..., 3] = 255 diff[:ds[0], :ds[1], :min(ds[2], 3)] += im1[..., :3] diff[:es[0], :es[1], :min(es[2], 3)] -= im2[..., :3] diff = np.clip(diff, 0, 255).astype(np.ubyte) return diff
def test(self, im1, im2, message): """Ask the user to decide whether an image test passes or fails. This method displays the test image, reference image, and the difference between the two. It then blocks until the user selects the test output by clicking a pass/fail button or typing p/f. If the user fails the test, then an exception is raised. """ self.show() if im2 is None: message += '\nImage1: %s %s Image2: [no standard]' % (im1.shape, im1.dtype) im2 = np.zeros((1, 1, 3), dtype=np.ubyte) else: message += '\nImage1: %s %s Image2: %s %s' % (im1.shape, im1.dtype, im2.shape, im2.dtype) self.label.setText(message) self.views[0].image.setImage(im1) self.views[1].image.setImage(im2) diff = makeDiffImage(im1, im2) self.views[2].image.setImage(diff) self.views[0].autoRange() while True: QtGui.QApplication.processEvents() lastKey = self.lastKey self.lastKey = None if lastKey in ('f', 'esc') or not self.isVisible(): raise Exception("User rejected test result.") elif lastKey == 'p': break time.sleep(0.03) for v in self.views: v.image.setImage(np.zeros((1, 1, 3), dtype=np.ubyte))
def initializeGL(self): ## Generate texture for rendering points w = 64 def fn(x,y): r = ((x-w/2.)**2 + (y-w/2.)**2) ** 0.5 return 255 * (w/2. - np.clip(r, w/2.-1.0, w/2.)) pData = np.empty((w, w, 4)) pData[:] = 255 pData[:,:,3] = np.fromfunction(fn, pData.shape[:2]) #print pData.shape, pData.min(), pData.max() pData = pData.astype(np.ubyte) if getattr(self, "pointTexture", None) is None: self.pointTexture = glGenTextures(1) glActiveTexture(GL_TEXTURE0) glEnable(GL_TEXTURE_2D) glBindTexture(GL_TEXTURE_2D, self.pointTexture) glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, pData.shape[0], pData.shape[1], 0, GL_RGBA, GL_UNSIGNED_BYTE, pData) self.shader = shaders.getShaderProgram('pointSprite') #def getVBO(self, name): #if name not in self.vbo: #self.vbo[name] = vbo.VBO(getattr(self, name).astype('f')) #return self.vbo[name] #def setupGLState(self): #"""Prepare OpenGL state for drawing. This function is called immediately before painting.""" ##glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) ## requires z-sorting to render properly. #glBlendFunc(GL_SRC_ALPHA, GL_ONE) #glEnable( GL_BLEND ) #glEnable( GL_ALPHA_TEST ) #glDisable( GL_DEPTH_TEST ) ##glEnable( GL_POINT_SMOOTH ) ##glHint(GL_POINT_SMOOTH_HINT, GL_NICEST) ##glPointParameterfv(GL_POINT_DISTANCE_ATTENUATION, (0, 0, -1e-3)) ##glPointParameterfv(GL_POINT_SIZE_MAX, (65500,)) ##glPointParameterfv(GL_POINT_SIZE_MIN, (0,))
def imageToArray(img, copy=False, transpose=True): """ Convert a QImage into numpy array. The image must have format RGB32, ARGB32, or ARGB32_Premultiplied. By default, the image is not copied; changes made to the array will appear in the QImage as well (beware: if the QImage is collected before the array, there may be trouble). The array will have shape (width, height, (b,g,r,a)). """ fmt = img.format() ptr = img.bits() if USE_PYSIDE: arr = np.frombuffer(ptr, dtype=np.ubyte) else: ptr.setsize(img.byteCount()) arr = np.asarray(ptr) if img.byteCount() != arr.size * arr.itemsize: # Required for Python 2.6, PyQt 4.10 # If this works on all platforms, then there is no need to use np.asarray.. arr = np.frombuffer(ptr, np.ubyte, img.byteCount()) arr = arr.reshape(img.height(), img.width(), 4) if fmt == img.Format_RGB32: arr[...,3] = 255 if copy: arr = arr.copy() if transpose: return arr.transpose((1,0,2)) else: return arr
def parse(x): #parse the digits file into tuples of digit = loads(x) array = np.fromstring(b64decode(digit["data"]),dtype=np.ubyte) array = array.astype(np.float64) return (digit["label"], array)
def setup_textures(gltf, uri_path): # TODO: support data URIs pil_images = {} for image_name, image in gltf.get('images', {}).items(): filename = os.path.join(uri_path, image['uri']) pil_image = Image.open(filename) pil_images[image_name] = pil_image _logger.debug('* loaded image "%s" (from %s)', image_name, filename) for texture_name, texture in gltf.get('textures', {}).items(): sampler = gltf['samplers'][texture['sampler']] texture_id = gl.glGenTextures(1) gl.glBindTexture(texture['target'], texture_id) sampler_id = gl.glGenSamplers(1) gl.glSamplerParameteri(sampler_id, gl.GL_TEXTURE_MIN_FILTER, sampler.get('minFilter', 9986)) gl.glSamplerParameteri(sampler_id, gl.GL_TEXTURE_MAG_FILTER, sampler.get('magFilter', 9729)) gl.glSamplerParameteri(sampler_id, gl.GL_TEXTURE_WRAP_S, sampler.get('wrapS', 10497)) gl.glSamplerParameteri(sampler_id, gl.GL_TEXTURE_WRAP_T, sampler.get('wrapT', 10497)) sampler['id'] = sampler_id gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1) if texture['type'] != gl.GL_UNSIGNED_BYTE: raise Exception('TODO') gl.glTexImage2D(texture['target'], 0, texture['internalFormat'], pil_image.width, pil_image.height, 0, gl.GL_RGB, #texture['format'], # INVESTIGATE texture['type'], np.array(list(pil_image.getdata()), dtype=(np.ubyte if texture['type'] == gl.GL_UNSIGNED_BYTE else np.ushort))) gl.glGenerateMipmap(texture['target']) if gl.glGetError() != gl.GL_NO_ERROR: raise Exception('failed to create texture "%s"' % texture_name) texture['id'] = texture_id _logger.debug('* created texture "%s"', texture_name)
def hamming(a,b): if a.dtype == np.bool and b.dtype == bool: return (a ^ b).sum() elif a.dtype == np.ubyte and b.dtype == np.ubyte: return hamming_table[a^b].sum() else: raise NotImplementedError("Unsupported array types %s and %s",a.dtype,b.dtype)
def colormap_lut(color = 'viridis', ncolors = None): # build lookup table if color == 'r': pos = np.array([0.0, 1.0]) color = np.array([[0,0,0,255], [255,0,0,255]], dtype=np.ubyte) ncolors = 512; elif color =='g': pos = np.array([0.0, 1.0]) color = np.array([[0,0,0,255], [0,255,0,255]], dtype=np.ubyte) ncolors = 512; elif color =='b': pos = np.array([0.0, 1.0]) color = np.array([[0,0,0,255], [0,0,255,255]], dtype=np.ubyte) ncolors = 512; else: #pos = np.array([0.0, 0.25, 0.5, 0.75, 1.0]) #color = np.array([[0,0,255,255], [0,255,255,255], [0,255,0,255], [255,255,0,255], [255,0,0,255]], dtype=np.ubyte) #color = np.array([[0,0,128,255], [0,255,255,255], [0,255,0,255], [255,255,0,255], [128,0,0,255]], dtype=np.ubyte) cmap = cm.get_cmap(color); if ncolors is None: ncolors = cmap.N; pos = np.linspace(0.0, 1.0, ncolors); color = cmap(pos, bytes = True); cmap = pg.ColorMap(pos, color) return cmap.getLookupTable(0.0, 1.0, ncolors);
def adjust_contrast(image, contrast): if (contrast < 0): contrast = 0 elif (contrast > 200): contrast = 200 contrast = contrast / 100 img = image.astype(np.float) * contrast img[img > 255] = 255 img[img < 0] = 0 return img.astype(np.ubyte)
def adjust_brightness(image, brightness): if (brightness < 0): brightness = 0 elif (brightness > 200): brightness = 200 brightness = (((brightness) * (510)) / 200) - 255 img = image.astype(np.float) + brightness img[img > 255] = 255 img[img < 0] = 0 return img.astype(np.ubyte)
def kmeans(X, n_clusters, **kwargs): """Classify vectors in X using K-Means algorithm with n_clusters. Arguments in kwargs are passed to scikit-learn MiniBatchKMeans. Returns a tuple of cluster centers and predicted labels.""" clf = MiniBatchKMeans(n_clusters=n_clusters, **kwargs) labels = clf.fit_predict(X) centers = clf.cluster_centers_.astype(np.ubyte) return centers, labels
def get_mask_polygons(polygons, height, width): """Turn a list of polygons into a mask image of height by width. Each polygon is expressed as a list of [x, y] points.""" mask = np.zeros((height, width), dtype=np.ubyte) cv2.fillPoly(mask, np.int32(polygons), color=255) return mask
def convert(image): """Convert a scikit-image binary image matrix to OpenCV""" with warnings.catch_warnings(record=True): warnings.filterwarnings('ignore', category=DataConversionWarning) return minmax_scale(image, (0, 255)).astype(np.ubyte)
def getpgcmap(cmp='BuRd'): import pyqtgraph as pg import numpy as np if cmp =='bryw': STEPS = np.array([0.0, 0.2, 0.6, 1.0]) CLRS = ['k', 'r', 'y', 'w'] ## Create a ColorMap clrmp = pg.ColorMap(STEPS, np.array([pg.colorTuple(pg.Color(c)) for c in CLRS])) ## Get the LookupTable lut = clrmp.getLookupTable() elif cmp == 'TrmBlk': pos = np.array([0.0, 0.5, 1.0]) color = np.array([[0,0,0,255], [255,128,0,255], [255,255,0,255]], dtype=np.ubyte) map = pg.ColorMap(pos, color) lut = map.getLookupTable(0.0, 1.0, 256) elif cmp == 'RdBu': pos = np.array([0.0,0.5,1.0]) color = np.array([[255,0,0,0],[255,255,255,255],[0,0,255,0]],dtype=np.ubyte) map = pg.ColorMap(pos,color) lut = map.getLookupTable(0.0,1.0,256) elif cmp == 'BuRd': pos = np.array([0.0,0.5,1.0]) color = np.array([[0,0,255,0],[255,255,255,255],[255,0,0,0]],dtype=np.ubyte) map = pg.ColorMap(pos,color) lut = map.getLookupTable(0.0,1.0,256) return lut
def get_mnist_images(): import gzip from tensorflow.contrib.learn.python.learn.datasets import base import numpy def extract_images(f): """Extract the images into a 4D uint8 numpy array [index, y, x, depth]. Args: f: A file object that can be passed into a gzip reader. Returns: data: A 4D uint8 numpy array [index, y, x, depth]. Raises: ValueError: If the bytestream does not start with 2051. """ print('Extracting', f.name) with gzip.GzipFile(fileobj=f) as bytestream: magic = _read32(bytestream) if magic != 2051: raise ValueError('Invalid magic number %d in MNIST image file: %s' % (magic, f.name)) num_images = _read32(bytestream) rows = _read32(bytestream) cols = _read32(bytestream) buf = bytestream.read(rows * cols * num_images) data = numpy.frombuffer(buf, dtype=numpy.uint8) data = data.reshape(num_images, rows, cols, 1) return data def _read32(bytestream): dt = numpy.dtype(numpy.uint32).newbyteorder('>') return numpy.frombuffer(bytestream.read(4), dtype=dt)[0] TRAIN_IMAGES = 'train-images-idx3-ubyte.gz' source_url = 'https://storage.googleapis.com/cvdf-datasets/mnist/' local_file = base.maybe_download(TRAIN_IMAGES, '/tmp', source_url + TRAIN_IMAGES) train_images = extract_images(open(local_file, 'rb')) train_images = train_images.reshape(60000, 28**2).T.astype(np.float64)/255 return train_images # helper utilities
def _update(self): """ Upload all pending data to GPU. """ if self.pending_data: start, stop = self.pending_data offset, nbytes = start, stop-start # offset, nbytes = self.pending_data data = self.ravel().view(np.ubyte)[offset:offset + nbytes] gl.glBufferSubData(self.target, offset, nbytes, data) self._pending_data = None self._need_update = False
def calculate_numpy_brga_for(name: str) -> np.ndarray: colormap = maps.get(name, maps[default_colormap]) result = np.zeros((len(colormap), 4), dtype=np.ubyte) for i, color in enumerate(colormap): result[i] = (int(255 * color[2]), int(255 * color[1]), int(255 * color[0]), 255) return result
def amean (inarray,dimension=None,keepdims=0): """ Calculates the arithmatic mean of the values in the passed array. That is: 1/n * (x1 + x2 + ... + xn). Defaults to ALL values in the passed array. Use dimension=None to flatten array first. REMEMBER: if dimension=0, it collapses over dimension 0 ('rows' in a 2D array) only, and if dimension is a sequence, it collapses over all specified dimensions. If keepdims is set to 1, the resulting array will have as many dimensions as inarray, with only 1 'level' per dim that was collapsed over. Usage: amean(inarray,dimension=None,keepdims=0) Returns: arithematic mean calculated over dim(s) in dimension """ if inarray.dtype in [N.int_, N.short,N.ubyte]: inarray = inarray.astype(N.float_) if dimension == None: inarray = N.ravel(inarray) sum = N.add.reduce(inarray) denom = float(len(inarray)) elif type(dimension) in [IntType,FloatType]: sum = asum(inarray,dimension) denom = float(inarray.shape[dimension]) if keepdims == 1: shp = list(inarray.shape) shp[dimension] = 1 sum = N.reshape(sum,shp) else: # must be a TUPLE of dims to average over dims = list(dimension) dims.sort() dims.reverse() sum = inarray *1.0 for dim in dims: sum = N.add.reduce(sum,dim) denom = N.array(N.multiply.reduce(N.take(inarray.shape,dims)),N.float_) if keepdims == 1: shp = list(inarray.shape) for dim in dims: shp[dim] = 1 sum = N.reshape(sum,shp) return sum/denom
def atmean(a,limits=None,inclusive=(1,1)): """ Returns the arithmetic mean of all values in an array, ignoring values strictly outside the sequence passed to 'limits'. Note: either limit in the sequence, or the value of limits itself, can be set to None. The inclusive list/tuple determines whether the lower and upper limiting bounds (respectively) are open/exclusive (0) or closed/inclusive (1). Usage: atmean(a,limits=None,inclusive=(1,1)) """ if a.dtype in [N.int_, N.short,N.ubyte]: a = a.astype(N.float_) if limits == None: return mean(a) assert type(limits) in [ListType,TupleType,N.ndarray], "Wrong type for limits in atmean" if inclusive[0]: lowerfcn = N.greater_equal else: lowerfcn = N.greater if inclusive[1]: upperfcn = N.less_equal else: upperfcn = N.less if limits[0] > N.maximum.reduce(N.ravel(a)) or limits[1] < N.minimum.reduce(N.ravel(a)): raise ValueError, "No array values within given limits (atmean)." elif limits[0]==None and limits[1]<>None: mask = upperfcn(a,limits[1]) elif limits[0]<>None and limits[1]==None: mask = lowerfcn(a,limits[0]) elif limits[0]<>None and limits[1]<>None: mask = lowerfcn(a,limits[0])*upperfcn(a,limits[1]) s = float(N.add.reduce(N.ravel(a*mask))) n = float(N.add.reduce(N.ravel(mask))) return s/n
def asum (a, dimension=None,keepdims=0): """ An alternative to the Numeric.add.reduce function, which allows one to (1) collapse over multiple dimensions at once, and/or (2) to retain all dimensions in the original array (squashing one down to size. Dimension can equal None (ravel array first), an integer (the dimension over which to operate), or a sequence (operate over multiple dimensions). If keepdims=1, the resulting array will have as many dimensions as the input array. Usage: asum(a, dimension=None, keepdims=0) Returns: array summed along 'dimension'(s), same _number_ of dims if keepdims=1 """ if type(a) == N.ndarray and a.dtype in [N.int_, N.short, N.ubyte]: a = a.astype(N.float_) if dimension == None: s = N.sum(N.ravel(a)) elif type(dimension) in [IntType,FloatType]: s = N.add.reduce(a, dimension) if keepdims == 1: shp = list(a.shape) shp[dimension] = 1 s = N.reshape(s,shp) else: # must be a SEQUENCE of dims to sum over dims = list(dimension) dims.sort() dims.reverse() s = a *1.0 for dim in dims: s = N.add.reduce(s,dim) if keepdims == 1: shp = list(a.shape) for dim in dims: shp[dim] = 1 s = N.reshape(s,shp) return s
def render(self): # Convert data to QImage for display. profile = debug.Profiler() if self.image is None or self.image.size == 0: return if isinstance(self.lut, collections.Callable): lut = self.lut(self.image) else: lut = self.lut if self.autoDownsample: # reduce dimensions of image based on screen resolution o = self.mapToDevice(QtCore.QPointF(0,0)) x = self.mapToDevice(QtCore.QPointF(1,0)) y = self.mapToDevice(QtCore.QPointF(0,1)) w = Point(x-o).length() h = Point(y-o).length() if w == 0 or h == 0: self.qimage = None return xds = max(1, int(1.0 / w)) yds = max(1, int(1.0 / h)) axes = [1, 0] if self.axisOrder == 'row-major' else [0, 1] image = fn.downsample(self.image, xds, axis=axes[0]) image = fn.downsample(image, yds, axis=axes[1]) self._lastDownsample = (xds, yds) else: image = self.image # if the image data is a small int, then we can combine levels + lut # into a single lut for better performance levels = self.levels if levels is not None and levels.ndim == 1 and image.dtype in (np.ubyte, np.uint16): if self._effectiveLut is None: eflsize = 2**(image.itemsize*8) ind = np.arange(eflsize) minlev, maxlev = levels levdiff = maxlev - minlev levdiff = 1 if levdiff == 0 else levdiff # don't allow division by 0 if lut is None: efflut = fn.rescaleData(ind, scale=255./levdiff, offset=minlev, dtype=np.ubyte) else: lutdtype = np.min_scalar_type(lut.shape[0]-1) efflut = fn.rescaleData(ind, scale=(lut.shape[0]-1)/levdiff, offset=minlev, dtype=lutdtype, clip=(0, lut.shape[0]-1)) efflut = lut[efflut] self._effectiveLut = efflut lut = self._effectiveLut levels = None # Assume images are in column-major order for backward compatibility # (most images are in row-major order) if self.axisOrder == 'col-major': image = image.transpose((1, 0, 2)[:image.ndim]) argb, alpha = fn.makeARGB(image, lut=lut, levels=levels) self.qimage = fn.makeQImage(argb, alpha, transpose=False)
def renderToArray(self, size, format=GL_BGRA, type=GL_UNSIGNED_BYTE, textureSize=1024, padding=256): w,h = map(int, size) self.makeCurrent() tex = None fb = None try: output = np.empty((w, h, 4), dtype=np.ubyte) fb = glfbo.glGenFramebuffers(1) glfbo.glBindFramebuffer(glfbo.GL_FRAMEBUFFER, fb ) glEnable(GL_TEXTURE_2D) tex = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, tex) texwidth = textureSize data = np.zeros((texwidth,texwidth,4), dtype=np.ubyte) ## Test texture dimensions first glTexImage2D(GL_PROXY_TEXTURE_2D, 0, GL_RGBA, texwidth, texwidth, 0, GL_RGBA, GL_UNSIGNED_BYTE, None) if glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH) == 0: raise Exception("OpenGL failed to create 2D texture (%dx%d); too large for this hardware." % shape[:2]) ## create teture glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texwidth, texwidth, 0, GL_RGBA, GL_UNSIGNED_BYTE, data.transpose((1,0,2))) self.opts['viewport'] = (0, 0, w, h) # viewport is the complete image; this ensures that paintGL(region=...) # is interpreted correctly. p2 = 2 * padding for x in range(-padding, w-padding, texwidth-p2): for y in range(-padding, h-padding, texwidth-p2): x2 = min(x+texwidth, w+padding) y2 = min(y+texwidth, h+padding) w2 = x2-x h2 = y2-y ## render to texture glfbo.glFramebufferTexture2D(glfbo.GL_FRAMEBUFFER, glfbo.GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0) self.paintGL(region=(x, h-y-h2, w2, h2), viewport=(0, 0, w2, h2)) # only render sub-region ## read texture back to array data = glGetTexImage(GL_TEXTURE_2D, 0, format, type) data = np.fromstring(data, dtype=np.ubyte).reshape(texwidth,texwidth,4).transpose(1,0,2)[:, ::-1] output[x+padding:x2-padding, y+padding:y2-padding] = data[padding:w2-padding, -(h2-padding):-padding] finally: self.opts['viewport'] = None glfbo.glBindFramebuffer(glfbo.GL_FRAMEBUFFER, 0) glBindTexture(GL_TEXTURE_2D, 0) if tex is not None: glDeleteTextures([tex]) if fb is not None: glfbo.glDeleteFramebuffers([fb]) return output
def map(self, data, mode='byte'): """ Return an array of colors corresponding to *data*. ============== ================================================================= **Arguments:** data A numpy record array where the fields in data.dtype match those defined by a prior call to setFields(). mode Either 'byte' or 'float'. For 'byte', the method returns an array of dtype ubyte with values scaled 0-255. For 'float', colors are returned as 0.0-1.0 float values. ============== ================================================================= """ if isinstance(data, dict): data = np.array([tuple(data.values())], dtype=[(k, float) for k in data.keys()]) colors = np.zeros((len(data),4)) for item in self.children(): if not item['Enabled']: continue chans = item.param('Channels..') mask = np.empty((len(data), 4), dtype=bool) for i,f in enumerate(['Red', 'Green', 'Blue', 'Alpha']): mask[:,i] = chans[f] colors2 = item.map(data) op = item['Operation'] if op == 'Add': colors[mask] = colors[mask] + colors2[mask] elif op == 'Multiply': colors[mask] *= colors2[mask] elif op == 'Overlay': a = colors2[:,3:4] c3 = colors * (1-a) + colors2 * a c3[:,3:4] = colors[:,3:4] + (1-colors[:,3:4]) * a colors = c3 elif op == 'Set': colors[mask] = colors2[mask] colors = np.clip(colors, 0, 1) if mode == 'byte': colors = (colors * 255).astype(np.ubyte) return colors
def export(self, fileName=None, toBytes=False, copy=False): if fileName is None and not toBytes and not copy: if USE_PYSIDE: filter = ["*."+str(f) for f in QtGui.QImageWriter.supportedImageFormats()] else: filter = ["*."+bytes(f).decode('utf-8') for f in QtGui.QImageWriter.supportedImageFormats()] preferred = ['*.png', '*.tif', '*.jpg'] for p in preferred[::-1]: if p in filter: filter.remove(p) filter.insert(0, p) self.fileSaveDialog(filter=filter) return targetRect = QtCore.QRect(0, 0, self.params['width'], self.params['height']) sourceRect = self.getSourceRect() #self.png = QtGui.QImage(targetRect.size(), QtGui.QImage.Format_ARGB32) #self.png.fill(pyqtgraph.mkColor(self.params['background'])) w, h = self.params['width'], self.params['height'] if w == 0 or h == 0: raise Exception("Cannot export image with size=0 (requested export size is %dx%d)" % (w,h)) bg = np.empty((self.params['width'], self.params['height'], 4), dtype=np.ubyte) color = self.params['background'] bg[:,:,0] = color.blue() bg[:,:,1] = color.green() bg[:,:,2] = color.red() bg[:,:,3] = color.alpha() self.png = fn.makeQImage(bg, alpha=True) ## set resolution of image: origTargetRect = self.getTargetRect() resolutionScale = targetRect.width() / origTargetRect.width() #self.png.setDotsPerMeterX(self.png.dotsPerMeterX() * resolutionScale) #self.png.setDotsPerMeterY(self.png.dotsPerMeterY() * resolutionScale) painter = QtGui.QPainter(self.png) #dtr = painter.deviceTransform() try: self.setExportMode(True, {'antialias': self.params['antialias'], 'background': self.params['background'], 'painter': painter, 'resolutionScale': resolutionScale}) painter.setRenderHint(QtGui.QPainter.Antialiasing, self.params['antialias']) self.getScene().render(painter, QtCore.QRectF(targetRect), QtCore.QRectF(sourceRect)) finally: self.setExportMode(False) painter.end() if copy: QtGui.QApplication.clipboard().setImage(self.png) elif toBytes: return self.png else: self.png.save(fileName)
