我们从Python开源项目中，提取了以下20个代码示例，用于说明如何使用numpy.right_shift()。
def test_NotImplemented_not_returned(self): # See gh-5964 and gh-2091. Some of these functions are not operator # related and were fixed for other reasons in the past. binary_funcs = [ np.power, np.add, np.subtract, np.multiply, np.divide, np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or, np.bitwise_xor, np.left_shift, np.right_shift, np.fmax, np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2, np.logical_and, np.logical_or, np.logical_xor, np.maximum, np.minimum, np.mod ] # These functions still return NotImplemented. Will be fixed in # future. # bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal] a = np.array('1') b = 1 for f in binary_funcs: assert_raises(TypeError, f, a, b)
def dec10216(data): """Unpacking the 10 bit data to 16 bit""" arr10 = data.astype(np.uint16).flat new_shape = list(data.shape[:-1]) + [(data.shape[-1] * 8) / 10] new_shape = [int(s) for s in new_shape] arr16 = np.zeros(new_shape, dtype=np.uint16) arr16.flat[::4] = np.left_shift(arr10[::5], 2) + \ np.right_shift((arr10[1::5]), 6) arr16.flat[1::4] = np.left_shift((arr10[1::5] & 63), 4) + \ np.right_shift((arr10[2::5]), 4) arr16.flat[2::4] = np.left_shift(arr10[2::5] & 15, 6) + \ np.right_shift((arr10[3::5]), 2) arr16.flat[3::4] = np.left_shift(arr10[3::5] & 3, 8) + \ arr10[4::5] return arr16
def dec10216(inbuf): arr10 = inbuf.astype(np.uint16) arr16 = np.zeros((int(len(arr10) * 4 / 5),), dtype=np.uint16) arr10_len = int((len(arr16) * 5) / 4) arr10 = arr10[:arr10_len] # adjust size """ /* * pack 4 10-bit words in 5 bytes into 4 16-bit words * * 0 1 2 3 4 5 * 01234567890123456789012345678901234567890 * 0 1 2 3 4 */ ip = &in_buffer[i]; op = &out_buffer[j]; op[0] = ip[0]*4 + ip[1]/64; op[1] = (ip[1] & 0x3F)*16 + ip[2]/16; op[2] = (ip[2] & 0x0F)*64 + ip[3]/4; op[3] = (ip[3] & 0x03)*256 +ip[4]; """ arr16.flat[::4] = np.left_shift(arr10[::5], 2) + \ np.right_shift((arr10[1::5]), 6) arr16.flat[1::4] = np.left_shift((arr10[1::5] & 63), 4) + \ np.right_shift((arr10[2::5]), 4) arr16.flat[2::4] = np.left_shift(arr10[2::5] & 15, 6) + \ np.right_shift((arr10[3::5]), 2) arr16.flat[3::4] = np.left_shift(arr10[3::5] & 3, 8) + \ arr10[4::5] return arr16
def flatten_and_pack(img, bits): """ Packs reduced bit depth images into bytes and returns a flattened array Args: img (uint8 numpy array): grayscale or multi-channel image bits (int): 1, 2, 4, or 8 bits per channel Returns: uint8 numpy array: flattened and packed array """ # pad the image at the end of the rows, so that each row ends on a byte boundary pixels_per_byte = 8 // bits if len(img.shape) > 1: if img.shape[1] % pixels_per_byte != 0: img = np.hstack((img, np.zeros((img.shape[0], pixels_per_byte - img.shape[1] % pixels_per_byte), dtype=np.uint8))) a = np.right_shift(img, 8-bits) # reduce bit depth b = a.flatten() # flatten c = np.zeros(b.size // pixels_per_byte, dtype=np.uint8) for i in range(0, pixels_per_byte): c += np.left_shift(b[i::pixels_per_byte], (pixels_per_byte-1-i)*bits) # pack pixels and add to result return c
def _rgb_integers_to_components(self, rgb_integers): red_mask = 0x00FF0000 green_mask = 0x0000FF00 blue_mask = 0x000000FF masks = np.asarray([[red_mask, green_mask, blue_mask]]) masked_rgb_components = np.bitwise_and(rgb_integers, masks) red_shifted = np.right_shift(masked_rgb_components[:,0], 16) green_shifted = np.right_shift(masked_rgb_components[:,1], 8) blue_shifted = np.right_shift(masked_rgb_components[:,2], 0) return np.array([red_shifted, green_shifted, blue_shifted]).transpose()
def __rshift__(self, other): return right_shift(self, other)
def __irshift__(self, other): return right_shift(self, other, self)
def __rrshift__(self, other): return right_shift(other, self)
def doDecompression( packedDataList, shape, n_threads ): blosc.set_nthreads( n_threads ) dataList = [None] * len(packedDataList) for J in np.arange(len(packedDataList) ): # dataStack[J,:,:] = np.reshape( # np.frombuffer( blosc.decompress( packedDataList[J] ), dtype='uint8' ), # shape[1:] ) # Something here Numpy-side is very slow, so let's not include that in our # benchmark. dataList[J] = blosc.decompress( packedDataList[J] ) return dataList #t_half0 = time.time() #halfimage = dm4image_8bit[:,:,::2] + np.left_shift(dm4image_8bit[:,:,1::2],4) #t_half1 = time.time() #restoreimage = np.empty( header['dimensions'], dtype='uint8' ) ##image[0::2] = np.left_shift(interlaced_image,4)/16 ##image[1::2] = np.right_shift(interlaced_image,4) ## Different interlace option ## TODO: AND array with 15 instead? #restoreimage[:,:,::2] = (np.left_shift( halfimage, 4 ) & 15 ) #restoreimage[:,:,1::2] = np.right_shift( halfimage, 4 ) #t_half2 = time.time() # #print( "4-byte encoding time (s): %f" % (t_half1 - t_half0) ) #print( "4-byte DEcoding time (s): %f" % (t_half2 - t_half1) )
def numpy_int16_to_uint8(depth): x, y = depth.shape out = np.ndarray((x, y, 2), dtype=np.uint8) out[:, :, 0] = np.right_shift(depth, 8) out[:, :, 1] = depth.astype(np.uint8) return out
def binary_permutations(n_bits): """ Given some number of bits, return a shape (2**n_bits, n_bits) boolean array containing every permoutation of those bits as a row. :param n_bits: An integer number of bits :return: A shape (2**n_bits, n_bits) boolean array containing every permoutation of those bits as a row. """ return np.right_shift(np.arange(2**n_bits)[:, None], np.arange(n_bits-1, -1, -1)[None, :]) & 1
def _mix(a, b, f): #Used for the blend function (mixes colors according to their alpha values) c = numpy.multiply(numpy.subtract(b,a),f) return numpy.add(numpy.right_shift(c,8),a)
def complex_data(self): ''' This will cast each byte to an int8 and interpret each byte as 4 bits real values and 4 bits imag values (RRRRIIII). The data are then used to create a 3D numpy array of dtype=complex, which is returned. The shape of the numpy array is N half frames, M subbands, K data points per half frame, where K = constants.bins_per_half_frame, N is typically 129 and M is typically 1 for compamp files and 16 for archive-compamp files. Note that this returns a Numpy array of type complex64. This data is not retained within Compamp objects. ''' #note that since we can only pack into int8 types, we must pad each 4-bit value with 4, 0 bits #this effectively multiplies each 4-bit value by 16 when that value is represented as an 8-bit signed integer. packed_data = self._packed_data() header = self.header() real_val = np.bitwise_and(packed_data, 0xf0).astype(np.int8) # coef's are: RRRRIIII (4 bits real, imag_val = np.left_shift(np.bitwise_and(packed_data, 0x0f), 4).astype(np.int8) # 4 bits imaginary in 2's complement) cdata = np.empty(len(real_val), np.complex64) #"Normalize" by making appropriate bit-shift. Otherwise, values for real and imaginary coefficients are #inflated by 16x. cdata.real = np.right_shift(real_val, 4) cdata.imag = np.right_shift(imag_val, 4) # expose compamp measurement blocks cdata = cdata.reshape((header['number_of_half_frames'], header['number_of_subbands'], constants.bins_per_half_frame)) return cdata
def _get_voc_color_map(n=256): color_map = np.zeros((n, 3)) for i in xrange(n): r = b = g = 0 cid = i for j in xrange(0, 8): r = np.bitwise_or(r, np.left_shift(np.unpackbits(np.array([cid], dtype=np.uint8))[-1], 7-j)) g = np.bitwise_or(g, np.left_shift(np.unpackbits(np.array([cid], dtype=np.uint8))[-2], 7-j)) b = np.bitwise_or(b, np.left_shift(np.unpackbits(np.array([cid], dtype=np.uint8))[-3], 7-j)) cid = np.right_shift(cid, 3) color_map[i][0] = r color_map[i][1] = g color_map[i][2] = b return color_map
