def run(self, ips, snap, img, para = None): intenimg = ImageManager.get(para['inten']).img strc = ndimage.generate_binary_structure(2, 1 if para['con']=='4-connect' else 2) buf, n = ndimage.label(snap, strc, output=np.uint32) index = range(1, n+1) idx = (np.ones(n+1)*para['front']).astype(np.uint8) msk = np.ones(n, dtype=np.bool) if para['mean']>0: msk *= ndimage.mean(intenimg, buf, index)>=para['mean'] if para['mean']<0: msk *= ndimage.mean(intenimg, buf, index)<-para['mean'] if para['max']>0: msk *= ndimage.maximum(intenimg, buf, index)>=para['max'] if para['max']<0: msk *= ndimage.maximum(intenimg, buf, index)<-para['max'] if para['min']>0: msk *= ndimage.minimum(intenimg, buf, index)>=para['min'] if para['min']<0: msk *= ndimage.minimum(intenimg, buf, index)<-para['min'] if para['sum']>0: msk *= ndimage.sum(intenimg, buf, index)>=para['sum'] if para['sum']<0: msk *= ndimage.sum(intenimg, buf, index)<-para['sum'] if para['std']>0: msk *= ndimage.standard_deviation(intenimg, buf, index)>=para['std'] if para['std']<0: msk *= ndimage.standard_deviation(intenimg, buf, index)<-para['std'] xy = ndimage.center_of_mass(intenimg, buf, index) xy = np.array(xy).round(2).T idx[1:][~msk] = para['back'] idx[0] = 0 img[:] = idx[buf] ImageManager.get(para['inten']).mark = RGMark((xy.T, msk)) ImageManager.get(para['inten']).update = True
def on_setback(self, event): name = self.com_back.GetValue() if name is None: return ImageManager.get().back = ImageManager.get(name) #curwin = WindowsManager.get() #curwin.set_back(ImageManager.get(name)) ImageManager.get().update()
def on_back(self, event): self.com_back.SetItems(['None'] + ImageManager.get_titles()) cur = WindowsManager.get() if not cur is None: cur = cur.back if not cur is None: cur = cur.title self.com_back.SetValue(str(cur)) modes = ['set', 'max', 'min', 'msk', 0.2, 0.4, 0.5, 0.6, 0.8] ips = ImageManager.get() if ips is None: self.com_mode.Select(0) else: self.com_mode.Select(modes.index(ips.chan_mode))
def run(self, ips, imgs, para=None): r, g, b = [], [], [] for i, n in zip(imgs, list(range(ips.get_nslices()))): for c, ci in zip((r, g, b), (0, 1, 2)): if self.para['copy']: c.append(i[:, :, ci].copy()) else: c.append(i[:, :, ci]) self.progress(i, n) for im, tl in zip([r, g, b], ['red', 'green', 'blue']): IPy.show_img(im, ips.title + '-' + tl) if self.para['destory']: ImageManager.close(ips.title)
def run(self, ips, imgs, para=None): ips1 = ImageManager.get(para['b1']) ips2 = ImageManager.get(para['b2']) rs1 = zip(ips1.imgs, ips1.data['prjs'], ips1.data['trans']) rs2 = zip(ips2.imgs, ips2.data['prjs'], ips2.data['trans']) rsts = [] for r1, r2 in zip(rs1, rs2): rsts.append(geo_indicate.count_ndvi(r1, r2)) imgs, prjs, trans = zip(*rsts) ips = ImagePlus(imgs, ips1.title + '-ndvi') ips.data['prjs'], ips.data['trans'] = prjs, trans IPy.show_ips(ips)
def run(self, ips, imgs, para=None): if para['kill']: ips.backimg = None else: print(ImageManager.get()) img = ImageManager.get(para['img']).img if img.dtype != np.uint8 or img.shape[:2] != ips.img.shape[:2]: IPy.alert( 'a background image must be 8-bit and with the same size') return ips.backimg = img ips.backmode = (para['k'], para['op']) ips.update()
def run(self, ips, imgs, para=None): ips1 = ImageManager.get(para['b1']) ips2 = ImageManager.get(para['b2']) imgs = [] for i in range(len(ips1.imgs)): b2, b1 = ips2.imgs[i], ips1.imgs[i] b1 = np.clip(b1, 1, 1e8, out=b1) b2 = np.clip(b2, 1, 1e8, out=b2) ndvi = (((b2 - b1) / (b2 + b1) + 1) / 2 * 255 + 0.5).astype( np.uint8) imgs.append(ndvi) ips = ImagePlus(imgs, ips1.title + '-ndvi') ips.data = ips1.data IPy.show_ips(ips)
def run(self, ips, imgs, para=None): if not para['stack']: imgs, labs = [ips.img], [ImageManager.get(para['lab']).img] else: labs = ImageManager.get(para['lab']).imgs if len(imgs) != len(labs): labs = [ImageManager.get(para['lab']).img] * len(imgs) for i in range(len(imgs)): img, lab = imgs[i], labs[i] connect = ['4-connected', '8-connected'].index(para['connect']) + 1 g = graph.rag_mean_color(img, lab, connect, para['mode'], para['sigma']) lab = graph.cut_normalized(lab, g, para['thresh'], para['num']) img[:] = color.label2rgb(lab, img, kind='avg') self.progress(i, len(imgs))
def run(self, ips, imgs, para=None): ndvi = ImageManager.get(para['ndvi']) lst = ImageManager.get(para['lst']) lab = ImageManager.get(para['lab']) area = ImageManager.get(para['area']) ndvi = list(zip(ndvi.imgs, ndvi.data['prjs'], ndvi.data['trans']))[0] lst = list(zip(lst.imgs, lst.data['prjs'], lst.data['trans']))[0] lab = list(zip(lab.imgs, lab.data['prjs'], lab.data['trans']))[0] area = list(zip(area.imgs, area.data['prjs'], area.data['trans']))[0] df = TableManager.get(para['df']).data rst = wheat.get_grade(ndvi, lst, lab, area, df) ips = ImagePlus([rst[0]], 'tiao xiu bing') ips.data['prjs'], ips.data['trans'] = [rst[1]], [rst[2]] IPy.show_ips(ips)
def preview(self, ips, para): lab = ImageManager.get(para['lab']).img connect = ['4-connected', '8-connected'].index(para['connect']) + 1 g = graph.rag_mean_color(ips.snap, lab, connect, para['mode'], para['sigma']) lab = graph.cut_normalized(lab, g, para['thresh'], para['num']) ips.img[:] = color.label2rgb(lab, ips.snap, kind='avg')
def run(self, ips, imgs, para=None): ips2 = ImageManager.get(para['temp']) nimg = ips.img * 0 nimg[ips.img > 0] += 80 nimg[ips2.img > 0] += 160 ips = ImagePlus([nimg], ips.title + '-diff-' + ips2.title) IPy.show_ips(ips)
def load(self, ips): titles = ImageManager.get_titles() self.para['img1'] = titles[0] self.para['img2'] = titles[0] Match.view = [(list, 'img1', titles, str, 'template', ''), (list, 'img2', titles, str, 'object', '')] return True
def run(self, para=None): if para['name'] == 'All': for i in ImageManager.get_titles(): WindowsManager.get(i).close() else: print(WindowsManager.get(para['name'])) WindowsManager.get(para['name']).close()
def run(self, tps, snap, data, para=None): ips = ImageManager.get(para['paper']) ips.snapshot() color = para['value'] if para['color'] == (0, 0, 0) else para['color'] if para['field'] != 'None': color = para['field'] gdraw.draw_line(ips.img, data, color, para['lw']) ips.update()
def on_items(self, event): items = ['No Background Image'] + ImageManager.get_titles() self.com_back.SetItems(items) if self.com_back.GetValue() in items: self.com_back.Select(items.index(self.com_back.GetValue())) else: self.com_back.Select(0)
def run(self, ips, imgs, para = None): inten = ImageManager.get(para['inten']) if not para['slice']: imgs = [inten.img] msks = [ips.img] else: msks = ips.imgs imgs = inten.imgs if len(msks)==1: msks *= len(imgs) buf = imgs[0].astype(np.uint16) strc = ndimage.generate_binary_structure(2, 1 if para['con']=='4-connect' else 2) idct = ['Max','Min','Mean','Variance','Standard','Sum'] key = {'Max':'max','Min':'min','Mean':'mean', 'Variance':'var','Standard':'std','Sum':'sum'} idct = [i for i in idct if para[key[i]]] titles = ['Slice', 'ID'][0 if para['slice'] else 1:] if para['center']: titles.extend(['Center-X','Center-Y']) if para['extent']: titles.extend(['Min-Y','Min-X','Max-Y','Max-X']) titles.extend(idct) k = ips.unit[0] data, mark = [],{'type':'layers', 'body':{}} # data,mark=[],[] for i in range(len(imgs)): n = ndimage.label(msks[i], strc, output=buf) index = range(1, n+1) dt = [] if para['slice']:dt.append([i]*n) dt.append(range(n)) xy = ndimage.center_of_mass(imgs[i], buf, index) xy = np.array(xy).round(2).T if para['center']:dt.extend([xy[1]*k, xy[0]*k]) boxs = [None] * n if para['extent']: boxs = ndimage.find_objects(buf) boxs = [( i[1].start+(i[1].stop-i[1].start)/2, i[0].start+(i[0].stop-i[0].start)/2, i[1].stop-i[1].start,i[0].stop-i[0].start) for i in boxs] for j in (0,1,2,3): dt.append([i[j]*k for i in boxs]) if para['max']:dt.append(ndimage.maximum(imgs[i], buf, index).round(2)) if para['min']:dt.append(ndimage.minimum(imgs[i], buf, index).round(2)) if para['mean']:dt.append(ndimage.mean(imgs[i], buf, index).round(2)) if para['var']:dt.append(ndimage.variance(imgs[i], buf, index).round(2)) if para['std']:dt.append(ndimage.standard_deviation(imgs[i], buf, index).round(2)) if para['sum']:dt.append(ndimage.sum(imgs[i], buf, index).round(2)) layer = {'type':'layer', 'body':[]} xy=np.int0(xy).T texts = [(i[1],i[0])+('id=%d'%n,) for i,n in zip(xy,range(len(xy)))] layer['body'].append({'type':'texts', 'body':texts}) if para['extent']: layer['body'].append({'type':'rectangles', 'body':boxs}) mark['body'][i] = layer data.extend(list(zip(*dt))) IPy.show_table(pd.DataFrame(data, columns=titles), inten.title+'-region statistic') inten.mark = GeometryMark(mark) inten.update = True
def run(self, ips, imgs, para=None): ips1 = ImageManager.get(para['img1']) ips2 = ImageManager.get(para['img2']) ips2.snapshot() img = ips1.img imgs = ips2.imgs sl1, sl2 = ips1.get_nslices(), ips2.get_nslices() cn1, cn2 = ips1.get_nchannels(), ips2.get_nchannels() if not (ips1.img.dtype == np.uint8 and ips2.img.dtype == np.uint8): IPy.alert('Two image must be type of 8-bit or rgb!') return for i in range(sl2): self.progress(i, sl2) match(img, imgs[i]) ips2.update = 'pix'
def on_mode(self, event): ips = ImageManager.get() if ips is None: return if self.chk_hide.GetValue(): ips.chan_mode = 0.0 return ips.update() modes = ['set', 'max', 'min', 'msk', 0.2, 0.4, 0.5, 0.6, 0.8] ips.chan_mode = modes[self.com_mode.GetSelection()] ips.update()
def run(self, tps, snap, data, para=None): img = ImageManager.get(para['temp']).img chans = list(data['channels'][0]) chans = [chans.index(i) for i in para['chans']] nimg = gmt.match_idx(data, img, step=para['step'], order=para['order'], chan=chans) IPy.show_img([nimg], tps.title + '-match')
def run(self, ips, imgs, para=None): ipst = ImageManager.get(para['temp']) chans = ['Channel %s' % i for i in range(ips.get_nchannels())] chans = [chans.index(i) for i in para['chans']] order = {'nearest': 0, 'linear': 1}[para['order']] rst = gmt.match_multi(imgs, ipst.img, chans, step=para['step'], order=order) ipst.update()
def run(self, ips, snap, img, para=None): key = {'chans': None, 'grade': para['grade'], 'w': para['w']} key['items'] = [i for i in ['ori', 'blr', 'sob', 'eig'] if para[i]] ori = ImageManager.get(para['img']).img feat, lab, key = get_feature(ori, snap, key) model = BaggingClassifier(n_estimators=para['n_estimators'], max_features=para['max_features']) model.fit(feat, lab) get_predict(ori, model, key, out=img) global model_para model_para = model, key
def run(self, tps, snap, data, para=None): ipst = ImageManager.get(para['temp']) chans = list(data['channels'][0]) chans = [chans.index(i) for i in para['chans']] order = {'nearest': 0, 'linear': 1}[para['order']] rst = gmt.match_idx(data, ipst.img, chans, step=para['step'], order=order) ipst.update()
def run(self, ips, imgs, para=None): if not para['stack']: imgs, labs = [ips.img], [ImageManager.get(para['lab']).img] else: labs = ImageManager.get(para['lab']).imgs if len(imgs) != len(labs): labs = [ImageManager.get(para['lab']).img] * len(imgs) for i in range(len(imgs)): img, lab = imgs[i], labs[i] connect = ['4-connected', '8-connected'].index(para['connect']) + 1 g = graph.rag_mean_color(img, lab, connect, para['mode'], para['sigma']) lab = graph.merge_hierarchical(lab, g, thresh=para['thresh'], rag_copy=False, in_place_merge=True, merge_func=merge_mean_color, weight_func=_weight_mean_color) img[:] = color.label2rgb(lab, img, kind='avg') self.progress(i, len(imgs))
def run(self, ips, imgs, para=None): idx = ['red', 'green', 'blue'] imr, img, imb = [ImageManager.get(para[i]) for i in idx] sr, sg, sb = [i.get_nslices() for i in [imr, img, imb]] if imr.imgtype!='8-bit' or img.imgtype!='8-bit' or imb.imgtype!='8-bit' or \ imr.size!=img.size or img.size!=imb.size or sr!=sg or sg!=sb: IPy.alert( 'three images must be 8-bit image, with the same size and slices!' ) return rgbs = [] w, h = imr.size for i in range(sr): self.progress(i, sr) rgbs.append(self.trans(imr.imgs[i], img.imgs[i], imb.imgs[i])) IPy.show_img(rgbs, self.titles()[0]) if self.para['destory']: for title in [para[i] for i in idx]: ImageManager.close(title)
def preview(self, ips, para): lab = ImageManager.get(para['lab']).img connect = ['4-connected', '8-connected'].index(para['connect']) + 1 g = graph.rag_mean_color(ips.snap, lab, connect, para['mode'], para['sigma']) lab = graph.merge_hierarchical(lab, g, thresh=para['thresh'], rag_copy=False, in_place_merge=True, merge_func=merge_mean_color, weight_func=_weight_mean_color) ips.img[:] = color.label2rgb(lab, ips.snap, kind='avg')
def run(self, ips, imgs, para=None): if not ('prjs' in ips.data and 'trans' in ips.data): return IPy.alert('need projection and transform matrix!') objs = ImageManager.get(para['fragments']) if not ('prjs' in objs.data and 'trans' in objs.data): return IPy.alert('need projection and transform matrix!') goal = (imgs[0], ips.data['prjs'][0], ips.data['trans'][0]) rasters = zip(objs.imgs, objs.data['prjs'], objs.data['trans']) rst = geo_util.rasters2des(list(rasters), goal, para['step']) ips = ImagePlus([rst[0]], ips.title + '-combine') ips.data['prjs'], ips.data['trans'] = [rst[1]], [rst[2]] IPy.show_ips(ips)
def run(self, ips, imgs, para=None): conts = find_contours(ips.img, 1e-6, fully_connected='low', positive_orientation='low') areas = [Polygon(i).area for i in conts] areas = np.array(areas) img = ImageManager.get(para['background']).get_subimg() wx.CallAfter(pub.sendMessage, 'showice', img=img, ices=conts, areas=areas, para=para)
def run(self, ips, imgs, para=None): ips1 = ImageManager.get(para['img1']) ips2 = ImageManager.get(para['img2']) ips1.snapshot() sl1, sl2 = ips1.get_nslices(), ips2.get_nslices() cn1, cn2 = ips1.get_nchannels(), ips2.get_nchannels() if ips1.dtype != ips2.dtype: IPy.alert('Two stack must be equal dtype!') return elif sl1 > 1 and sl2 > 1 and sl1 != sl2: IPy.alert('Two stack must have equal slices!') return elif cn1 > 1 and cn2 > 1 and cn1 != cn2: IPy.alert('Two stack must have equal channels!') return w, h = ips1.size, ips2.size w, h = min(w[0], h[0]), min(w[1], h[1]) if sl1 == 1: bliter.blit(ips1.get_subimg(), ips2.get_subimg(), mode=para['op']) elif sl1 > 1 and sl2 == 1: for i in range(sl1): self.progress(i, sl1) ss1, se1 = ips1.get_rect() bliter.blit(ips1.imgs[i][ss1, se1], ips2.get_subimg(), mode=para['op']) elif sl1 > 1 and sl2 > 1: for i in range(sl1): self.progress(i, sl1) ss1, se1 = ips1.get_rect() ss2, se2 = ips2.get_rect() bliter.blit(ips1.imgs[i][ss1, se1], ips2.imgs[i][ss2, se2], mode=para['op']) ips1.update = 'pix'
def run(self, ips, imgs, para=None, preview=False): if len(ips.imgs) == 1: ips.img[:] = ips.snap key = {'chans': None, 'grade': para['grade'], 'w': para['w']} key['items'] = [i for i in ['ori', 'blr', 'sob', 'eig'] if para[i]] slir, slic = ips.get_rect() labs = [i[slir, slic] for i in imgs] ori = ImageManager.get(para['img']).imgs if len(imgs) == 1: ori = [ImageManager.get(para['img']).img] oris = [i[slir, slic] for i in ori] IPy.set_info('extract features...') feat, lab, key = feature.get_feature(oris, labs, key, callback=self.progress) IPy.set_info('training data...') self.progress(None, 1) model = self.classify(para) model.fit(feat, lab) IPy.set_info('predict data...') if preview: return feature.get_predict(oris, model, key, labs, callback=self.progress) if len(imgs) == 1: ips.swap() outs = feature.get_predict(oris, model, key, callback=self.progress) nips = ImagePlus(outs, ips.title + 'rst') nips.range, nips.lut = ips.range, ips.lut nips.back, nips.chan_mode = ips.back, 0.4 IPy.show_ips(nips) global model_para model_para = model, key
def on_cmapsel(self, event): key = self.cmapsel.GetValue() lut = ColorManager.get_lut(key) n = self.spn_num.GetValue() + 1 idx = np.linspace(0, 255, n).astype(int) cs = list(lut[idx]) + [(128, 128, 128)] * (16 - n) for btn, c in zip(self.btns, cs): btn.SetBackgroundColour(c) ips = ImageManager.get() if ips is None: return newlut = lut * 0 newlut[:n] = lut[idx] ips.lut = newlut ips.update()