我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.logical_and()。
def _resolve_spec(im1, im2): im = im1.copy() img1 = cv.cvtColor(im1, cv.COLOR_BGR2GRAY) img2 = cv.cvtColor(im2, cv.COLOR_BGR2GRAY) # Best pixel selection criteria # 1. Pixel difference should be more than 20. (just an experimentally value. Free to change!) # 2. Best pixel should have less intensity # 3. pixel should not be pure black. (just an additional constraint # to remove black background created by warping) mask = np.logical_and((img1 - img2) > DIFF_THRESHOLD, img1 > img2) mask = np.logical_and(mask, img2 != 0) im[mask] = im2[mask] return im
def action_label_counts(directory, data_loader, n_actions=18, n=None): episode_paths = frame.episode_paths(directory) label_counts = [0, 0] action_label_counts = [[0, 0] for i in range(n_actions)] if n is not None: np.random.shuffle(episode_paths) episode_paths = episode_paths[:n] for episode_path in tqdm.tqdm(episode_paths): try: features, labels = data_loader.load_features_and_labels([episode_path]) except: traceback.print_exc() else: for label in range(len(label_counts)): label_counts[label] += np.count_nonzero(labels == label) for action in range(n_actions): actions = np.reshape(np.array(features["action"]), [-1]) action_label_counts[action][label] += np.count_nonzero( np.logical_and(labels == label, actions == action)) return label_counts, action_label_counts
def iall(arrays, axis = -1): """ Test whether all array elements along a given axis evaluate to True Parameters ---------- arrays : iterable Arrays to be reduced. axis : int or None, optional Axis along which a logical AND reduction is performed. The default is to perform a logical AND along the 'stream axis', as if all arrays in ``array`` were stacked along a new dimension. If ``axis = None``, arrays in ``arrays`` are flattened before reduction. Yields ------ all : ndarray, dtype bool """ yield from ireduce_ufunc(arrays, ufunc = np.logical_and, axis = axis)
def _classify_gems(counts0, counts1): """ Infer number of distinct transcriptomes present in each GEM (1 or 2) and report cr_constants.GEM_CLASS_GENOME0 for a single cell w/ transcriptome 0, report cr_constants.GEM_CLASS_GENOME1 for a single cell w/ transcriptome 1, report cr_constants.GEM_CLASS_MULTIPLET for multiple transcriptomes """ # Assumes that most of the GEMs are single-cell; model counts independently thresh0, thresh1 = [cr_constants.DEFAULT_MULTIPLET_THRESHOLD] * 2 if sum(counts0 > counts1) >= 1 and sum(counts1 > counts0) >= 1: thresh0 = np.percentile(counts0[counts0 > counts1], cr_constants.MULTIPLET_PROB_THRESHOLD) thresh1 = np.percentile(counts1[counts1 > counts0], cr_constants.MULTIPLET_PROB_THRESHOLD) doublet = np.logical_and(counts0 >= thresh0, counts1 >= thresh1) dtype = np.dtype('|S%d' % max(len(cls) for cls in cr_constants.GEM_CLASSES)) result = np.where(doublet, cr_constants.GEM_CLASS_MULTIPLET, cr_constants.GEM_CLASS_GENOME0).astype(dtype) result[np.logical_and(np.logical_not(result == cr_constants.GEM_CLASS_MULTIPLET), counts1 > counts0)] = cr_constants.GEM_CLASS_GENOME1 return result
def reg2bin_vector(begin, end): '''Vectorized tabix reg2bin -- much faster than reg2bin''' result = np.zeros(begin.shape) # Entries filled done = np.zeros(begin.shape, dtype=np.bool) for (bits, bins) in rev_bit_bins: begin_shift = begin >> bits new_done = (begin >> bits) == (end >> bits) mask = np.logical_and(new_done, np.logical_not(done)) offset = ((1 << (29 - bits)) - 1) / 7 result[mask] = offset + begin_shift[mask] done = new_done return result.astype(np.int32)
def compute_test_accuracy(X_test, Y_test, model, prediction_type, cellgroup_map_array): prediction = model.predict(X_test) auc = [] if prediction_type=="cellgroup": prediction = np.dot(prediction, cellgroup_map_array) Y_test = np.dot(Y_test, cellgroup_map_array) mask = ~np.logical_or(Y_test.sum(1)==0, Y_test.sum(1)==Y_test.shape[1]) for y,pred in zip(Y_test.T,prediction.T): pos = np.logical_and(mask, y==1) neg = np.logical_and(mask, y==0) try: U = stats.mannwhitneyu(pred[pos], pred[neg])[0] auc.append(1.-U/(np.count_nonzero(pos)*np.count_nonzero(neg))) except ValueError: auc.append(0.5) return auc
def ignore_data(self, xmin=None, xmax=None, unit=None): """ Ignore the data points within range [xmin, xmax]. If xmin is None, then xmin=min(xdata); if xmax is None, then xmax=max(xdata). if unit is None, then assume the same unit as `self.xunit'. """ if unit is None: unit = self.xunit if xmin is not None: xmin = self.convert_unit(xmin, unit=unit) else: xmin = np.min(self.xdata) if xmax is not None: xmax = self.convert_unit(xmax, unit=unit) else: xmax = np.max(self.xdata) ignore_idx = np.logical_and(self.xdata >= xmin, self.xdata <= xmax) self.mask[ignore_idx] = False # reset `f_residual' self.f_residual = None
def notice_data(self, xmin=None, xmax=None, unit=None): """ Notice the data points within range [xmin, xmax]. If xmin is None, then xmin=min(xdata); if xmax is None, then xmax=max(xdata). if unit is None, then assume the same unit as `self.xunit'. """ if unit is None: unit = self.xunit if xmin is not None: xmin = self.convert_unit(xmin, unit=unit) else: xmin = np.min(self.xdata) if xmax is not None: xmax = self.convert_unit(xmax, unit=unit) else: xmax = np.max(self.xdata) notice_idx = np.logical_and(self.xdata >= xmin, self.xdata <= xmax) self.mask[notice_idx] = True # reset `f_residual' self.f_residual = None
def overlap_ratio(boxes1, boxes2): # find intersection bbox x_int_bot = np.maximum(boxes1[:, 0], boxes2[0]) x_int_top = np.minimum(boxes1[:, 0] + boxes1[:, 2], boxes2[0] + boxes2[2]) y_int_bot = np.maximum(boxes1[:, 1], boxes2[1]) y_int_top = np.minimum(boxes1[:, 1] + boxes1[:, 3], boxes2[1] + boxes2[3]) # find intersection area dx = x_int_top - x_int_bot dy = y_int_top - y_int_bot area_int = np.where(np.logical_and(dx>0, dy>0), dx * dy, np.zeros_like(dx)) # find union area_union = boxes1[:,2] * boxes1[:,3] + boxes2[2] * boxes2[3] - area_int # find overlap ratio ratio = np.where(area_union > 0, area_int/area_union, np.zeros_like(area_int)) return ratio ########################################################################### # overlap_ratio of two bboxes # ###########################################################################
def overlap_ratio_pair(boxes1, boxes2): # find intersection bbox x_int_bot = np.maximum(boxes1[:, 0], boxes2[:, 0]) x_int_top = np.minimum(boxes1[:, 0] + boxes1[:, 2], boxes2[:, 0] + boxes2[:, 2]) y_int_bot = np.maximum(boxes1[:, 1], boxes2[:, 1]) y_int_top = np.minimum(boxes1[:, 1] + boxes1[:, 3], boxes2[:, 1] + boxes2[:, 3]) # find intersection area dx = x_int_top - x_int_bot dy = y_int_top - y_int_bot area_int = np.where(np.logical_and(dx>0, dy>0), dx * dy, np.zeros_like(dx)) # find union area_union = boxes1[:,2] * boxes1[:,3] + boxes2[:, 2] * boxes2[:, 3] - area_int # find overlap ratio ratio = np.where(area_union > 0, area_int/area_union, np.zeros_like(area_int)) return ratio
def _create_drop_path_choices(self): if not self._drop_path: # Drop path was turned off. return np.zeros(shape=[len(self._choices)], dtype='int32') elif np.random.uniform() < self._p_local_drop_path: # Local drop-path (make each choice independantly at random.) choices = np.random.uniform(size=[len(self._choices)]) drop_base = choices < self._p_drop_base_case drop_recursive = np.logical_and( choices < (self._p_drop_base_case + self._p_drop_recursive_case), np.logical_not(drop_base)) return (np.int32(drop_base)*self._JUST_RECURSE + np.int32(drop_recursive)*self._JUST_BASE) else: # Global (pick a single column.) column = np.random.randint(self._fractal_block_depth) return np.array( [self._JUST_RECURSE if len(binary_seq) < column else self._JUST_BASE for _, binary_seq in self._choices], dtype='int32')
def __act_manual(self, state_meas): if len(self.__measure_for_manual): # [AMMO2, AMMO3, AMMO4, AMMO5, AMMO6, AMMO7, WEAPON2, # WEAPON3 WEAPON4 WEAPON5 WEAPON6 WEAPON7 SELECTED_WEAPON] assert len(self.__measure_for_manual) == 13 # [SELECT_WEAPON2 SELECT_WEAPON3 SELECT_WEAPON4 SELECT_WEAPON5 SELECT_WEAPON6 SELECT_WEAPON7] curr_action = np.zeros((state_meas.shape[0], self.__num_manual_controls), dtype=np.int) for ns in range(state_meas.shape[0]): curr_ammo = state_meas[ns, self.__measure_for_manual[:6]] curr_weapons = state_meas[ns, self.__measure_for_manual[6:12]] if self.verbose: print 'current ammo:', curr_ammo print 'current weapons:', curr_weapons available_weapons = np.logical_and(curr_ammo >= np.array([1, 2, 1, 1, 1, 40]), curr_weapons) if any(available_weapons): best_weapon = np.nonzero(available_weapons)[0][-1] if not state_meas[ns, self.__measure_for_manual[12]] == best_weapon + 2: curr_action[ns, best_weapon] = 1 return curr_action else: return []
def anamVertexRegionSize(vor, L, typical=6): """ Given a set of centroids (voronoi generators), for each vertex in the tessellation, return 1 if the vertex is part of a region that is not of the 'typical' size """ # vertices v = vor.vertices sizeFlag = numpy.zeros(len(v)) # flag for anamolous region size # regSize = [[]]*len(v) # list of region sizes for reg in vor.regions: if len(reg) > 0 and -1 not in reg: # Non-empty and non-open region size = len(reg) if size != typical: for vert in reg: # update size of all vertices that are in the region # regSize[vert].append(size) sizeFlag[vert] = 1 # Choose all in box sizeFlag = sizeFlag[numpy.logical_and(*[numpy.logical_and(v[:, i] >= 0, v[:, i] <= L[i]) for i in range(2)])] sizeFlag = sizeFlag.astype('int') return sizeFlag
def anamVertexRegionSize(vor, L, typical=6): """ Given a set of centroids (voronoi generators), for each vertex in the tessellation, return 1 if the vertex is part of a region that is not of the 'typical' size """ # vertices v = vor.vertices sizeFlag = numpy.zeros(len(v)) # flag for anamolous region size #regSize = [[]]*len(v) # list of region sizes for reg in vor.regions: if len(reg) > 0 and -1 not in reg: # Non-empty and non-open region size = len(reg) if size != typical: for vert in reg: # update size of all vertices that are in the region #regSize[vert].append(size) sizeFlag[vert] = 1 # Choose all in box sizeFlag = sizeFlag[ numpy.logical_and(* [ numpy.logical_and(v[:,i]>=0, v[:,i] <= L[i]) for i in range(2) ] )] sizeFlag = sizeFlag.astype('int') return sizeFlag
def test_truth_table_logical(self): # 2, 3 and 4 serves as true values input1 = [0, 0, 3, 2] input2 = [0, 4, 0, 2] typecodes = (np.typecodes['AllFloat'] + np.typecodes['AllInteger'] + '?') # boolean for dtype in map(np.dtype, typecodes): arg1 = np.asarray(input1, dtype=dtype) arg2 = np.asarray(input2, dtype=dtype) # OR out = [False, True, True, True] for func in (np.logical_or, np.maximum): assert_equal(func(arg1, arg2).astype(bool), out) # AND out = [False, False, False, True] for func in (np.logical_and, np.minimum): assert_equal(func(arg1, arg2).astype(bool), out) # XOR out = [False, True, True, False] for func in (np.logical_xor, np.not_equal): assert_equal(func(arg1, arg2).astype(bool), out)
def test_object_logical(self): a = np.array([3, None, True, False, "test", ""], dtype=object) assert_equal(np.logical_or(a, None), np.array([x or None for x in a], dtype=object)) assert_equal(np.logical_or(a, True), np.array([x or True for x in a], dtype=object)) assert_equal(np.logical_or(a, 12), np.array([x or 12 for x in a], dtype=object)) assert_equal(np.logical_or(a, "blah"), np.array([x or "blah" for x in a], dtype=object)) assert_equal(np.logical_and(a, None), np.array([x and None for x in a], dtype=object)) assert_equal(np.logical_and(a, True), np.array([x and True for x in a], dtype=object)) assert_equal(np.logical_and(a, 12), np.array([x and 12 for x in a], dtype=object)) assert_equal(np.logical_and(a, "blah"), np.array([x and "blah" for x in a], dtype=object)) assert_equal(np.logical_not(a), np.array([not x for x in a], dtype=object)) assert_equal(np.logical_or.reduce(a), 3) assert_equal(np.logical_and.reduce(a), None)
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 get_metrics(predictions, targets): assert(np.logical_or(predictions == 1, predictions == 0).all()) assert(np.logical_or(targets == 1, targets == 0).all()) TP = np.logical_and(predictions == 1, targets == 1).sum() FP = np.logical_and(predictions == 1, targets == 0).sum() FN = np.logical_and(predictions == 0, targets == 1).sum() TN = np.logical_and(predictions == 0, targets == 0).sum() N = TP + FP + FN + TN PPV = float(TP) / float(TP + FP) if TP != 0.0 else 0.0 FPV = float(TN) / float(TN + FN) if TN != 0.0 else 0.0 ACC = float(TP + TN) / float(N) TPR = float(TP) / float(TP + FN) if TP != 0.0 else 0.0 FPR = float(FP) / float(FP + TN) if FP != 0.0 else 0.0 tp, tn, fp, fn = float(TP) / N, float(TN) / N, float(FP) / N, float(FN) / N MCC = float(tp*tn - fp*fn) / (np.sqrt(tp+fp)*np.sqrt(tp+fn)*np.sqrt(tn+fp)*np.sqrt(tn+fn)) F1 = 2 * TP / float(2 * TP + FP + FN) metrics = { "TP": TP, "FP": FP, "FN": FN, "TN": TN, "N": N, "PPV": PPV, "FPV": FPV, "MCC": MCC, "ACC": ACC, "F1": F1 } return metrics
def simOnePrd(self): ''' Simulate one period of the fashion victom model for this type. Each agent receives an idiosyncratic preference shock and chooses whether to change styles (using the optimal decision rule). Parameters ---------- none Returns ------- none ''' pNow = self.pNow sPrev = self.sNow J2Pprob = self.switchFuncJock(pNow) P2Jprob = self.switchFuncPunk(pNow) Shks = self.RNG.rand(self.pop_size) J2P = np.logical_and(sPrev == 0,Shks < J2Pprob) P2J = np.logical_and(sPrev == 1,Shks < P2Jprob) sNow = copy(sPrev) sNow[J2P] = 1 sNow[P2J] = 0 self.sNow = sNow
def _shrink(v, gamma): """Soft-shrinkage of an array with parameter gamma. Parameters ---------- v : array Array containing the values to be applied to the shrinkage operator gamma : float Shrinkage parameter. Returns ------- v : array The same input array after the shrinkage operator was applied. """ pos = v > gamma neg = v < -gamma v[pos] -= gamma v[neg] += gamma v[np.logical_and(~pos, ~neg)] = .0 return v
def __split_apply(self, func_y_lt_f, func_y_gt_f, func_f_lt_0, y, f): # Make sure all arrays are of a compatible type y, f = np.broadcast_arrays(y, f) y = y.astype(float, copy=False) f = f.astype(float, copy=False) if any(y < 0): raise ValueError("y has to be > 0!") # get indicators of which likelihoods to apply where y_lt_f = np.logical_and(y <= f, f > 0) y_gt_f = np.logical_and(y > f, f > 0) f_lt_0 = f <= 0 result = np.zeros_like(y) result[y_lt_f] = func_y_lt_f(y[y_lt_f], f[y_lt_f]) result[y_gt_f] = func_y_gt_f(y[y_gt_f], f[y_gt_f]) result[f_lt_0] = func_f_lt_0(y[f_lt_0], f[f_lt_0]) return result
def _global_lonlat2pix(self, lonlat): x = np.searchsorted(self._coords_x, lonlat[:, 0], side='right') - 1 x = x.astype(int) ycoords = self._coords_y y = np.searchsorted(ycoords, lonlat[:, 1], side='right') - 1 y = y.astype(int) # We want the *closed* interval, which means moving # points on the end back by 1 on_end_x = lonlat[:, 0] == self._coords_x[-1] on_end_y = lonlat[:, 1] == self._coords_y[-1] x[on_end_x] -= 1 y[on_end_y] -= 1 if (not all(np.logical_and(x >= 0, x < self._full_res[0]))) or \ (not all(np.logical_and(y >= 0, y < self._full_res[1]))): raise ValueError("Queried location is not " "in the image {}!".format(self.source._filename)) result = np.concatenate((x[:, np.newaxis], y[:, np.newaxis]), axis=1) return result # @contract(lonlat='array[Nx2](float64),N>0')
def load_switching_data(filename_or_fileobject, start_state=None, group="main", failure=False, threshold=None, voltage_scale_factor=1.0, duration_scale_factor=1.0, data_name='voltage', data_filter=None, display=False): data, desc = load_from_HDF5(filename_or_fileobject, reshape=False) # Regular axes states = desc[group].axis("state").points reps = desc[group].axis("attempt").points # Main data array, possibly unstructured dat = data[group][:].reshape((-1, reps.size, states.size)) # Filter data if desired # e.g. filter_func = lambda dat: np.logical_and(dat['field'] == 0.04, dat['temperature'] == 4.0) if data_filter: dat = dat[np.where(data_filter(dat))] Vs = dat[data_name] durs = dat['pulse_duration'][:,0,0] amps = dat['pulse_voltage'][:,0,0] points = np.array([durs, amps]).transpose() if failure: return points, reset_failure(Vs, start_state=start_state) else: return points, switching_phase(Vs, start_state=start_state, threshold=threshold, display=display)
def _pfp(pha, amp, phabin, binsize): """Sub prefered phase function """ nbin, nt = len(phabin), pha.shape[1] ampbin = np.zeros((len(phabin), nt), dtype=float) # Binarize amplitude accros all trials : for t in range(nt): curpha, curamp = pha[:, t], amp[:, t] for i, p in enumerate(phabin): idx = np.logical_and(curpha >= p, curpha < p+binsize) if idx.astype(int).sum() != 0: ampbin[i, t] = curamp[idx].mean() else: ampbin[i, t] = 0 ampbin[:, t] /= ampbin[:, t].sum() # Find prefered phase and p-values : pfp = np.array([phabin[k]+binsize/2 for k in ampbin.argmax(axis=0)]) pvalue = circ_rtest(pfp)[0] prf = phabin[ampbin.mean(axis=1).argmax()]+binsize/2 return pfp, prf, pvalue, ampbin
def get_snippet_idx(snippet, full_array): """ Find the indices of ``full_array`` where ``snippet`` is present. Assumes both ``snippet`` and ``full_array`` are ordered. Parameters ---------- snippet : np.array Array of ordered time stamps full_array : np.array Array of ordered time stamps Returns ------- idx : np.array Array of booleans indicating where in ``full_array`` ``snippet`` is present. """ idx = np.logical_and( full_array >= snippet[0], full_array <= snippet[-1] ) return idx
def get_signal_mask(df): masks = [] # Select waveforms whose DOMs are close to both interaction # vertices and still suficiently separated in time masks.append(df['GeometricalSelection'] == 1) # Apply a light set of cuts on the remaining waveforms masks.append(df['Bins_ToT_Pulse1'] >= 2) masks.append(df['Bins_ToT_Pulse2'] >= 3) masks.append(df['Bins_TbT'] >= 2) masks.append(df['Amplitude_Pulse1'] >= 10) masks.append(df['Amplitude_Pulse2'] >= 10) # Combine all the masks selection_mask = masks[0] for i in range(1, len(masks)): selection_mask = np.logical_and(selection_mask, masks[i]) return selection_mask
def get_edge_mask(self, subdomain=None): '''Get faces which are fully in subdomain. ''' if subdomain is None: # http://stackoverflow.com/a/42392791/353337 return numpy.s_[:] if subdomain not in self.subdomains: self._mark_vertices(subdomain) # A face is inside if all its edges are in. # An edge is inside if all its nodes are in. is_in = self.subdomains[subdomain]['vertices'][self.idx_hierarchy] # Take `all()` over the first index is_inside = numpy.all(is_in, axis=tuple(range(1))) if subdomain.is_boundary_only: # Filter for boundary is_inside = numpy.logical_and(is_inside, self.is_boundary_edge) return is_inside
def get_face_mask(self, subdomain): '''Get faces which are fully in subdomain. ''' if subdomain is None: # http://stackoverflow.com/a/42392791/353337 return numpy.s_[:] if subdomain not in self.subdomains: self._mark_vertices(subdomain) # A face is inside if all its edges are in. # An edge is inside if all its nodes are in. is_in = self.subdomains[subdomain]['vertices'][self.idx_hierarchy] # Take `all()` over all axes except the last two (face_ids, cell_ids). n = len(is_in.shape) is_inside = numpy.all(is_in, axis=tuple(range(n-2))) if subdomain.is_boundary_only: # Filter for boundary is_inside = numpy.logical_and(is_inside, self.is_boundary_face) return is_inside
def _mark_vertices(self, subdomain): '''Mark faces/edges which are fully in subdomain. ''' if subdomain is None: is_inside = numpy.ones(len(self.node_coords), dtype=bool) else: is_inside = subdomain.is_inside(self.node_coords.T).T if subdomain.is_boundary_only: # Filter boundary self.mark_boundary() is_inside = numpy.logical_and(is_inside, self.is_boundary_node) self.subdomains[subdomain] = { 'vertices': is_inside, } return
def _filter_image_with_no_gt(self): """ filter images that have no ground-truth labels. use case: when you wish to work only on a subset of pascal classes, you have 2 options: 1. use only the sub-dataset that contains the subset of classes 2. use all images, and images with no ground-truth will count as true-negative images :return: self object with filtered information """ # filter images that do not have any of the specified classes self.labels = [f[np.logical_and(f[:, 0] >= 0, f[:, 0] <= self.num_classes-1), :] for f in self.labels] # find indices of images with ground-truth labels gt_indices = [idx for idx, f in enumerate(self.labels) if not f.size == 0] self.labels = [self.labels[idx] for idx in gt_indices] self.image_set_index = [self.image_set_index[idx] for idx in gt_indices] old_num_images = self.num_images self.num_images = len(self.labels) print ('filtering images with no gt-labels. can abort filtering using *true_negative* flag') print ('... remaining {0}/{1} images. '.format(self.num_images, old_num_images))
def _make_counts(emin, emax): def _counts(field, data): e = data["event_energy"].in_units("keV") mask = np.logical_and(e >= emin, e < emax) x = data["event_x"][mask] y = data["event_y"][mask] z = np.ones(x.shape) pos = np.array([x,y,z]).transpose() img = data.deposit(pos, method="count") if data.has_field_parameter("sigma"): sigma = data.get_field_parameter("sigma") else: sigma = None if sigma is not None and sigma > 0.0: kern = _astropy.conv.Gaussian2DKernel(stddev=sigma) img[:,:,0] = _astropy.conv.convolve(img[:,:,0], kern) return data.ds.arr(img, "counts/pixel") return _counts
def test_particle_filter_dependency(): """ Test dataset add_particle_filter which should automatically add the dependency of the filter. """ @particle_filter(filtered_type='all', requires=['particle_type']) def stars(pfilter, data): filter = data[(pfilter.filtered_type, "particle_type")] == 2 return filter @particle_filter(filtered_type='stars', requires=['creation_time']) def young_stars(pfilter, data): age = data.ds.current_time - data[pfilter.filtered_type, "creation_time"] filter = np.logical_and(age.in_units('Myr') <= 5, age >= 0) return filter ds = yt.load(iso_galaxy) ds.add_particle_filter('young_stars') assert 'young_stars' in ds.particle_types assert 'stars' in ds.particle_types assert ('deposit', 'young_stars_cic') in ds.derived_field_list assert ('deposit', 'stars_cic') in ds.derived_field_list
def bbox_filter(left, right, domain_width): def myfilter(chunk, mask=None): pos = np.array([chunk['x'], chunk['y'], chunk['z']]).T # This hurts, but is useful for periodicity. Probably should check # first if it is even needed for a given left/right for i in range(3): pos[:, i] = np.mod(pos[:, i] - left[i], domain_width[i]) + left[i] # Now get all particles that are within the bbox if mask is None: mask = np.all(pos >= left, axis=1) np.logical_and(mask, np.all(pos < right, axis=1), mask) else: np.logical_and(mask, np.all(pos >= left, axis=1), mask) np.logical_and(mask, np.all(pos < right, axis=1), mask) return mask return myfilter
def get_transitions(states): """ Computes transitions given a state array Args: states : numpy array States array of the form ...,4,1,1,...,1,2,2,...,2,3,3,....,3,4,...,4,1,... Returns: transitions : numpy array Contains indices of all the transitions in the states array """ states = np.squeeze(states) # Edge cases when starts in 1 and/or ends in 4 if states[0] == 1: states = np.concatenate(([4], states)) if states[-1] == 4: states = np.concatenate((states, [1])) transitions = np.where(np.diff(states) != 0)[0] + 1 first = np.where(states == 1)[0][0] last = np.where(states == 4)[0][-1] + 1 transitions = transitions[np.logical_and(transitions >= first, transitions <= last)] return transitions
def _compute_count_purity(counts0, counts1): """ Compute fraction of counts in putative single-cell GEMs originating from the non-cell transcriptome """ gem_occupancy = MultiGenomeAnalysis._classify_gems(counts0, counts1) frac0 = counts0.astype(float) / (counts0 + counts1).astype(float) purity0 = frac0[gem_occupancy == cr_constants.GEM_CLASS_GENOME0] purity1 = 1 - frac0[gem_occupancy == cr_constants.GEM_CLASS_GENOME1] overall_purity = np.concatenate([purity0, purity1]) # Compute number of purity outliers threshold0, threshold1 = 1.0, 1.0 fit_purity0 = purity0[np.logical_and(purity0 > 0, purity0 < 1)] fit_purity1 = purity1[np.logical_and(purity1 > 0, purity1 < 1)] if len(fit_purity0) > 1 and len(fit_purity1) > 1: try: alpha0, beta0, _, _ = scipy.stats.beta.fit(fit_purity0, floc=0, fscale=1) alpha1, beta1, _, _ = scipy.stats.beta.fit(fit_purity1, floc=0, fscale=1) threshold0 = scipy.stats.beta.ppf(cr_constants.COUNT_PURITY_OUTLIER_PROB_THRESHOLD, alpha0, beta0) threshold1 = scipy.stats.beta.ppf(cr_constants.COUNT_PURITY_OUTLIER_PROB_THRESHOLD, alpha1, beta1) except scipy.stats._continuous_distns.FitSolverError as e: print >> sys.stderr, e threshold0, threshold1 = 1.0, 1.0 except scipy.stats._continuous_distns.FitDataError as e: print >> sys.stderr, e threshold0, threshold1 = 1.0, 1.0 outlier0 = np.logical_and(gem_occupancy == cr_constants.GEM_CLASS_GENOME0, frac0 < threshold0) outlier1 = np.logical_and(gem_occupancy == cr_constants.GEM_CLASS_GENOME1, (1-frac0) < threshold1) n_outlier0 = sum(outlier0) n_outlier1 = sum(outlier1) frac_outlier0 = tk_stats.robust_divide(n_outlier0, len(purity0)) frac_outlier1 = tk_stats.robust_divide(n_outlier1, len(purity1)) is_outlier = np.logical_or(outlier0, outlier1).astype(int) return (purity0.mean(), purity1.mean(), overall_purity.mean(), n_outlier0, n_outlier1, frac_outlier0, frac_outlier1, is_outlier)
def numpy_logical_and_list(list_of_logicals): assert(len(list_of_logicals) >= 2) output = list_of_logicals[0] for i in range(1,len(list_of_logicals)): output = np.logical_and(output, list_of_logicals[i]) return output
def clean_contour(in_contour, is_prob=False): if is_prob: pred = (in_contour >= 0.5).astype(np.float32) else: pred = in_contour labels = measure.label(pred) area = [] for l in range(1, np.amax(labels) + 1): area.append(np.sum(labels == l)) out_contour = in_contour out_contour[np.logical_and(labels > 0, labels != np.argmax(area) + 1)] = 0 return out_contour
def dice(im1, im2): """ Computes the Dice coefficient, a measure of set similarity. Parameters ---------- im1 : array-like, bool Any array of arbitrary size. If not boolean, will be converted. im2 : array-like, bool Any other array of identical size. If not boolean, will be converted. Returns ------- dice : float Dice coefficient as a float on range [0,1]. Maximum similarity = 1 No similarity = 0 Notes ----- The order of inputs for `dice` is irrelevant. The result will be identical if `im1` and `im2` are switched. """ im1 = np.asarray(im1).astype(np.bool) im2 = np.asarray(im2).astype(np.bool) if im1.shape != im2.shape: raise ValueError("Shape mismatch: im1 and im2 must have the same shape.") # Compute Dice coefficient intersection = np.logical_and(im1, im2) return (2. * intersection.sum() + np.finfo('float').eps) / (im1.sum() + im2.sum() + np.finfo('float').eps)
def dice(im1, im2): """ Computes the Dice coefficient, a measure of set similarity. Parameters ---------- im1 : array-like, bool Any array of arbitrary size. If not boolean, will be converted. im2 : array-like, bool Any other array of identical size. If not boolean, will be converted. Returns ------- dice : float Dice coefficient as a float on range [0,1]. Maximum similarity = 1 No similarity = 0 Notes ----- The order of inputs for `dice` is irrelevant. The result will be identical if `im1` and `im2` are switched. """ im1 = np.asarray(im1).astype(np.bool) im2 = np.asarray(im2).astype(np.bool) if im1.shape != im2.shape: raise ValueError("Shape mismatch: im1 and im2 must have the same shape.") # Compute Dice coefficient intersection = np.logical_and(im1, im2) return 2. * (intersection.sum() + np.finfo('float').eps) / (im1.sum() + im2.sum() + 2*np.finfo('float').eps)
def dice(im1, im2): """ Computes the Dice coefficient, a measure of set similarity. Parameters ---------- im1 : array-like, bool Any array of arbitrary size. If not boolean, will be converted. im2 : array-like, bool Any other array of identical size. If not boolean, will be converted. Returns ------- dice : float Dice coefficient as a float on range [0,1]. Maximum similarity = 1 No similarity = 0 Notes ----- The order of inputs for `dice` is irrelevant. The result will be identical if `im1` and `im2` are switched. """ im1 = np.asarray(im1).astype(np.bool) im2 = np.asarray(im2).astype(np.bool) if im1.shape != im2.shape: raise ValueError("Shape mismatch: im1 and im2 must have the same shape.") # Compute Dice coefficient intersection = np.logical_and(im1, im2) return 2. * (intersection.sum() + np.finfo('float').eps) / (im1.sum() + im2.sum() + 2 * np.finfo('float').eps)
def dice(im1, im2): """ Computes the Dice coefficient, a measure of set similarity. Parameters ---------- im1 : array-like, bool Any array of arbitrary size. If not boolean, will be converted. im2 : array-like, bool Any other array of identical size. If not boolean, will be converted. Returns ------- dice : float Dice coefficient as a float on range [0,1]. Maximum similarity = 1 No similarity = 0 Notes ----- The order of inputs for `dice` is irrelevant. The result will be identical if `im1` and `im2` are switched. """ im1 = np.asarray(im1).astype(np.bool) im2 = np.asarray(im2).astype(np.bool) if im1.shape != im2.shape: raise ValueError("Shape mismatch: im1 and im2 must have the same shape.") # Compute Dice coefficient intersection = np.logical_and(im1, im2) return 2. * intersection.sum() / (im1.sum() + im2.sum())
def __indexs_select_pk2(self,pk2_roi_pos): x_min = pk2_roi_pos[:,0].min() x_max = pk2_roi_pos[:,0].max() y_min = pk2_roi_pos[:,1].min() y_max = pk2_roi_pos[:,1].max() pca_1,pca_2 = self.PCAusedList.currentText().split("-") pca_1 = np.int(pca_1)-1 pca_2 = np.int(pca_2)-1 x = np.logical_and(self.wavePCAs[:,pca_1]>x_min, \ self.wavePCAs[:,pca_1]<x_max) y = np.logical_and(self.wavePCAs[:,pca_2]>y_min, \ self.wavePCAs[:,pca_2]<y_max) ind_0 = np.logical_and(x, y) ind_0 = np.where(ind_0 == True)[0] ind_0 = np.array(ind_0,dtype=np.int32) if ind_0.shape[0]>0: segments = [] for i in range(pk2_roi_pos.shape[0]-1): segments.append([pk2_roi_pos[i],pk2_roi_pos[i+1]]) segments.append([pk2_roi_pos[-1],pk2_roi_pos[0]]) segments = np.array(segments) temp_pcas = self.wavePCAs[ind_0] temp_pcas = temp_pcas[:,[pca_1,pca_2]] is_intersect = np.apply_along_axis(self.__intersect_roi2,1,temp_pcas,segments,pca_1) return ind_0[is_intersect] else: return np.array([],dtype=np.int32)
