def _showMeanStd(self, busy=True): if busy: busy = BusyIndicator() dmin, dmax = self._subset_range subset, mask = self.image.optimalRavel(self._subset) dprint(5, "computing mean") mean = measurements.mean(subset, labels=mask, index=None if mask is None else False) dprint(5, "computing std") std = measurements.standard_deviation(subset, labels=mask, index=None if mask is None else False) dprint(5, "done") text = " ".join([("%s: " + DataValueFormat) % (name, value) for name, value in ("min", dmin), ("max", dmax), ("mean", mean), ("std", std)] + ["np: %d" % self._subset.size]) self._wlab_stats.setText(text) self._wmore_stats.hide() # update markers ypos = 0.3 self._line_mean.line.setData([mean, mean], [0, 1]) self._line_mean.marker.setValue(mean, ypos) self._line_mean.setText(("\u03BC=" + DataValueFormat) % mean) self._line_mean.show() self._line_std.line.setData([mean - std, mean + std], [ypos, ypos]) self._line_std.marker.setValue(mean, ypos) self._line_std.setText(("\u03C3=" + DataValueFormat) % std) self._line_std.show() self._histplot.replot()
def measure_expression(self, im, labels, segment_ids): """ Measure expression levels. Args: im (np.ndarray[float]) - 3D array of pixel values labels (np.ndarray[int]) - cell segment labels segment_ids (np.ndarray[int]) - ordered segment IDs """ # split R/G/B image channels drop = lambda x: x.reshape(*x.shape[:2]) channels = [drop(x) for x in np.split(im, self.colordepth, axis=-1)] # compute means means = [mean(channel, labels, segment_ids) for channel in channels] # compute std with catch_warnings(): filterwarnings('ignore') evaluate_std = lambda x: standard_deviation(x, labels, segment_ids) stds = [evaluate_std(channel) for channel in channels] # compile dictionaries self.levels = dict(enumerate(means)) self.std = dict(enumerate(stds))
def getLMRectStats(self, rect): xx1, xx2, yy1, yy2 = self._lmRectToPix(rect) if xx1 is not None: subset = self.image.image()[xx1:xx2, yy1:yy2] subset, mask = self.image.optimalRavel(subset) mmin, mmax = measurements.extrema(subset, labels=mask, index=None if mask is None else False)[:2] mean = measurements.mean(subset, labels=mask, index=None if mask is None else False) std = measurements.standard_deviation(subset, labels=mask, index=None if mask is None else False) ssum = measurements.sum(subset, labels=mask, index=None if mask is None else False) return xx1, xx2, yy1, yy2, mmin, mmax, mean, std, ssum, subset.size return None
def get_superpixel_stds_band(label_array: np.ndarray, band: np.ndarray) -> np.ndarray: """Assume labels in label_array are 0, 1, 2, ..., n Returns array of shape = (len(np.unique(labels)) x 1) """ labels_ = label_array + 1 # scipy wants labels to begin at 1 and transforms to 1, 2, ..., n+1 labels_unique = np.unique(labels_) means = measurements.standard_deviation(band, labels=labels_, index=labels_unique) return means.reshape((-1, 1))
def phot(self, im, showmask=True): # TODO if we switch to astropy.photometry then we can have that # do the work with subpixels properly, but for now they don't # do rms of the bg correctly so we can't use their stuff yet. mask = self.setmask(im) if showmask: cmap1 = pl.matplotlib.colors.LinearSegmentedColormap.from_list( 'my_cmap', ["black", "blue"], 2) cmap1._init() cmap1._lut[:, -1] = pl.array([0, 0.5, 0, 0, 0]) pl.imshow(mask > 0, origin="bottom", interpolation="nearest", cmap=cmap1) from scipy import ndimage from scipy.ndimage import measurements as m nin = len(pl.where(mask == 1)[0]) nout = len(pl.where(mask == 2)[0]) floor = pl.nanmin(im.data) if floor < 0: floor = 0 raw = m.sum(im.data, mask, 1) - floor * nin #bg=m.mean(im.data,mask,2) #bgsig=m.standard_deviation(im.data,mask,2) # from astropy.stats import sigma_clip # clipped = sigma_clip(im.data,sig=3,iters=2) # # http://astropy.readthedocs.org/en/latest/api/astropy.stats.sigma_clip.html#astropy.stats.sigma_clip # # TODO what we really want is to sigma-clip only the BG array/mask # # because including the source will probably just be domimated by the # # source... # bg =m.mean( clipped,mask,2)-floor # bgsig=m.standard_deviation(clipped,mask,2) # sigma_clip doesn't handle nans from scipy import stats def mymode(x): return stats.mode(x, axis=None)[0][0] # pdb.set_trace() # xx=stats.mode(im.data,axis=None) # print xx bg = ndimage.labeled_comprehension(im.data, mask, 2, mymode, "float", 0) - floor # bg = ndimage.labeled_comprehension(im.data,mask,2,pl.mean,"float",0) bgsig = m.standard_deviation(im.data, mask, 2) # assume uncert dominated by BG level. # TODO add sqrt(cts in source) Poisson - need gain or explicit err/pix uncert = bgsig * nin / pl.sqrt(nout) results = raw, bg, raw - bg * nin, uncert f = self.photfactor(im) if f: if self.debug: print "phot factor = ", f results = pl.array(results) * f if self.debug: # print "max=", m.maximum(im.data,mask,1), m.maximum(im.data,mask,2) # print "nin,nout=",nin,nout print "raw, bg, bgsubbed, uncert=", results pdb.set_trace() return results
def label_objects(dataset=None, labels=None, out=None, out_features=None, source=None, return_labels=False): DM = DataModel.instance() log.info('+ Loading data into memory') data = DM.load_slices(dataset) if labels is None: data += 1 labels = set(np.unique(data)) - set([0]) else: data += 1 labels = np.asarray(labels) + 1 obj_labels = [] log.info('+ Extracting individual objects') new_labels = np.zeros(data.shape, np.int32) total_labels = 0 num = 0 for label in labels: mask = (data == label) tmp_data = data.copy() tmp_data[~mask] = 0 tmp_labels, num = splabel(tmp_data, structure=octahedron(1)) mask = (tmp_labels > 0) new_labels[mask] = tmp_labels[mask] + total_labels total_labels += num obj_labels += [label] * num log.info('+ {} Objects found'.format(total_labels)) log.info('+ Saving results') DM.create_empty_dataset(out, DM.data_shape, new_labels.dtype) DM.write_slices(out, new_labels, params=dict(active=True, num_objects=total_labels)) log.info('+ Loading source to memory') data = DM.load_slices(source) objs = new_labels objects = new_labels num_objects = total_labels objlabels = np.arange(1, num_objects+1) log.info('+ Computing Average intensity') feature = measure.mean(data, objs, index=objlabels) DM.create_empty_dataset(out_features[0], (num_objects,), np.float32, check=False) DM.write_dataset(out_features[0], feature, params=dict(active=True)) """log.info('+ Computing Median intensity') objs.shape = -1 data.shape = -1 feature = binned_statistic(objs, data, statistic='median', bins=num_objects+1)[0] feature = feature[objlabels] out_features[1].write_direct(feature) out_features[1].attrs['active'] = True objs.shape = dataset.shape data.shape = dataset.shape""" log.info('+ Computing Sum of intensity') feature = measure.sum(data, objs, index=objlabels) DM.create_empty_dataset(out_features[1], (num_objects,), np.float32, check=False) DM.write_dataset(out_features[1], feature, params=dict(active=True)) log.info('+ Computing Standard Deviation of intensity') feature = measure.standard_deviation(data, objs, index=objlabels) DM.create_empty_dataset(out_features[2], (num_objects,), np.float32, check=False) DM.write_dataset(out_features[2], feature, params=dict(active=True)) log.info('+ Computing Variance of intensity') feature = measure.variance(data, objs, index=objlabels) DM.create_empty_dataset(out_features[3], (num_objects,), np.float32, check=False) DM.write_dataset(out_features[3], feature, params=dict(active=True)) log.info('+ Computing Area') objs.shape = -1 feature = np.bincount(objs, minlength=num_objects+1)[1:] DM.create_empty_dataset(out_features[4], (num_objects,), np.float32, check=False) DM.write_dataset(out_features[4], feature, params=dict(active=True)) DM.create_empty_dataset(out_features[5], (num_objects,), np.float32, check=False) DM.write_dataset(out_features[5], np.log10(feature), params=dict(active=True)) objs.shape = data.shape log.info('+ Computing Bounding Box') obj_windows = measure.find_objects(objs) feature = []; depth = []; height = []; width = []; for w in obj_windows: feature.append((w[0].stop - w[0].start) * (w[1].stop - w[1].start) * (w[2].stop - w[2].start)) depth.append(w[0].stop - w[0].start) height.append(w[1].stop - w[1].start) width.append(w[2].stop - w[2].start) feature = np.asarray(feature, np.float32) DM.create_empty_dataset(out_features[6], (num_objects,), np.float32, check=False) DM.write_dataset(out_features[6], feature, params=dict(active=True)) #depth depth = np.asarray(depth, np.float32) DM.create_empty_dataset(out_features[7], (num_objects,), np.float32, check=False) DM.write_dataset(out_features[7], depth, params=dict(active=True)) # height height = np.asarray(height, np.float32) DM.create_empty_dataset(out_features[8], (num_objects,), np.float32, check=False) DM.write_dataset(out_features[8], height, params=dict(active=True)) # width width = np.asarray(width, np.float32) DM.create_empty_dataset(out_features[9], (num_objects,), np.float32, check=False) DM.write_dataset(out_features[9], width, params=dict(active=True)) # log10 DM.create_empty_dataset(out_features[10], (num_objects,), np.float32, check=False) DM.write_dataset(out_features[10], np.log10(feature), params=dict(active=True)) log.info('+ Computing Oriented Bounding Box') ori_feature = []; ori_depth = []; ori_height = []; ori_width = []; for i, w in enumerate(obj_windows): z, y, x = np.where(objs[w] == i+1) coords = np.c_[z, y, x] if coords.shape[0] >= 3: coords = PCA(n_components=3).fit_transform(coords) cmin, cmax = coords.min(0), coords.max(0) zz, yy, xx = (cmax[0] - cmin[0] + 1, cmax[1] - cmin[1] + 1, cmax[2] - cmin[2] + 1) ori_feature.append(zz * yy * xx) ori_depth.append(zz) ori_height.append(yy) ori_width.append(xx) ori_feature = np.asarray(ori_feature, np.float32) DM.create_empty_dataset(out_features[11], (num_objects,), np.float32, check=False) DM.write_dataset(out_features[11], ori_feature, params=dict(active=True)) #depth ori_depth = np.asarray(ori_depth, np.float32) DM.create_empty_dataset(out_features[12], (num_objects,), np.float32, check=False) DM.write_dataset(out_features[12], ori_depth, params=dict(active=True)) # height ori_height = np.asarray(ori_height, np.float32) DM.create_empty_dataset(out_features[13], (num_objects,), np.float32, check=False) DM.write_dataset(out_features[13], ori_height, params=dict(active=True)) # width ori_width = np.asarray(ori_width, np.float32) DM.create_empty_dataset(out_features[14], (num_objects,), np.float32, check=False) DM.write_dataset(out_features[14], ori_width, params=dict(active=True)) # log10 DM.create_empty_dataset(out_features[15], (num_objects,), np.float32, check=False) DM.write_dataset(out_features[15], np.log10(ori_feature), params=dict(active=True)) log.info('+ Computing Positions') pos = measure.center_of_mass(objs, labels=objs, index=objlabels) pos = np.asarray(pos, dtype=np.float32) DM.create_empty_dataset(out_features[16], (num_objects,), np.float32, check=False) DM.write_dataset(out_features[16], pos[:, 2].copy(), params=dict(active=True)) DM.create_empty_dataset(out_features[17], (num_objects,), np.float32, check=False) DM.write_dataset(out_features[17], pos[:, 1].copy(), params=dict(active=True)) DM.create_empty_dataset(out_features[18], (num_objects,), np.float32, check=False) DM.write_dataset(out_features[18], pos[:, 0].copy(), params=dict(active=True)) if return_labels: return out, total_labels, np.asarray(obj_labels) return out, total_labels