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()
