blog detect

yxdragon · yxdragon · commit f22ef8ac70a8 · 2020-02-08T11:29:52.000+08:00
diff --git a/imagepy/menus/Analysis/label_plg.py b/imagepy/menus/Analysis/label_plg.py
@@ -5,6 +5,7 @@
 """
 import numpy as np
 from scipy.ndimage import label, generate_binary_structure
+from skimage.segmentation import find_boundaries
 from imagepy import IPy
 from imagepy.core import ImagePlus
 from imagepy.core.engine import Filter, Simple
@@ -27,7 +28,27 @@ def run(self, ips, imgs, para = None):
             lab, n = label(imgs[i], strc, output = np.int32)
             labels.append(lab)
         IPy.show_img(labels, ips.title+'-label') 
+
+class Boundaries(Simple):
+    title = 'Mark Boundaries'
+    note = ['8-bit', '16-bit','int']    
+    para = {'slice':False, 'mode':'outer', 'con':'4-Connect'}
+    view = [(list, 'con', ['4-Connect','8-Connect'], str, 'Structure', 'connect'),
+            (list, 'mode', ['thick', 'inner', 'outer', 'subpixel'], str, 'mode', ''),
+            (bool, 'slice', 'slice')]
         
+    def run(self, ips, imgs, para = None):
+        if not para['slice']:  imgs = [ips.img]
+        labels = []
+        for i in range(len(imgs)):
+            self.progress(i, len(imgs))
+            con = 1 if para['con']=='4-Connect' else 2
+            bound = find_boundaries(imgs[i], con, para['mode'])
+            bound.dtype = np.uint8
+            bound *= 255
+            labels.append(bound)
+        IPy.show_img(labels, ips.title+'-boundary') 
+
 class Render(Simple):
     title = 'Label Render'
     note = ['8-bit', '16-bit', 'int']    
@@ -36,7 +57,7 @@ class Render(Simple):
             (int, 'colors', (4, 255), 0, 'colors', 'n'),
             (bool, 'back', 'background'),
             (bool, 'slice', 'slice')]
-        
+    
     def run(self, ips, imgs, para = None):
         if not para['slice']:  imgs = [ips.img]
         print(para)
@@ -57,4 +78,4 @@ def run(self, ips, imgs, para = None):
         ips.range = (0, para['colors'])
         IPy.show_ips(ips) 
 
-plgs = [Label, Render]
+plgs = [Label, Boundaries, Render]
diff --git a/imagepy/menus/File/Samples Local/samples_plgs.py b/imagepy/menus/File/Samples Local/samples_plgs.py
@@ -13,14 +13,20 @@ def __init__(self, title):
 
     def run(self, para = None):
         img = self.data()
-        if img.dtype != np.uint8: 
-            img = img.astype(np.uint8)
+        if isinstance(img, tuple):
+            return IPy.show_img(list(img), self.title)
+        if img.dtype == np.bool: 
+            img.dtype = np.uint8
+            img *= 255
         IPy.show_img([img], self.title)
 
     def __call__(self):
         return self
 
-datas = ['face', 'ascent', '-', 'page', 'astronaut', 'horse', 'camera', 
-    'coffee', 'hubble_deep_field', 'coins', 'immunohistochemistry', 'moon']
+datas = ['face', 'ascent', '-', 'binary_blobs', 'brick', 'astronaut', 
+    'camera', 'cell', 'checkerboard', 'chelsea', 'clock', 'coffee', 'coins',
+    'colorwheel', 'grass', 'gravel', 'horse', 'hubble_deep_field', 
+    'immunohistochemistry', 'microaneurysms', 'moon', 'page', 
+    'text', 'retina', 'rocket', 'rough_wall', 'shepp_logan_phantom', 'stereo_motorcycle']
 
 plgs = [i if i=='-' else Data(i) for i in datas]
diff --git a/imagepy/menus/Process/Binary/binary_plgs.py b/imagepy/menus/Process/Binary/binary_plgs.py
@@ -10,6 +10,7 @@
 import numpy as np
 from imagepy.core.engine import Filter
 from skimage.morphology import convex_hull_object
+from skimage.segmentation import clear_border
 
 class Closing(Filter):
     """Closing: derived from imagepy.core.engine.Filter """
@@ -82,13 +83,20 @@ def run(self, ips, snap, img, para = None):
         ndimg.binary_fill_holes(snap, output=img)
         img *= 255
 
+class ClearBorder(Filter):
+    title = 'Clear Border'
+    note = ['8-bit', 'auto_msk', 'auto_snap']
+
+    def run(self, ips, snap, img, para = None):
+        clear_border(img, in_place=True)
+        
+
 class Convex(Filter):
     title = 'Binary ConvexHull'
     note = ['8-bit', 'auto_msk', 'auto_snap']
 
-    #process
     def run(self, ips, snap, img, para = None):
         img[convex_hull_object(snap)] = 255
         
 
-plgs = [Dilation, Erosion, '-', Closing, Opening, '-', Outline, FillHoles, Convex]
+plgs = [Dilation, Erosion, '-', Closing, Opening, '-', Outline, FillHoles, ClearBorder, Convex]
diff --git a/imagepy/menus/Process/Features/__init__.py b/imagepy/menus/Process/Features/__init__.py
@@ -1 +1 @@
-catlog = ['corner_plgs', '-', 'edge_plgs']
+catlog = ['edge_plgs', '-', 'corner_plgs', '-', 'ridge_plgs', '-', 'blob_plgs']
diff --git a/imagepy/menus/Process/Features/blob_plgs.py b/imagepy/menus/Process/Features/blob_plgs.py
@@ -0,0 +1,170 @@
+from imagepy import IPy
+import numpy as np
+from imagepy.core.engine import Simple
+from skimage.feature import blob_dog, blob_doh, blob_log
+from imagepy.core.mark import GeometryMark
+import pandas as pd
+
+class Dog(Simple):
+    title = 'Blob Dog'
+    note = ['all', 'preview']
+    para = {'min_sigma':1, 'max_sigma':50, 'sigma_ratio':1.6, 'threshold':0.1, 
+            'overlap':0.5, 'exclude_border':False, 'showid':True, 'slice':False}
+
+    view = [(int, 'min_sigma', (1, 50), 0, 'min', 'sigma'),
+            (int, 'max_sigma', (1, 50), 0, 'max', 'sigma'),
+            (float, 'sigma_ratio', (1.3, 5), 1, 'ratio', '1.3~5'),
+            (float, 'threshold', (0.1, 10), 1, 'threshold', '0.1~10'),
+            (float, 'overlap', (0, 10), 1, 'overlap', ''),
+            (bool, 'exclude_border', 'exclude border'),
+            (bool, 'showid', 'show id on image'),
+            (bool, 'slice', 'slice')]
+
+    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 = GeometryMark({'type':'circles', 'body':pts[:,[1,0,2]]})
+
+    def cancel(self, ips): ips.mark = None
+
+    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_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)
+            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 = GeometryMark(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)
+        IPy.show_table(df, ips.title+'-dogblob')
+
+class Doh(Simple):
+    title = 'Blob Doh'
+    note = ['all', 'preview']
+    para = {'min_sigma':1, 'max_sigma':30, 'num_sigma':10, 'threshold':0.01, 
+            'overlap':0.5, 'log_scale':False, 'showid':True, 'slice':False}
+
+    view = [(int, 'min_sigma', (1, 50), 0, 'min', 'sigma'),
+            (int, 'max_sigma', (1, 50), 0, 'max', 'sigma'),
+            (int, 'num_sigma', (5, 30), 0, 'num', 'sigma'),
+            (float, 'threshold', (0.01, 1), 2, 'threshold', '0.1~10'),
+            (float, 'overlap', (0, 10), 1, 'overlap', ''),
+            (bool, 'log_scale', 'log scale'),
+            (bool, 'showid', 'show id on image'),
+            (bool, 'slice', 'slice')]
+
+    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 = GeometryMark({'type':'circles', 'body':pts[:,[1,0,2]]})
+
+    def cancel(self, ips): ips.mark = None
+
+    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_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'])
+
+            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 = GeometryMark(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)
+        IPy.show_table(df, ips.title+'-dohblob')
+
+class Log(Simple):
+    title = 'Blob Log'
+    note = ['all', 'preview']
+    para = {'min_sigma':1, 'max_sigma':30, 'num_sigma':10, 'threshold':0.1, 'overlap':0.5, 
+        'log_scale':False, 'showid':True, 'exclude_border':False, 'slice':False}
+
+    view = [(int, 'min_sigma', (1, 50), 0, 'min', 'sigma'),
+            (int, 'max_sigma', (1, 50), 0, 'max', 'sigma'),
+            (int, 'num_sigma', (5, 30), 0, 'num', 'sigma'),
+            (float, 'threshold', (0.01, 1), 2, 'threshold', '0.02~1'),
+            (float, 'overlap', (0, 10), 1, 'overlap', ''),
+            (bool, 'log_scale', 'log scale'),
+            (bool, 'exclude_border', 'exclude border'),
+            (bool, 'showid', 'show id on image'),
+            (bool, 'slice', 'slice')]
+
+    def preview(self, ips, para):
+        grayimg = ips.img if ips.img.ndim==2 else ips.img.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)
+        ips.mark = GeometryMark({'type':'circles', 'body':pts[:,[1,0,2]]})
+
+    def cancel(self, ips): ips.mark = None
+
+    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 = GeometryMark(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)
+        IPy.show_table(df, ips.title+'-dohblob')
+
+plgs = [Dog, Doh, Log]
diff --git a/imagepy/tools/Draw/aibrush.gif b/imagepy/tools/Draw/aibrush.gif
diff --git a/imagepy/tools/Draw/aibrush_tol.py b/imagepy/tools/Draw/aibrush_tol.py
@@ -15,8 +15,8 @@ def fill_normal(img, r, c, color, con, tor):
         msk &= flood(img[:,:,i], (r, c), connectivity=con, tolerance=tor)
     img[msk] = color
 
-def local_brush(img, r, c, color, sigma, msize):
-    lab = felzenszwalb(img, 1, sigma, msize)
+def local_brush(img, back, r, c, color, sigma, msize):
+    lab = felzenszwalb(back, 1, sigma, msize)
     msk = flood(lab, (r, c), connectivity=2)
     img[msk] = color
 
@@ -127,10 +127,11 @@ def global_out_fill(img, r, c, color):
 
 scale and move:             | wheel
 '''
+
 class Plugin(Tool):
-    title = 'AI Painter'
+    title = 'AI Brush'
     
-    para = {'win':48, 'tor':10, 'con':'8-connect', 'ms':20, 'r':2, 'color':(255,0,128)}
+    para = {'win':48, 'tor':10, 'con':'8-connect', 'ms':30, 'r':2, 'color':(255,0,128)}
     view = [(int, 'win', (28, 64), 0, 'window', 'size'),
             ('color', 'color', 'color', 'mark'),
             ('lab', None, '======= Brush ======='),
@@ -244,19 +245,21 @@ def mouse_move(self, ips, x, y, btn, **key):
             sr = (max(0,r-w), min(img.shape[0], r+w))
             sc = (max(0,c-w), min(img.shape[1], c+w))
             r, c = min(r, w), min(c, w)
-            clip = img[slice(*sr), slice(*sc)]
+            backclip = imgclip = img[slice(*sr), slice(*sc)]
+            if not ips.back is None: 
+                backclip = ips.back.img[slice(*sr), slice(*sc)]
 
             if self.status == 'local_pen':
-                local_pen(clip, r, c, self.para['r'], color)
+                local_pen(imgclip, r, c, self.para['r'], color)
             if self.status == 'local_brush':
-                if (clip[r,c] - color).sum()==0: continue
-                local_brush(clip, r, c, color, 0, self.para['ms'])
+                if (imgclip[r,c] - color).sum()==0: continue
+                local_brush(imgclip, backclip, r, c, color, 0, self.para['ms'])
             if self.status == 'local_in':
-                local_in_fill(clip, r, c, self.para['r'], self.pickcolor, color)
+                local_in_fill(imgclip, r, c, self.para['r'], self.pickcolor, color)
             if self.status == 'local_sketch':
-                local_sketch(clip, r, c, self.para['r'], self.pickcolor, color)
+                local_sketch(imgclip, r, c, self.para['r'], self.pickcolor, color)
             if self.status=='local_out':
-                local_out_fill(clip, r, c, self.para['r'], self.pickcolor, color)
+                local_out_fill(imgclip, r, c, self.para['r'], self.pickcolor, color)
 
 
         ips.mark = self.make_mark(x, y)
diff --git a/imagepy/ui/canvasframe.py b/imagepy/ui/canvasframe.py
@@ -132,7 +132,8 @@ def on_idle(self, event):
             self.canvas.set_rg(self.ips.chan_range)
 
             if self.ips.back != None:
-                self.canvas.set_back(self.ips.back.imgs[self.ips.cur])
+                self.ips.back.cur = self.ips.cur
+                self.canvas.set_back(self.ips.back.img)
                 self.canvas.set_cn(self.ips.back.chan, True)
                 self.canvas.set_rg(self.ips.back.chan_range, True)
                 self.canvas.set_lut(self.ips.back.lut, True)

Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-catlog = ['corner_plgs', '-', 'edge_plgs']`
	`1`	`+catlog = ['edge_plgs', '-', 'corner_plgs', '-', 'ridge_plgs', '-', 'blob_plgs']`