def note_frame_test():
frame = VectorNoteFrame(None)
canvas = frame.add_canvas()
canvas.set_shp(mark2shp(layer))
canvas = frame.add_canvas()
canvas.set_shp(mark2shp(ellipses))
frame.Show()
def note_test():
frame = wx.Frame(None)
notebook = VectorNoteBook(frame)
canvas = notebook.add_canvas()
canvas.set_shp(mark2shp(layer))
canvas = notebook.add_canvas()
canvas.set_shp(mark2shp(ellipses))
frame.Show()
def mouse_down(self, ips, x, y, btn, **key):
if btn == 1:
ips.snapshot()
self.status = 1
self.line['body'] = [(x, y)]
ips.mark = mark2shp(self.line)
ips.update()
def graph_mark(graph):
ids = graph.nodes()
pts = [graph.nodes[i]['o'] for i in ids]
pts = {'type': 'points', 'body': [(i[1], i[0]) for i in pts]}
txt = [(a, b, str(c)) for (a, b), c in zip(pts['body'], ids)]
txt = {'type': 'texts', 'body': txt}
return mark2shp({'type': 'layer', 'body': [pts, txt]})
def run(self, ips, imgs, para = None):
if not para['slice']:imgs = [ips.img]
k = ips.unit[0]
titles = ['Slice', 'ID'][0 if para['slice'] else 1:] + ['Center-X','Center-Y', 'N', 'Neighbors']
buf = imgs[0].astype(np.uint32)
data, mark = [], {'type':'layers', 'body':{}}
for i in range(len(imgs)):
if para['labled']: buf = imgs[i]
else: label(imgs[i], generate_binary_structure(2, 1), output=buf)
conarr = connect_graph(buf, 1 if para['con']=='4-connect' else 2, not self.para['nozero'])
conmap = mapidx(conarr)
ls = regionprops(buf)
dt = [[i]*len(ls), list(range(1,1+len(ls)))]
if not para['slice']:dt = dt[1:]
layer = {'type':'layer', 'body':[]}
texts = [(i.centroid[::-1])+('id=%d'%i.label,) for i in ls]
lines = [(ls[i-1].centroid[::-1], ls[j-1].centroid[::-1]) for i,j in conarr]
layer['body'].append({'type':'texts', 'body':texts})
layer['body'].append({'type':'lines', 'body':lines})
mark['body'][i] = layer
dt.append([round(i.centroid[1]*k,1) for i in ls])
dt.append([round(i.centroid[0]*k,1) for i in ls])
neibs = [conmap[i.label] if i.label in conmap else [] for i in ls]
dt.extend([[len(i) for i in neibs], neibs])
data.extend(list(zip(*dt)))
ips.mark = mark2shp(mark)
self.app.show_table(pd.DataFrame(data, columns=titles), ips.title+'-region')
def run(self, ips, imgs, para=None):
pts = (np.random.rand(200) * 512).reshape((100, 2))
ips.mark = mark2shp({
'type': 'points',
'color': (255, 0, 0),
'lw': 1,
'body': pts
})
def run(self, ips, snap, img, para=None):
intenimg = self.app.get_img(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]
red_pts = {
'type': 'points',
'body': xy[::-1].T[~msk],
'color': (255, 0, 0)
}
green_pts = {
'type': 'points',
'body': xy[::-1].T[msk],
'color': (0, 255, 0)
}
self.app.get_img(para['inten']).mark = mark2shp({
'type':
'layer',
'body': [red_pts, green_pts]
})
self.app.get_img(para['inten']).update()
def preview(self, ips, para):
grayimg = ips.img if ips.img.ndim == 2 else ips.img.mean(axis=-1)
grayimg /= grayimg.max()
pts = blob_doh(grayimg,
min_sigma=para['min_sigma'],
max_sigma=para['max_sigma'],
num_sigma=para['num_sigma'],
threshold=para['threshold'],
overlap=para['overlap'],
log_scale=para['log_scale'])
ips.mark = mark2shp({'type': 'circles', 'body': pts[:, [1, 0, 2]]})
def preview(self, ips, para):
grayimg = ips.img if ips.img.ndim == 2 else ips.img.mean(axis=-1)
grayimg /= grayimg.max()
pts = blob_dog(grayimg,
min_sigma=para['min_sigma'],
max_sigma=para['max_sigma'],
sigma_ratio=para['sigma_ratio'],
threshold=para['threshold'],
overlap=para['overlap'],
exclude_border=para['exclude_border'])
pts[:, 2] *= np.sqrt(2)
ips.mark = mark2shp({'type': 'circles', 'body': pts[:, [1, 0, 2]]})
def run(self, ips, imgs, para=None):
if not para['slice']: imgs = [ips.img]
data, sid, fid, mark = [], [], [], {'type': 'layers', 'body': {}}
for i in range(len(imgs)):
grayimg = imgs[i] if imgs[i].ndim == 2 else imgs[i].mean(axis=-1)
grayimg /= grayimg.max()
pts = blob_log(grayimg,
min_sigma=para['min_sigma'],
max_sigma=para['max_sigma'],
num_sigma=para['num_sigma'],
threshold=para['threshold'],
overlap=para['overlap'],
log_scale=para['log_scale'],
exclude_border=para['exclude_border'])
pts[:, 2] *= np.sqrt(2)
sid.extend([i] * len(pts))
fid.extend(range(1, len(pts) + 1))
data.append(pts)
layer = {
'type': 'layer',
'body': [{
'type': 'circles',
'body': pts[:, [1, 0, 2]]
}]
}
if para['showid']:
layer['body'].append({
'type':
'texts',
'body': [(x, y, 'id=%d' % i)
for (x, y), i in zip(pts[:, 1::-1], fid)]
})
mark['body'][i] = layer
ips.mark = mark2shp(mark)
df = pd.DataFrame(np.vstack(data) * ips.unit[0],
columns=['X', 'Y', 'R'])
df.insert(0, 'FID', fid)
if para['slice']: df.insert(o, 'SliceID', sid)
self.app.show_table(df, ips.title + '-dohblob')
def run(self, ips, imgs, para = None):
titles = ['SliceID', 'X', 'Y', 'Value']
k, u = ips.unit
if not para['slice']:
imgs = [ips.img]
titles = titles[1:]
data = []
pts = np.vstack([i.body.reshape(-1,2) for i in ips.roi.body])
layers = {'type':'layers', 'body':{}}
for n in range(len(imgs)):
xs, ys = (pts.T[:2]*k).round(2).astype(np.int16)
vs = imgs[n][ys, xs]
cont = ([n]*len(vs), xs, ys, vs.round(2))
if not para['slice']: cont = cont[1:]
data.extend(zip(*cont))
if para['buf']:
layers['body'][n] = {'type':'circles', 'body':list(zip(xs, ys, vs.round(2)))}
self.progress(n, len(imgs))
self.app.show_table(pd.DataFrame(data, columns=titles), ips.title+'-points')
if para['buf']:ips.mark = mark2shp(layers)
import sys
sys.path.append('../../')
from sciapp.object import mark2shp, Layer, json2shp
from sciapp.action import PointEditor, LineEditor, PolygonEditor, \
RectangleEditor, EllipseEditor, FreeLineEditor, FreePolygonEditor, BaseEditor
from sciwx.canvas import VectorFrame
from sciwx.plugins.filters import Gaussian
import wx
ellipse = {'type':'ellipse', 'body':(100,100,100,-50,1)}
rectangles = {'type':'rectangles', 'body':[(100,100,80,50),(200,200,80,100)]}
layer = {'type':'layer', 'num':-1, 'color':(0,0,255), 'fill':False, 'body':[rectangles, ellipse]}
if __name__ == '__main__':
app = wx.App()
frame = VectorFrame(None)
frame.set_shp(mark2shp(layer))
bar = frame.add_toolbar()
bar.add_tool('E', BaseEditor)
bar.add_tool('P', PointEditor)
bar.add_tool('L', LineEditor)
bar.add_tool('M', PolygonEditor)
bar.add_tool('R', RectangleEditor)
bar.add_tool('O', EllipseEditor)
bar.add_tool('S', FreeLineEditor)
bar.add_tool('&', FreePolygonEditor)
frame.Show()
app.MainLoop()
img.SaveFile(path, wx.BITMAP_TYPE_PNG)
def __del__(self):
# self.img = self.back = None
print('========== canvas del')
if __name__=='__main__':
from skimage.data import astronaut, camera
import matplotlib.pyplot as plt
app = wx.App()
frame = wx.Frame(None, title='Canvas')
canvas = Canvas(frame, autofit=False, ingrade=True, up=True)
line = mark2shp({'type':'polygon', 'color':(255,0,0), 'lstyle':'o', 'fill':True,
'body':[[(0,0),(1000,1000),(2000,0), (0,0)],
[(0,0),(100,100),(200,0),(0,0)],
[(100,400),(300,100),(300,600),(100,400)]]})
layer = Layer()
layer.color = (0,0,0)
layer.lw = 1
import json
import geonumpy.io as gio
shp = gio.read_shp('C:/Users/54631/Documents/projects/huangqu/demo/shape/province.shp')
feats = json.loads(shp.to_json())['features']
for i in feats:
shp = json2shp(i['geometry'])
layer.body.append(shp)
canvas.marks.append(layer)
'''
def run(self, ips, imgs, para=None):
inten = self.app.get_img(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.uint32)
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)):
if para['labeled']:
n, buf[:] = msks[i].max(), msks[i]
else:
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(buf, 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[0].start, 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)))
self.app.show_table(pd.DataFrame(data, columns=titles),
inten.title + '-pixels')
inten.mark = mark2shp(mark)
inten.update()
def frame_test():
frame = VectorFrame(None)
frame.set_shp(mark2shp(layer))
frame.Show()
def run(self, ips, imgs, para=None):
ips.roi = mark2shp(self.app.manager('roi').get(name=para['name']))
def run(self, ips, imgs, para=None):
obj = mark2shp(
self.app.manager('roi').get(name=para['name'])).to_geom()
roi = geom_flatten(ips.roi.to_geom())
ips.roi = ROI(geom2shp(geom_flatten(roi.symmetric_difference(obj))))
def run(self, ips, imgs, para=None):
obj = mark2shp(
self.app.manager('roi').get(name=para['name'])).to_geom()
roi = geom_flatten(ips.roi.to_geom())
ips.roi = ROI(geom2shp(geom_flatten(roi.intersection(obj))))
def run(self, ips, imgs, para=None):
with open(para['path']) as f:
ips.roi = ROI(mark2shp(json.loads(f.read())))
def mark_test(mark):
frame = wx.Frame(None, title='gray test')
canvas = Canvas(frame, autofit=False, up=True)
canvas.set_shp(mark2shp(mark))
frame.Show()
def UpdateData(self):
names = self.app.manager('roi').gets('name')
objs = self.app.manager('roi').gets('obj')
types = [ROI(mark2shp(i)).roitype for i in objs]
self.lst_rois.SetValue(list(zip(names, types)))
def mouse_move(self, ips, x, y, btn, **key):
if self.status == 1:
self.line['body'].append((x, y))
ips.mark = mark2shp(self.line)
ips.update()
def run(self, ips, imgs, para = None):
if not para['slice']:imgs = [ips.img]
k = ips.unit[0]
titles = ['Slice', 'ID'][0 if para['slice'] else 1:]
if para['center']:titles.extend(['Center-X','Center-Y'])
if para['area']:titles.append('Area')
if para['l']:titles.append('Perimeter')
if para['extent']:titles.extend(['Min-Y','Min-X','Max-Y','Max-X'])
if para['ed']:titles.extend(['Diameter'])
if para['ca']:titles.extend(['ConvexArea'])
if para['holes']:titles.extend(['Holes'])
if para['fa']:titles.extend(['FilledArea'])
if para['solid']:titles.extend(['Solidity'])
if para['cov']:titles.extend(['Major','Minor','Ori'])
buf = imgs[0].astype(np.uint32)
data, mark = [], {'type':'layers', 'body':{}}
strc = generate_binary_structure(2, 1 if para['con']=='4-connect' else 2)
for i in range(len(imgs)):
label(imgs[i], strc, output=buf)
ls = regionprops(buf)
dt = [[i]*len(ls), list(range(len(ls)))]
if not para['slice']:dt = dt[1:]
layer = {'type':'layer', 'body':[]}
texts = [(i.centroid[::-1])+('id=%d'%n,) for i,n in zip(ls,range(len(ls)))]
layer['body'].append({'type':'texts', 'body':texts})
if para['cov']:
ellips = [i.centroid[::-1] + (i.major_axis_length/2,i.minor_axis_length/2, i.orientation+np.pi/2) for i in ls]
layer['body'].append({'type':'ellipses', 'body':ellips})
print(i,i,i,i,i)
if len(ls)>0: mark['body'][i] = layer
if para['center']:
dt.append([round(i.centroid[1]*k,1) for i in ls])
dt.append([round(i.centroid[0]*k,1) for i in ls])
if para['area']:
dt.append([i.area*k**2 for i in ls])
if para['l']:
dt.append([round(i.perimeter*k,1) for i in ls])
if para['extent']:
for j in (0,1,2,3):
dt.append([i.bbox[j]*k for i in ls])
if para['ed']:
dt.append([round(i.equivalent_diameter*k, 1) for i in ls])
if para['ca']:
dt.append([i.convex_area*k**2 for i in ls])
if para['holes']:
dt.append([1-i.euler_number for i in ls])
if para['fa']:
dt.append([i.filled_area*k**2 for i in ls])
if para['solid']:
dt.append([round(i.solidity, 2) for i in ls])
if para['cov']:
dt.append([round(i.major_axis_length*k, 1) for i in ls])
dt.append([round(i.minor_axis_length*k, 1) for i in ls])
dt.append([round(i.orientation*k, 1) for i in ls])
data.extend(list(zip(*dt)))
ips.mark = mark2shp(mark if para['slice'] else mark['body'][0])
self.app.show_table(pd.DataFrame(data, columns=titles), ips.title+'-region')
