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 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 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 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 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 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):
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 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, 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, 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):
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, 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 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):
if not ('prj' 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 = geo_struct.Raster(imgs, ips.data['prj'], ips.data['trans'])
objs = zip(objs.imgs, objs.data['prjs'], objs.data['trans'])
rasters = [geo_struct.Raster([i[0]], i[1], i[2]) for i in objs]
rst = geo_util.rasters2one(rasters, goal, para['step'])
ips = ImagePlus(rst.imgs, ips.title + '-combine')
ips.data['prj'], ips.data['trans'] = goal.prj, goal.m
IPy.show_ips(ips)
def run(self, ips, imgs, para=None):
ips1 = ImageManager.get(para['img1'])
ips2 = ImageManager.get(para['img2'])
detector = CVSURF(hessianThreshold=para['thr'],
nOctaves=para['oct'],
nOctaveLayers=para['int'],
upright=para['upright'],
extended=para['ext'])
kps1, feats1 = detector.detectAndCompute(ips1.img, None)
kps2, feats2 = detector.detectAndCompute(ips2.img, None)
dim, std = {
'None': 0,
'Affine': 6,
'H**o': 8
}[para['trans']], para['std'] / 100.0
style = para['style'] == 'Blue/Yellow'
idx, msk, m = Matcher(dim, std).filter(kps1, feats1, kps2, feats2)
picker1 = Pick(kps1, kps2, idx, msk, ips1, ips2, True, style)
picker2 = Pick(kps1, kps2, idx, msk, ips1, ips2, False, style)
ips1.tool, ips1.mark = picker1, picker1
ips2.tool, ips2.mark = picker2, picker2
if para['log']: self.log(kps1, kps2, msk, m, dim)
ips1.update, ips2.update = True, True
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()
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 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)
feat_dic = {'sqrt': 'sqrt', 'log2': 'log2', 'None': None}
max_depth = None if para['max_depth'] == 0 else para['max_depth']
model = RandomForestClassifier(
n_estimators=para['n_estimators'],
max_features=feat_dic[para['max_features']],
max_depth=max_depth)
model.fit(feat, lab)
get_predict(ori, model, key, out=img)
global model_para
model_para = model, key
def runasyn(self, wb, info, key, para=None, callback=None):
TaskManager.add(self)
for i in para:
if i in key and key[i][0] == 'img':
ips = ImageManager.get(para[i])
para[i] = ips if ips is None else ips.img
if i in key and key[i][0] == 'tab':
tps = TableManager.get(para[i])
para[i] = tps if tps is None else tps.data
start = time()
xlreport.fill_value(wb, info, para)
wb.save(para['path'])
IPy.set_info('%s: cost %.3fs' % (self.title, time() - start))
TaskManager.remove(self)
if callback != None: callback()
def run(self, ips, imgs, para=None):
dis = ImageManager.get(para['dis']).imgs
balls, ids, rs, graph = [], [], [], ips.data
for idx in graph.nodes():
ids.append(idx)
balls.append(graph.node[idx]['o'])
xs, ys, zs = [], [], []
v1s, v2s = [], []
for (s, e) in graph.edges():
eds = graph[s][e]
st, ed = graph.node[s]['o'], graph.node[e]['o']
v1s.append(st)
v2s.append(ed)
for i in eds:
pts = eds[i]['pts']
xs.append(pts[:, 0])
ys.append(pts[:, 1])
zs.append(pts[:, 2])
rs1 = dis[list(np.array(v1s).astype(np.int16).T)]
rs2 = dis[list(np.array(v2s).astype(np.int16).T)]
rs1 = list(np.clip(rs1, 2, 1e4) * 0.5)
rs2 = list(np.clip(rs2, 2, 1e4) * 0.5)
rs = dis[list(np.array(balls).astype(np.int16).T)]
rs = list(np.clip(rs, 2, 1e4))
cs = tuple(np.array(para['ncolor']) / 255.0)
vts, fs, ns, cs = myvi.build_balls(balls, rs, cs)
self.frame.viewer.add_surf_asyn('balls', vts, fs, ns, cs)
meansize = sum(rs) / len(rs)
vts, fs, pos, h, color = myvi.build_marks(['ID:%s' % i for i in ids],
balls, rs, meansize,
(1, 1, 1))
self.frame.viewer.add_mark_asyn('txt', vts, fs, pos, h, color)
css = tuple(np.array(para['lcolor']) / 255.0)
vts, fs, ns, cs = myvi.build_lines(xs, ys, zs, css)
self.frame.viewer.add_surf_asyn('paths', vts, fs, ns, cs, mode='grid')
#vts, fs, ns, cs = myvi.build_lines(lxs, lys, lzs, (0,1,0))
vts, fs, ns, cs = myvi.build_arrows(v1s, v2s, rs1, rs2, 0, 0, css)
self.frame.viewer.add_surf_asyn('lines', vts, fs, ns, cs)
self.frame.Raise()
self.frame = None