我们从Python开源项目中，提取了以下45个代码示例，用于说明如何使用numpy.bitwise_or()。
def labelcolormap(N=256): def bitget(byteval, idx): return ((byteval & (1 << idx)) != 0) cmap = np.zeros((N, 3)) for i in range(0, N): id = i r, g, b = 0, 0, 0 for j in range(0, 8): r = np.bitwise_or(r, (bitget(id, 0) << 7-j)) g = np.bitwise_or(g, (bitget(id, 1) << 7-j)) b = np.bitwise_or(b, (bitget(id, 2) << 7-j)) id = (id >> 3) cmap[i, 0] = r cmap[i, 1] = g cmap[i, 2] = b cmap = cmap.astype(np.float32) / 255 return cmap
def loadDepthMap(self,filename): """ Read a depth-map :param filename: file name to load :return: image data of depth image """ img = Image.open(filename) # top 8 bits of depth are packed into green channel and lower 8 bits into blue assert len(img.getbands()) == 3 r, g, b = img.split() r = np.asarray(r, np.int32) g = np.asarray(g, np.int32) b = np.asarray(b, np.int32) dpt = np.bitwise_or(np.left_shift(g, 8), b) imgdata = np.asarray(dpt, np.float32) return imgdata
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 label_colormap(N=256): def bitget(byteval, idx): return ((byteval & (1 << idx)) != 0) cmap = np.zeros((N, 3)) for i in range(0, N): id = i r, g, b = 0, 0, 0 for j in range(0, 8): r = np.bitwise_or(r, (bitget(id, 0) << 7-j)) g = np.bitwise_or(g, (bitget(id, 1) << 7-j)) b = np.bitwise_or(b, (bitget(id, 2) << 7-j)) id = (id >> 3) cmap[i, 0] = r cmap[i, 1] = g cmap[i, 2] = b cmap = cmap.astype(np.float32) / 255 return cmap
def loadDepthMap(self, filename): """ Read a depth-map :param filename: file name to load :return: image data of depth image """ img = Image.open(filename) # top 8 bits of depth are packed into green channel and lower 8 bits into blue assert len(img.getbands()) == 3 r, g, b = img.split() r = np.asarray(r, np.int32) g = np.asarray(g, np.int32) b = np.asarray(b, np.int32) dpt = np.bitwise_or(np.left_shift(g, 8), b) imgdata = np.asarray(dpt, np.float32) return imgdata
def labelcolormap(N=256): cmap = np.zeros((N, 3)) for i in range(0, N): id = i r, g, b = 0, 0, 0 for j in range(0, 8): r = np.bitwise_or(r, (bitget(id, 0) << 7-j)) g = np.bitwise_or(g, (bitget(id, 1) << 7-j)) b = np.bitwise_or(b, (bitget(id, 2) << 7-j)) id = (id >> 3) cmap[i, 0] = r cmap[i, 1] = g cmap[i, 2] = b cmap = cmap.astype(np.float32) / 255 return cmap # ----------------------------------------------------------------------------- # Evaluation # -----------------------------------------------------------------------------
def test_values(self): for dt in self.bitwise_types: zeros = np.array([0], dtype=dt) ones = np.array([-1], dtype=dt) msg = "dt = '%s'" % dt.char assert_equal(np.bitwise_not(zeros), ones, err_msg=msg) assert_equal(np.bitwise_not(ones), zeros, err_msg=msg) assert_equal(np.bitwise_or(zeros, zeros), zeros, err_msg=msg) assert_equal(np.bitwise_or(zeros, ones), ones, err_msg=msg) assert_equal(np.bitwise_or(ones, zeros), ones, err_msg=msg) assert_equal(np.bitwise_or(ones, ones), ones, err_msg=msg) assert_equal(np.bitwise_xor(zeros, zeros), zeros, err_msg=msg) assert_equal(np.bitwise_xor(zeros, ones), ones, err_msg=msg) assert_equal(np.bitwise_xor(ones, zeros), ones, err_msg=msg) assert_equal(np.bitwise_xor(ones, ones), zeros, err_msg=msg) assert_equal(np.bitwise_and(zeros, zeros), zeros, err_msg=msg) assert_equal(np.bitwise_and(zeros, ones), zeros, err_msg=msg) assert_equal(np.bitwise_and(ones, zeros), zeros, err_msg=msg) assert_equal(np.bitwise_and(ones, ones), ones, err_msg=msg)
def set_ufunc(self, scalar_op): # This is probably a speed up of the implementation if isinstance(scalar_op, theano.scalar.basic.Add): self.ufunc = numpy.add elif isinstance(scalar_op, theano.scalar.basic.Mul): self.ufunc = numpy.multiply elif isinstance(scalar_op, theano.scalar.basic.Maximum): self.ufunc = numpy.maximum elif isinstance(scalar_op, theano.scalar.basic.Minimum): self.ufunc = numpy.minimum elif isinstance(scalar_op, theano.scalar.basic.AND): self.ufunc = numpy.bitwise_and elif isinstance(scalar_op, theano.scalar.basic.OR): self.ufunc = numpy.bitwise_or elif isinstance(scalar_op, theano.scalar.basic.XOR): self.ufunc = numpy.bitwise_xor else: self.ufunc = numpy.frompyfunc(scalar_op.impl, 2, 1)
def test_truth_table_bitwise(self): arg1 = [False, False, True, True] arg2 = [False, True, False, True] out = [False, True, True, True] assert_equal(np.bitwise_or(arg1, arg2), out) out = [False, False, False, True] assert_equal(np.bitwise_and(arg1, arg2), out) out = [False, True, True, False] assert_equal(np.bitwise_xor(arg1, arg2), out)
def __or__(self, other): return bitwise_or(self, other)
def __ior__(self, other): return bitwise_or(self, other, self)
def __ror__(self, other): return bitwise_or(other, self)
def label_colormap(N=256): cmap = np.zeros((N, 3)) for i in six.moves.range(0, N): id = i r, g, b = 0, 0, 0 for j in six.moves.range(0, 8): r = np.bitwise_or(r, (bitget(id, 0) << 7 - j)) g = np.bitwise_or(g, (bitget(id, 1) << 7 - j)) b = np.bitwise_or(b, (bitget(id, 2) << 7 - j)) id = (id >> 3) cmap[i, 0] = r cmap[i, 1] = g cmap[i, 2] = b cmap = cmap.astype(np.float32) / 255 return cmap
def create_binary_wf_data(wf, sync_mkr=0, samp_mkr=0, vertical_resolution=12): """Given numpy arrays of waveform and marker data convert to binary format. Assumes waveform data is np.float in range -1 to 1 and marker data can be cast to bool Binary format is waveform in MSB and and markers in LSB waveform sync_mkr samp_mkr 15 downto 4/2 1 0 """ #cast the waveform to integers if not((vertical_resolution == 12) or (vertical_resolution == 14)): raise ValueError("vertical resolution must be 12 or 14 bits") #convert waveform to integers scale_factor = 2**(vertical_resolution-1) bin_data = np.int16((scale_factor-1)*np.array(wf)) #clip if necessary if np.max(bin_data) > scale_factor-1 or np.min(bin_data) < -scale_factor: warnings.warn("Clipping waveform. Max value: {:d} Min value: {:d}. Scale factor: {:d}.".format(np.max(bin_data), np.min(bin_data),scale_factor)) bin_data = np.clip(bin_data, -scale_factor, scale_factor-1) # bin_data = bin_data.byteswap() #shift up to the MSB bin_data = np.left_shift(bin_data, 4 if vertical_resolution == 12 else 2) #add in the marker bits bin_data = np.bitwise_or(bin_data, np.bitwise_or(np.left_shift(np.bitwise_and(sync_mkr, 0x1), 1), np.bitwise_and(samp_mkr, 0x1))) return bin_data
def get_mask_overlap(mask1, mask2): intersect = np.bitwise_and(mask1, mask2).sum() union = np.bitwise_or(mask1, mask2).sum() return 1.0 * intersect / union
def _find_DoG_extrema(self, DoG): # TODO: sample ? ext = [] for octave in DoG: _, rows, cols = octave.shape # assert octave.shape = (<layers>(=s+2), <rows>, <columns>) ########################## # time ? ########################## peeled = [octave[ind1, ind2, ind3] for ind1, ind2, ind3 in product(*[[slice(1, -1), slice(2, None), slice(None, -2)]]*3)] center_block = peeled[0] # octave[1:-1,1:-1,1:-1], the center part neighbor_blocks = peeled[1:] # neighbors in 26 directions in 3-D DoG space with offset 1 is_extreme = \ np.bitwise_or(center_block > (np.max(neighbor_blocks, axis=0)), center_block < (np.min(neighbor_blocks, axis=0))) # assert is_extreme.shape = (s, rows-2, columns-2) ext_coord = np.array( list(product(*[range(1, i-1) for i in octave.shape]))).reshape([x-2 for x in octave.shape]+[-1]) assert ext_coord.shape[:-1] == is_extreme.shape ext_coord = ext_coord[is_extreme].astype(np.float) print("%d key point candidates found" % ext_coord.shape[0]) # assert ext_coord.shape = (<number of key points>, 3) ext_coord /= [1, rows, cols] # convert row, col coord to relative ext_coord[:, 0] = get_sigma_by_layer(ext_coord[:, 0]) ext.extend(list(ext_coord)) # filters # for layer, row, col in ext_coord: # nb = octave[layer-1:layer+2, row-1:row+2, col-1:col+2] # 3x3x3 neighbor # x_hat, d_x_hat = self._fit_extremum(nb) # if # TODO: if x[i] > 0.5, do it recursivey # print(x_hat, d_x_hat) return ext
def __ior__(self, other): np.bitwise_or(self, other, out=self) return self
def spread_bitsv(ival, level): res = np.zeros_like(ival, dtype='int64') for i in range(level): ares = np.bitwise_and(ival, 1<<i) << (i*2) np.bitwise_or(res, ares, res) return res
def get_keyv(iarr, level): i1, i2, i3 = (v.astype("int64") for v in iarr) i1 = spread_bitsv(i1, level) i2 = spread_bitsv(i2, level) << 1 i3 = spread_bitsv(i3, level) << 2 np.bitwise_or(i1, i2, i1) np.bitwise_or(i1, i3, i1) return i1
def pwdist_jaccard(self, seq1idx, seq2idx): """Compute the Jaccard-Needham dissimilarity between two boolean 1-D arrays. Returns: distance value (double) """ u = self[seq1idx] v = self[seq2idx] dist = (np.double(np.bitwise_and((u != v), np.bitwise_or(u != 0, v != 0)).sum()) / np.double(np.bitwise_or(u != 0, v != 0).sum())) return dist
def loadNYU(self, path): img = Image.open(path) if len(img.getbands()) != 3: raise ValueError('NYU input should be with 3 channel') r, g, b = img.split() r = np.asarray(r,np.int32) g = np.asarray(g,np.int32) b = np.asarray(b,np.int32) dpt = np.bitwise_or(np.left_shift(g,8),b) self.dmData = np.asarray(dpt, np.float32) return self.dmData
def combine_depth_frames(frame1, frame2): frame2[frame2 > 2046] = 0 return numpy.bitwise_or(frame1, frame2)
def test_types(self): for dt in self.bitwise_types: zeros = np.array([0], dtype=dt) ones = np.array([-1], dtype=dt) msg = "dt = '%s'" % dt.char assert_(np.bitwise_not(zeros).dtype == dt, msg) assert_(np.bitwise_or(zeros, zeros).dtype == dt, msg) assert_(np.bitwise_xor(zeros, zeros).dtype == dt, msg) assert_(np.bitwise_and(zeros, zeros).dtype == dt, msg)
def test_identity(self): assert_(np.bitwise_or.identity == 0, 'bitwise_or') assert_(np.bitwise_xor.identity == 0, 'bitwise_xor') assert_(np.bitwise_and.identity == -1, 'bitwise_and')
def test_reduction(self): binary_funcs = (np.bitwise_or, np.bitwise_xor, np.bitwise_and) for dt in self.bitwise_types: zeros = np.array([0], dtype=dt) ones = np.array([-1], dtype=dt) for f in binary_funcs: msg = "dt: '%s', f: '%s'" % (dt, f) assert_equal(f.reduce(zeros), zeros, err_msg=msg) assert_equal(f.reduce(ones), ones, err_msg=msg) # Test empty reduction, no object dtype for dt in self.bitwise_types[:-1]: # No object array types empty = np.array([], dtype=dt) for f in binary_funcs: msg = "dt: '%s', f: '%s'" % (dt, f) tgt = np.array(f.identity, dtype=dt) res = f.reduce(empty) assert_equal(res, tgt, err_msg=msg) assert_(res.dtype == tgt.dtype, msg) # Empty object arrays use the identity. Note that the types may # differ, the actual type used is determined by the assign_identity # function and is not the same as the type returned by the identity # method. for f in binary_funcs: msg = "dt: '%s'" % (f,) empty = np.array([], dtype=object) tgt = f.identity res = f.reduce(empty) assert_equal(res, tgt, err_msg=msg) # Non-empty object arrays do not use the identity for f in binary_funcs: msg = "dt: '%s'" % (f,) btype = np.array([True], dtype=object) assert_(type(f.reduce(btype)) is bool, msg)
def activate_network(self, num_activations=1): """Activates the Markov Network Parameters ---------- num_activations: int (default: 1) The number of times the Markov Network should be activated Returns ------- None """ original_input_values = np.copy(self.states[:self.num_input_states]) for _ in range(num_activations): for markov_gate, mg_input_ids, mg_output_ids in zip(self.markov_gates, self.markov_gate_input_ids, self.markov_gate_output_ids): # Determine the input values for this Markov Gate mg_input_values = self.states[mg_input_ids] mg_input_index = int(''.join([str(int(val)) for val in mg_input_values]), base=2) # Determine the corresponding output values for this Markov Gate roll = np.random.uniform() mg_output_index = np.where(markov_gate[mg_input_index, :] >= roll)[0][0] mg_output_values = np.array(list(np.binary_repr(mg_output_index, width=len(mg_output_ids))), dtype=np.uint8) self.states[mg_output_ids] = np.bitwise_or(self.states[mg_output_ids], mg_output_values) self.states[:self.num_input_states] = original_input_values
def mask(self,image): """Uses the image passed as parameter as alpha mask.""" if npy: aux1 = numpy.bitwise_and(self.pixels,0xffffff) aux2 = numpy.bitwise_and(image.pixels,0xff000000) self.pixels = numpy.bitwise_or(aux1,aux2) return for i in range(self.width): for j in range(self.height): n = self.get(i,j) m = image.get(i,j) new = ((m & 0xff000000) << 24) | (n & 0xffffff) self.set(i,j,new)
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
def seperate_lungs(image): #Creation of the markers as shown above: marker_internal, marker_external, marker_watershed = generate_markers(image) #Creation of the Sobel-Gradient sobel_filtered_dx = ndimage.sobel(image, 1) sobel_filtered_dy = ndimage.sobel(image, 0) sobel_gradient = np.hypot(sobel_filtered_dx, sobel_filtered_dy) sobel_gradient *= 255.0 / np.max(sobel_gradient) #Watershed algorithm watershed = morphology.watershed(sobel_gradient, marker_watershed) #Reducing the image created by the Watershed algorithm to its outline outline = ndimage.morphological_gradient(watershed, size=(3,3)) outline = outline.astype(bool) #Performing Black-Tophat Morphology for reinclusion #Creation of the disk-kernel and increasing its size a bit blackhat_struct = [[0, 0, 1, 1, 1, 0, 0], [0, 1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 0, 0]] blackhat_struct = ndimage.iterate_structure(blackhat_struct, 8) #Perform the Black-Hat outline += ndimage.black_tophat(outline, structure=blackhat_struct) #Use the internal marker and the Outline that was just created to generate the lungfilter lungfilter = np.bitwise_or(marker_internal, outline) #Close holes in the lungfilter #fill_holes is not used here, since in some slices the heart would be reincluded by accident ##structure = np.ones((BINARY_CLOSING_SIZE,BINARY_CLOSING_SIZE)) # 5 is not enough, 7 is structure = morphology.disk(BINARY_CLOSING_SIZE) # better , 5 seems sufficient, we use 7 for safety/just in case lungfilter = ndimage.morphology.binary_closing(lungfilter, structure=structure, iterations=3) #, iterations=3) # was structure=np.ones((5,5)) ### NOTE if no iterattions, i.e. default 1 we get holes within lungs for the disk(5) and perhaps more #Apply the lungfilter (note the filtered areas being assigned -2000 HU) segmented = np.where(lungfilter == 1, image, -2000*np.ones((512, 512))) ### was -2000 return segmented, lungfilter, outline, watershed, sobel_gradient, marker_internal, marker_external, marker_watershed
def seperate_lungs_3d(image): #Creation of the markers as shown above: marker_internal, marker_external, marker_watershed = generate_markers_3d(image) #Creation of the Sobel-Gradient sobel_filtered_dx = ndimage.sobel(image, axis=2) sobel_filtered_dy = ndimage.sobel(image, axis=1) sobel_gradient = np.hypot(sobel_filtered_dx, sobel_filtered_dy) sobel_gradient *= 255.0 / np.max(sobel_gradient) #Watershed algorithm watershed = morphology.watershed(sobel_gradient, marker_watershed) #Reducing the image created by the Watershed algorithm to its outline outline = ndimage.morphological_gradient(watershed, size=(1,3,3)) outline = outline.astype(bool) #Performing Black-Tophat Morphology for reinclusion #Creation of the disk-kernel and increasing its size a bit blackhat_struct = [[0, 0, 1, 1, 1, 0, 0], [0, 1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 0, 0]] blackhat_struct = ndimage.iterate_structure(blackhat_struct, 8) blackhat_struct = blackhat_struct[np.newaxis,:,:] #Perform the Black-Hat outline += ndimage.black_tophat(outline, structure=blackhat_struct) # very long time #Use the internal marker and the Outline that was just created to generate the lungfilter lungfilter = np.bitwise_or(marker_internal, outline) #Close holes in the lungfilter #fill_holes is not used here, since in some slices the heart would be reincluded by accident ##structure = np.ones((BINARY_CLOSING_SIZE,BINARY_CLOSING_SIZE)) # 5 is not enough, 7 is structure = morphology.disk(BINARY_CLOSING_SIZE) # better , 5 seems sufficient, we use 7 for safety/just in case structure = structure[np.newaxis,:,:] lungfilter = ndimage.morphology.binary_closing(lungfilter, structure=structure, iterations=3) #, iterations=3) # was structure=np.ones((5,5)) ### NOTE if no iterattions, i.e. default 1 we get holes within lungs for the disk(5) and perhaps more #Apply the lungfilter (note the filtered areas being assigned -2000 HU) segmented = np.where(lungfilter == 1, image, -2000*np.ones(marker_internal.shape)) return segmented, lungfilter, outline, watershed, sobel_gradient, marker_internal, marker_external, marker_watershed
def get_segmented_lungs(image): #Creation of the markers as shown above: marker_internal, marker_external, marker_watershed = generate_markers(image) #Creation of the Sobel-Gradient sobel_filtered_dx = ndimage.sobel(image, 1) sobel_filtered_dy = ndimage.sobel(image, 0) sobel_gradient = np.hypot(sobel_filtered_dx, sobel_filtered_dy) sobel_gradient *= 255.0 / np.max(sobel_gradient) #Watershed algorithm watershed = morphology.watershed(sobel_gradient, marker_watershed) #Reducing the image created by the Watershed algorithm to its outline outline = ndimage.morphological_gradient(watershed, size=(3,3)) outline = outline.astype(bool) #Performing Black-Tophat Morphology for reinclusion #Creation of the disk-kernel and increasing its size a bit blackhat_struct = [[0, 0, 1, 1, 1, 0, 0], [0, 1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 0, 0]] #blackhat_struct = ndimage.iterate_structure(blackhat_struct, 8) blackhat_struct = ndimage.iterate_structure(blackhat_struct, 14) # <- retains more of the area, 12 works well. Changed to 14, 12 still excluded some parts. #Perform the Black-Hat outline += ndimage.black_tophat(outline, structure=blackhat_struct) #Use the internal marker and the Outline that was just created to generate the lungfilter lungfilter = np.bitwise_or(marker_internal, outline) #Close holes in the lungfilter #fill_holes is not used here, since in some slices the heart would be reincluded by accident lungfilter = ndimage.morphology.binary_closing(lungfilter, structure=np.ones((5,5)), iterations=3) #Apply the lungfilter (note the filtered areas being assigned threshold_min HU) segmented = np.where(lungfilter == 1, image, threshold_min*np.ones(image.shape)) #return segmented, lungfilter, outline, watershed, sobel_gradient, marker_internal, marker_external, marker_watershed return segmented
