compleximage view support

Author: yxdragon

imagepy/__init__.py

@@ -6,6 +6,7 @@
 import wx.lib.agw.advancedsplash as AS
 
 from .IPy import *
+from .core import ImagePlus, TablePlus
 root_dir = osp.abspath(osp.dirname(__file__))
 os.chdir(root_dir)
 

imagepy/core/manager/windowmanager.py

@@ -26,7 +26,6 @@ def remove(cls, win):
         for i in cls.wins:
             if i == win: 
                 cls.wins.remove(i)
-                print('remove', i.ips.title)
 
 class ImageManager:
     imgs = []

imagepy/core/wraper/imageplus.py

@@ -9,7 +9,8 @@ def get_img_type(imgs):
     if imgs[0].dtype == np.int32:return '32-int'
     if imgs[0].dtype == np.float32:return '32-float'
     if imgs[0].dtype == np.float64:return '64-float'
-    if imgs[0].dtype == np.complex128:return 'complex'
+    if imgs[0].dtype == np.complex128:return '128-complex'
+    if imgs[0].dtype == np.complex64:return '64-complex'
 
 def get_updown(imgs, slices='all', chans='all', step=1):
     c = chans if isinstance(chans, int) else slice(None)
@@ -23,6 +24,8 @@ def get_updown(imgs, slices='all', chans='all', step=1):
     mins = np.array(mins).reshape((len(mins),-1))
     maxs = np.array(maxs).reshape((len(maxs),-1))
     mins, maxs = mins.min(axis=0), maxs.max(axis=0)
+    if np.iscomplexobj(mins):
+        mins, maxs = np.zeros(mins.shape), np.abs(maxs)
     if chans!='all': return mins.min(), maxs.max()
     return [(i,j) for i,j in zip(mins, maxs)]
 
@@ -50,6 +53,7 @@ def __init__(self, imgs, title=None, is3d=False):
         self.msk = None
         self.mskmode = None
         self.lut = ColorManager.get_lut('grays')
+        self.log = False
 
         self.tool = None
         self.data = {}

imagepy/menus/Process/FFT/fft_plgs.py

@@ -2,6 +2,7 @@
 from imagepy.core.engine import Simple, Filter
 from numpy.fft import fft2, ifft2, fftshift, ifftshift
 from imagepy import IPy
+from imagepy.core import ImagePlus
 
 class FFT(Simple):
 	title = 'FFT'
@@ -17,26 +18,9 @@ def run(self, ips, imgs, para = None):
 		for i in range(len(imgs)):
 			rst.append(shift(fft2(imgs[i])))
 			self.progress(i, len(imgs))
-		IPy.show_img(rst, '%s-fft'%ips.title)
-
-class LogPower(Simple):
-	title = 'Log Power'
-	note = ['complex']
-	para = {'slice':False, 'type':'float', 'log':2.718}
-	view = [(float, 'log', (2,30), 3, 'log', ''),
-			(list, 'type', ['uint8', 'int', 'float'], str, 'type', ''),
-			(bool, 'slice', 'slices')]
-
-	def run(self, ips, imgs, para = None):
-		if not para['slice']: imgs = [ips.img]
-		tp = {'uint8':np.uint8, 'int':np.int32, 'float':np.float32}
-		rst, tp = [], tp[para['type']]
-		for i in range(len(imgs)):
-			zs = np.log(np.abs(imgs[i]))
-			zs /= np.log(para['log'])
-			rst.append(zs.astype(tp))
-			self.progress(i, len(imgs))
-		IPy.show_img(rst, '%s-fft'%ips.title)
+		ips = ImagePlus(rst, '%s-fft'%ips.title)
+		ips.log = True
+		IPy.show_ips(ips)
 
 class IFFT(Simple):
 	title = 'Inverse FFT'
@@ -70,4 +54,22 @@ class IShift(Filter):
 	def run(self, ips, snap, img, para = None):
 		return ifftshift(img)
 
-plgs = [FFT, IFFT, '-', Shift, IShift, LogPower]
+class Split(Simple):
+	title = 'Split Real And Image'
+	note = ['complex']
+	para = {'slice':False, 'copy':False}
+	view = [(bool, 'slice', 'slices'),
+			(bool, 'copy', 'memory copy')]
+
+	def run(self, ips, imgs, para = None):
+		if not para['slice']: imgs = [ips.img]
+		copy = np.copy if para['copy'] else lambda x:x
+		imags, reals = [], []
+		for i in range(len(imgs)):
+			reals.append(copy(imgs[i].real))
+			imags.append(copy(imgs[i].imag))
+			self.progress(i, len(imgs))
+		IPy.show_img(reals, '%s-real'%ips.title)
+		IPy.show_img(imags, '%s-image'%ips.title)
+
+plgs = [FFT, IFFT, '-', Shift, IShift, '-', Split]

imagepy/ui/canvas/canvas.py

@@ -25,17 +25,19 @@ def __init__(self, parent, autofit=False):
 
         self.buffer = None
 
-        lut = np.arange(256*3)
+        lut = np.arange(256*3)//3
         lut.shape = (256,3)
         lut = lut.astype(np.uint8)
 
         self.lut = lut
         self.rg = (0, 255)
         self.cn = 0
+        self.log = False
 
         self._lut = lut
         self._rg = (0, 255)
         self._cn = 0
+        self._log = False
 
         self.marks = {}
 
@@ -99,6 +101,10 @@ def set_img(self, img):
     def set_back(self, back): 
         self.back = back
 
+    def set_log(self, log, b=False):
+        if b: self._log = log
+        else: self.log = log
+        
     def set_rg(self, rg, b=False):
         if b: self._rg = rg
         else: self.rg = rg
@@ -158,17 +164,17 @@ def draw_image(self, dc, img, back, mode):
 
         #if not back is None: print('has back image')
         mix_img(back, m, o, shp, self.outbak, 
-              self.outrgb, self.outint,
-              self._rg, self._lut, cns=self._cn, mode='set')
+              self.outrgb, self.outint, self._rg,
+                self._lut, self._log, cns=self._cn, mode='set')
 
         mix_img(self.img, m, o, shp, self.outimg,
-              self.outrgb, self.outint,
-              self.rg, self.lut, cns=self.cn, mode=self.mode)
-        
+              self.outrgb, self.outint, self.rg,
+                self.lut, self.log, cns=self.cn, mode=self.mode)
         self.outbmp.CopyFromBuffer(memoryview(self.outrgb))
         dc.DrawBitmap(self.outbmp, *csbox[:2])
 
-    def update(self):
+    def update(self, counter = [0,0]):
+        counter[0] += 1
         start = time()
         lay(self.winbox, self.conbox)
         dc = wx.BufferedDC(wx.ClientDC(self), self.buffer)
@@ -181,8 +187,11 @@ def update(self):
             else:
                 drawmark(dc, self.to_panel_coor, self.marks[i], k=self.scale)
         dc.UnMask()
-        print('frame rate:',int(1/max(0.001, time()-start)))
-
+        counter[1] += time()-start
+        if counter[0] == 10:
+            print('frame rate:',int(10/max(0.001,counter[1])))
+            counter[0] = counter[1] = 0
+        
     def center(self, x, y, coord='win'):
         if coord=='data':
             x,y = self.to_panel_coor(x, y)
@@ -229,24 +238,27 @@ def __del__(self):
         print('========== canvas del')
 
 if __name__=='__main__':
-    msk = np.zeros((512,512), dtype=np.uint8)
-    msk[100:200,100:200] = 1
-    msk[200:300,200:300] = 2
-    msk[300:400,300:400] = 3
-    lut = np.array([(0,0,0),(255,0,0),(0,255,0),(0,0,255)], dtype=np.uint8)
-    
     from skimage.data import astronaut, camera
+    from numpy.fft import fft2, ifft2, fftshift, ifftshift
+    import matplotlib.pyplot as plt
+
+    img = camera()
+    img = fftshift(fft2(img))
+    farr = img.view(dtype=np.float64)
+    #a = farr.reshape((512,2,512)).transpose(0,2,1)
+    # farr.shape = img.shape+(-1,)
+    #plt.imshow(np.log(np.abs(a[:,:,1])))
+    #plt.show()
+    
     app = wx.App()
     frame = wx.Frame(None)
     canvas = Canvas(frame)
-    canvas.set_img(msk)
-    canvas.set_lut(lut)
+    
+    canvas.set_img(img)
+    # canvas.set_rg((-128, 127))
+    canvas.set_rg((0,31015306))
     canvas.set_cn(0)
-    canvas.set_back(astronaut())
-    canvas.set_cn((0,1,2), True)
-    canvas.set_mode(0.5)
-    x = np.arange(512)
-    y = np.sin(x/30) * 100 + 256
-    canvas.marks['line'] = {'type':'line', 'lw':3, 'body':np.array([x,y]).T.tolist()}
+    canvas.set_log(True)
     frame.Show(True)
+    frame.SetSize(512,512)
     app.MainLoop()

imagepy/ui/canvas/imutil.py

@@ -1,9 +1,11 @@
 import numpy as np
 from scipy.ndimage import affine_transform
 try: from numba import njit as jit
-except: jit = None
+except:
+    print('install numba may be several times faster!')
+    jit = None
 # jit = None
-
+    
 def affine_jit(img, m, offset, output_shape=0, output=0, order=0, prefilter=0):
     kr=m[0]; kc=m[1]; ofr=offset[0]; ofc=offset[1];
     for r in range(output_shape[0]):
@@ -61,34 +63,88 @@ def blend_jit(img, out, msk, mode):
         if isinstance(mode, float): blend_mix(img, out, msk, mode)
     blend = blend_jit
 
-def stretch(img, out, rg, mode='set'):
-    if img.dtype==np.uint8 and (rg==[(0,255)] or rg==(0,255)):
+def stretch(img, out, rg, log=False):
+    if img.dtype==np.uint8 and not log and (rg==[(0,255)] or rg==(0,255)):
         out[:] = img
-    else:
+    elif not log:
+        ptp = max(rg[1]-rg[0], 1e-6)
         np.clip(img, rg[0], rg[1], out=img)
         np.subtract(img, rg[0], out=img, casting='unsafe')
-        np.multiply(img, 255.0/np.ptp(rg), out=out, casting='unsafe')
+        np.multiply(img, 255/ptp, out=out, casting='unsafe')
+    elif img.itemsize<3:
+        length = 2**(img.itemsize*8)
+        lut = np.arange(length, dtype=np.float32)
+        if img.dtype in (np.int8, np.int16):
+            lut[length//2:] -= length
+        np.clip(lut, rg[0], rg[1], out=lut)
+        np.subtract(lut, rg[0]-1, out=lut)
+        ptp = np.log(max(rg[1]-rg[0]+1, 1+1e-6))
+        np.log(lut, out=lut)
+        lut *= 255/np.log(max(rg[1]-rg[0]+1, 1+1e-6))
+        out[:] = lut[img]
+    else:
+        fimg = img.ravel().view(np.float32)
+        fimg = fimg[:img.size].reshape(img.shape)
+        np.clip(img, rg[0], rg[1], out=fimg)
+        np.subtract(fimg, rg[0]-1, out=fimg)
+        ptp = np.log(max(rg[1]-rg[0]+1, 1+1e-6))
+        np.log(fimg, out=fimg)
+        np.multiply(fimg, 255/ptp, out=out, casting='unsafe')
 
 if not jit is None:
     @jit
-    def stretch_int(img, out, rg):
+    def stretch_linear(img, out, rg):
+        ptp = max(rg[1]-rg[0], 1e-6)
         for r in range(img.shape[0]):
             for c in range(img.shape[1]):
-                out[r,c] = img[r,c]
+                v = (img[r,c]-rg[0])/ptp*255
+                out[r,c] = min(max(v, 0), 255)
     @jit
-    def stretch_other(img, out, rg):
-        ptp = max(rg[1]-rg[0], 1e-6)
+    def stretch_log(img, out, rg):
+        ptp = 255/np.log(max(rg[1]-rg[0]+1, 1+1e-6))
         for r in range(img.shape[0]):
             for c in range(img.shape[1]):
-                v = (img[r,c]-rg[0])/ptp*255
+                v = np.log(img[r,c]-rg[0]+1)*ptp
                 out[r,c] = min(max(v, 0), 255)
-    def stretch_jit(img, out, rg):
-        # print(img.dtype, rg)
-        if img.dtype==np.uint8 and (rg==[(0,255)] or rg==(0,255)):
-            stretch_int(img, out, rg)
-        else: stretch_other(img, out, rg)
+    @jit
+    def stretch_lut(img, out, lut):
+        for r in range(img.shape[0]):
+            for c in range(img.shape[1]):
+                out[r,c] = lut[img[r,c]]
+        
+    def stretch_jit(img, out, rg, log=False):
+        if img.dtype==np.uint8 and not log and (rg==[(0,255)] or rg==(0,255)):
+            out[:] = img
+        elif not log:
+            stretch_linear(img, out, rg)
+        elif img.itemsize<3:
+            length = 2**(img.itemsize*8)
+            lut = np.arange(length, dtype=np.float32)
+            if img.dtype in (np.int8, np.int16):
+                lut[length//2:] -= length
+            np.clip(lut, rg[0], rg[1], out=lut)
+            np.subtract(lut, rg[0]-1, out=lut)
+            ptp = np.log(max(rg[1]-rg[0]+1, 1+1e-6))
+            np.log(lut, out=lut)
+            lut *= 255/np.log(max(rg[1]-rg[0]+1, 1+1e-6))
+            stretch_lut(img, out, lut)
+        else:
+            stretch_log(img, out, rg)
+            
     stretch = stretch_jit
 
+def complex_norm(ori, real, img, out):
+    np.abs(ori, out=out)
+    return out
+
+if not jit is None:
+    @jit
+    def complex_norm(ori, real, img, out):
+        for r in range(img.shape[0]):
+            for c in range(img.shape[1]):
+                out[r,c] = (img[r,c]**2+real[r,c]**2)**0.5
+        return out
+
 def lookup(img, lut, out, mode='set'):
     blend(lut[img], out, img, mode)
 
@@ -136,29 +192,30 @@ def lookup_jit(img, lut, out, mode):
     lookup = lookup_jit
 
 # mode: set, min, max, mix, nor
-def mix_img(img, m, o, shp, buf, rgb, byt, rg=(0,255), lut=None, cns=0, mode='set'):
+def mix_img(img, m, o, shp, buf, rgb, byt, rg=(0,255), lut=None, log=True, cns=0, mode='set'):
     if img is None: return
     img = img.reshape((img.shape[0], img.shape[1], -1))
     if isinstance(rg, tuple): rg = [rg]*img.shape[2]
 
     if isinstance(cns, int):
-        # print(img.dtype, buf.dtype, 'type')
-        affine_transform(img[:,:,cns], m, o, shp, buf, 0, prefilter=False)
-        stretch(buf, byt, rg[cns])
+        if np.iscomplexobj(buf):
+            affine_transform(img[:,:,0].real, m, o, shp, buf.real, 0, prefilter=False)
+            affine_transform(img[:,:,0].imag, m, o, shp, buf.imag, 0, prefilter=False)
+            buf = complex_norm(buf, buf.real, buf.imag, buf.real)
+        else: affine_transform(img[:,:,cns], m, o, shp, buf, 0, prefilter=False)
+        stretch(buf, byt, rg[cns], log)
         return lookup(byt, lut, rgb, mode)
-
     for i,v in enumerate(cns):
         if v==-1: rgb[:,:,i] = 0
-        elif mode=='set' and buf.dtype==np.uint8 and rg[v]==(0,255):
+        elif mode=='set' and img.dtype==np.uint8 and rg[v]==(0,255) and not log:
             affine_transform(img[:,:,v], m, o, shp, rgb[:,:,i], 0, prefilter=False)
         else:
             affine_transform(img[:,:,v], m, o, shp, buf, 0, prefilter=False)
-            stretch(buf, byt, rg[v])
+            stretch(buf, byt, rg[v], log)
             blend(byt, rgb[:,:,i], byt, mode)
 
-
 '''
 rgb = np.array([[[0,0,0]]], dtype=np.uint8)
 lut = np.array([[0,0,0]], dtype=np.uint8)
 mix_img(img, (1,1), (0,0), (1,1), img, rgb, img, (0,255), lut, 0, 'set')
-'''
+'''

imagepy/ui/canvasframe.py

@@ -130,11 +130,13 @@ def on_idle(self, event):
             self.canvas.set_img(self.ips.imgs[self.ips.cur])
             self.canvas.set_cn(self.ips.chan)
             self.canvas.set_rg(self.ips.chan_range)
+            self.canvas.set_log(self.ips.log)
 
             if self.ips.back != None:
                 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_log(self.ips.back.log, True)
                 self.canvas.set_rg(self.ips.back.chan_range, True)
                 self.canvas.set_lut(self.ips.back.lut, True)
                 self.canvas.set_mode(self.ips.chan_mode)