insituTEM 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

insituTEM/insitu_Preprocess.py

@@ -2,8 +2,8 @@
 """
 
 in-situ TEM Toolbox - PreProcess
-By: Meng and Michael
-Assembles of functions related to movie preprocess
+By: Meng Li and Michael
+Assembles of functions related to movie preprocess 
 Example:
     
     import insitu_Preprocess as PP
@@ -18,7 +18,8 @@ import cv2
 from scipy import signal
 from PIL import Image 
 import matplotlib.pyplot as plt
-
+import tifffile
+import tqdm
 
 def estimate_dup(A,B,threshold=1):
     """
@@ -66,44 +67,76 @@ def median_blur (score_list, i,thrs=150,wid=21):
 def detect_blur_fft(image, size=20, thresh=15,vis=False):
     """
     Function to detect if one frame is blurred using FFT
+    Example:
+    score,is_blur = PP.detect_blur_fft(image, size=20, thresh=15,vis=False)
+    Input:
     image: grayscale image, default size: 128*128 px
-    size: filter size to get the background of FFT
+size: filter size to get the background of FFT
     thresh: threshold value for blur scores, smaller score, more blurry
-    
+    Output:
+    mean: mean value of the frame
+    is_blur: whether the frame is blur
     """
+    from insituTEM import insitu_DP as DP
     # grab the dimensions of the image and use the dimensions to derive the center (x, y)-coordinates
-    (h, w) = image.shape
-    (cX, cY) = (int(w / 2.0), int(h / 2.0))
-    # compute the FFT to find the frequency transform, then shift 
-    # the zero frequency component (i.e., DC component located at
-    # the top-left corner) to the center where it will be more
-    # easy to analyze
-    fft = np.fft.fft2(image)
-    fftShift = np.fft.fftshift(fft)
-    magnitude = 20 * np.log(np.abs(fftShift))
+    # h, w = image.shape
+  
+
+    magnitude=DP.getFFT(image)
+    h,w = magnitude.shape
+    cX, cY = w //2, h//2
+    bar=int(h/100)
+    center=bar*10
+        #use only the center of the FFT
+    crop_h,crop_w=(h-cX)//2, (w-cY)//2
+    
+
     # compute the background of FFT to make the diffraaction spots more obvious
     bg = cv2.blur(magnitude,(size,size))
 
     enhanced =cv2.subtract(magnitude, bg)
+    #remove noise by mean
+    # enhanced=enhanced[crop_h:(crop_h+cY),crop_w:(crop_w+cX)]
+
     #remove white noise from the substracted image
-    enhanced[enhanced<30]=0
-    #remove center spot
-    enhanced[cY - 10:cY + 10, cX - 10:cX + 10]=0
+    enhanced[enhanced<20]=0
+    
+    # Check the data type and convert if necessary
+    if enhanced.dtype != np.uint8:
+        # Normalize the image to the range [0, 255] if it has a different range
+        enhanced = cv2.normalize(enhanced, None, 0, 255, cv2.NORM_MINMAX)
+        # Convert the image to uint8
+        enhanced = enhanced.astype(np.uint8)
+    
+    # Apply median filter
+    enhanced = cv2.medianBlur(enhanced, 3)
+
+    # enhanced = cv2.medianBlur(enhanced, 3)
+    # #remove center spot
+    enhanced[(cY - center): (cY + center), cX - center:cX + center] =0
+    enhanced[(cY - bar): (cY + bar), :]=0
+    enhanced[:, (cX - bar): (cX + bar)]=0
+    # enhanced[
+
+
+    croppedFFT=enhanced[crop_h:(crop_h+cY),crop_w:(crop_w+cX)]
 
     if vis:
-        (fig, ax) = plt.subplots(1, 2, )
+        (fig, ax) = plt.subplots(1, 2,figsize=(10, 5) )
         ax[0].imshow(image, cmap="gray")
         ax[0].set_title("Input")
-        ax[0].set_xticks([])
-        ax[0].set_yticks([])
+        # ax[0].set_xticks([])
+        # ax[0].set_yticks([])
         # display the magnitude image
-        ax[1].imshow(enhanced,cmap="viridis")
+        ax[1].imshow(croppedFFT,cmap="viridis")
         ax[1].set_title("Filtered FFT")
-        ax[1].set_xticks([])
-        ax[1].set_yticks([])
+        # ax[1].set_xticks([])
+        # ax[1].set_yticks([])
+        
         # show our plots
         plt.show()
-    mean = np.mean(enhanced)*1000
+    # mean = np.mean(enhanced)*1000
+    mean = np.mean(croppedFFT)*1000
 #     print(mean)
     # the image will be considered "blurry" if the mean value of the magnitudes is less than the threshold value
     return (mean,mean<thresh)
@@ -198,4 +231,175 @@ def removeDPs(img,DP):
     else:
         for j in range(nDP):
             position=DP[j]
-            removeDP(img,position)
+            removeDP(img,position)
+
+
+def BlurDetection(path,wid=31):
+    """
+    Function to remove blurry frames based on the blur score
+    Input: tif file path
+    Output: deblurred tif stack
+    """
+    from insituTEM import insitu_IO as IO
+
+    indexout=path[:-4]+'_DB-index.csv'
+    DBout=path[:-4]+'_DB.csv'
+    DBout2=path[:-4]+'_Blur.csv'
+
+    stack = tifffile.imread(path)
+    nFrames,h,w = stack.shape #make sure the order of h and w!
+    index = []#index of remaining frames
+    score = []
+
+    print("------------------------------------------")
+    print("Calculating blur scores!")  
+
+    for i in tqdm.tqdm(range(nFrames)):
+        fr=stack[i]
+        s = blur_score(fr)
+        score.append(s)
+        index.append(i)
+        
+    length = len(score)
+    Blur=np.zeros((length,3))#[i,blur_score,blur_th]
+    Blur[:,0]=index
+    Blur[:,1]=score            
+
+    plt.plot(score,'gray')
+    plt.show()     
+
+    print("------------------------------------------")
+    print("Check blur detection!")  
+  
+    thrs=int(input( 'Input blur threshold(default: 70): ')) 
+    while thrs!=0:
+        index2=[]
+
+        for i in tqdm.tqdm(range(len(score))):
+            medthres,is_blur=median_blur (score, i,thrs,wid=wid)#wid must be odd
+    #        DB[index[i],3]=is_blur
+            Blur[i,2]=medthres
+            if is_blur == 0:
+                index2.append(index[i])
+                
+        plt.plot(Blur[:,0],Blur[:,1],'gray',Blur[:,0],Blur[:,2]-thrs,'r',Blur[:,0],Blur[:,2]+thrs,'r')
+        plt.show()
+        thrs=int(input( 'Press 0 if you are satisfied, press corrected threshold if you want to change:  ')) 
+    
+    IO.writeCSV(DBout2,Blur)  
+        
+    result= np.zeros((len(index2),2)) 
+    for i in range(len(index2)):
+        result[i,0]=i
+        result[i,1]=index2[i]
+        
+    IO.writeCSV(indexout,result)
+
+    print("------------------------------------------")
+    print("Save blur removed file") 
+    pathout2=path[:-4]+'_DBlur.tif'
+
+    with tifffile.TiffWriter(pathout2,bigtiff=True) as tif:
+        for j in tqdm.tqdm(range(len(index2))):
+            i=int(result[j,1])
+            fr=stack[i]
+
+            tif.write(fr, contiguous=True)
+    print("------------------------------------------")
+    print("Blur removed!") 
+    print("==========================================")
+
+
+def movie_preprocess(path,remove_DP=True,DP=[[0, 0, 1, 1],[0,0,2,2]],Crop=True,cropboarder=[0,0,0,0],Trim=False,start_time_mmss="00:00",end_time_mmss="00:00",grayscale=True,exp_time=0):
+    """
+    Function to preprocess the raw TEM movie to tiff
+    Input:
+        path: file path of the movie
+        remove DP: if there are constant dead point in the movie to remove, 
+            if so, input the DP value. 
+        Crop: if crop the movie to remove the boarders
+            if so, input the cropboarder: [left, top, right, bottom]
+        Trim: if trim the movie length
+            if so, input the start and end time in mm:ss
+        grayscale: if convert the movie to grayscale
+        exp_time: if remove the duplicated frame based on the real exposure time. 
+            if no need to remove duplicates, put exp_time = 0
+    """
+    # print("=========================================")
+    print("ETEM movie preprocessor start!")
+
+    import moviepy.editor as mp
+    import moviepy.video.fx.all as vfx
+    from insituTEM import insitu_IO as IO
+
+
+    video = mp.VideoFileClip(path)
+    if Trim == True:
+        # Convert mm:ss to seconds
+        start_time_seconds = sum(x * int(t) for x, t in zip([60, 1], start_time_mmss.split(":")))
+        end_time_seconds = sum(x * int(t) for x, t in zip([60, 1], end_time_mmss.split(":")))
+
+        video = video.subclip(start_time_seconds, end_time_seconds)# cut the clip between t=0 and 28 secs.
+
+    fps = int(video.fps)
+    # fps= 15
+    w = int(video.w)
+    h = int(video.h)
+    nFrames = int(fps*video.duration)
+
+    print("fps=", fps, "   w =",w, "   h=", h, "duration= ",video.duration)
+    print("Total number of Frames=", nFrames)
+
+
+
+    #Preview first frame
+    print("------------------------------------------")
+    print("Preview the processed frame: press 0 if you want to continue: ")
+
+    if Crop == True:
+        video =  video.fx(vfx.crop, x1=cropboarder[0], y1=cropboarder[1], x2=w-cropboarder[2], y2=h-cropboarder[3])#crop movie snapshot
+    
+    fr = video.get_frame(mp.cvsecs(1/fps))
+    
+    if grayscale==True: 
+        fr = cv2.cvtColor(fr, cv2.COLOR_BGR2GRAY)
+
+    if remove_DP==True:
+        removeDPs(fr,DP)
+
+    IO.showFr(fr)
+    prompt = input("Input 0 if you want to continue, other keys to break :")
+
+    if prompt != "0":
+        print("Stopped by user. Modify the cropboarder values and restart.")
+        return
+    else: 
+        #continue to apply to the full movie
+        #remove duplicate frames with known fps conversion
+        if exp_time==0:
+            dup=1
+        else:
+            dup= fps*exp_time
+
+        nFramesOut=int(nFrames/dup)
+        print ('nFramesOut= ', nFramesOut)
+        print('nFramesIn= ',nFrames)
+
+
+        pathout=path[:-4]+'_CutDB.tif'
+
+        print("------------------------------------------")
+        print("Saving duplicate removed processed frames~")   
+        
+
+        with tifffile.TiffWriter(pathout,bigtiff=True) as tif:
+            for j in tqdm.tqdm(range(nFramesOut)):
+                i=j*dup
+                fr = video.get_frame(mp.cvsecs(i/fps))
+                if grayscale==True: 
+                    fr = cv2.cvtColor(fr, cv2.COLOR_BGR2GRAY)
+                if remove_DP==True:
+                    removeDPs(fr,DP) 
+                tif.write(fr, contiguous=True)
+
+        print("Conversion done!")

insituTEM/insitu_alignment.py

@@ -10,15 +10,20 @@ Example:
     Al.get_matrix()
 
 Created on Tue Jun 11 17:22:45 2019
-By: Michael and Meng
+By: Meng Li and Michel
 """
+
+
 import numpy as np
 import csv
 import cv2
 from skimage import io #package for TIFF stack reading
 import tifffile
 from scipy import signal
-from tqdm import tqdm
+import tqdm
+import matplotlib.pyplot as plt
+from insituTEM import insitu_IO as IO
+
 
 def get_path():
     from tkinter import Tk
@@ -54,6 +59,117 @@ Please choose the csv you want to use
     return dx, dy, csvpath
 
 
+def Adaptive_template_match(path, NOF = 50, csvout=True, TMout=True, TMdenoise=True, TMdenoise_window=5,extend=True, bg = 150):
+    '''
+    Function to produce adaptive template matching on tiff image stack based on ROI selection
+    input: 
+        path: image path for grayscale Tiff stack
+        NOF: number of frames for template to grow
+        csvout: whether to write the translation matrix
+        TMout: whether to write the template match found feature
+        TMdenoise: whether to denoise the measured matrix to remove sudden change
+        TMdenoise_window: window size for TMdenoise
+        bg: background color (0-255)
+        extend: whether to extend the image for the translation (avoid crop)
+    
+    output: 
+        Translated  image stack
+        Csv file of translation matrix
+        Captured ROI location
+
+    Write by Meng Li (mona.mengli@gmail.com) 2024.02.06
+    '''
+    import cv2
+    import numpy as np
+    from matplotlib import pyplot as plt
+    import tifffile
+    import easygui
+    import tqdm
+    from insituTEM import insitu_IO as IO
+    # from insituTEM import insitu_alignment as AL
+ 
+    ###############################################################
+    ## 1. Inital settings 
+
+    stack = tifffile.imread(path)
+    nFrames, h,w = stack.shape
+    
+    TM = np.zeros((nFrames,3))#frame, TX,TY,max_val
+    pathout3 = path[:-4]+'_TM.csv'
+    pathout2 = path[:-4]+'_TM.tif'
+    
+    ################################################################
+    #2. Open fr0 and select ROI for template matching
+    img = stack[0]
+    ## Select ROI for template matching
+    r = cv2.selectROI("Select ROI, press ENTER to confirm",img,fromCenter=False,showCrosshair=False)
+    cv2.destroyWindow("Select ROI, press ENTER to confirm")
+    # Crop image
+    template = img[int(r[1]):int(r[1]+r[3]), int(r[0]):int(r[0]+r[2])]#opencv coordinate: Y,x , from upper left corner of the image 
+    # Display cropped image
+    cv2.imshow("Template, press ENTER to confirm", template)
+    cv2.waitKey(0)
+    # cv2.destroyWindow("Template, press ENTER to confirm")
+    cv2.destroyAllWindows()
+    for _ in range(5):
+        cv2.waitKey(1)
+    
+    
+    
+    # ################################################################
+    #3. Apply template to template matching
+    meth='cv2.TM_CCOEFF_NORMED'
+    method = eval(meth)
+    w, h = template.shape[::-1]
+ 
+    print("------------------------------------------")
+    print("Calculating drift~")  
+    with tifffile.TiffWriter(pathout2,bigtiff=True) as tif:
+        for i in tqdm.tqdm(range(nFrames)):
+            fr=stack[i]
+            # Apply template Matching
+            res = cv2.matchTemplate(fr,template,method)
+            min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)
+            top_left = max_loc
+            TM[i,0]=i
+            TM[i,1]=top_left[0]
+            TM[i,2]=top_left[1]
+            bottom_right = (top_left[0] + w, top_left[1] + h)
+            cv2.rectangle(fr,top_left, bottom_right, 255, 2)
+
+            if i%NOF==NOF-1:
+                template = fr[int(top_left[1]):int(top_left[1] + h), int(top_left[0]):int(top_left[0] + w)]#opencv coordinate: Y,x , from upper left corner of the image 
+            if TMout==True: 
+                tif.write(fr, contiguous=True)
+
+        
+    TM[:,1]=TM[0,1]-TM[:,1]
+    TM[:,2]=TM[0,2]-TM[:,2]
+    
+    # ################################################################
+    #4. Apply TM to movie
+    if TMdenoise==True: 
+        #Get average to minimize total movement
+        TM=denoiseTM(TM,TMdenoise_window)
+        Mx=int(np.mean(TM[:,1]))
+        My=int(np.mean(TM[:,2]))
+        TM[:,1]=TM[:,1]-Mx
+        TM[:,2]=TM[:,2]-My
+    
+    print("------------------------------------------")
+    print("Saving files~")   
+    plt.plot(TM[:,0],TM[:,1],'b',TM[:,0],TM[:,2],'r')
+
+    if csvout==True:
+        IO.writeCSV(pathout3,TM,fmt='%1.1d')
+    
+    TranslateStack(path,TM,bg=bg, extend = extend)
+    print("Adaptive template matching done!")  
+    plt.show(block=False)
+    plt.pause(0.1)
+    plt.close()
+
+
 
     
 def TranslateStack(movie_path,matrix,bg=150,extend=True):
@@ -90,7 +206,7 @@ def TranslateStack(movie_path,matrix,bg=150,extend=True):
     
     #2d matrix flipped order of width and height to work with warpaffine method
     print("\nApplying translation to stack\n")
-    with tifffile.TiffWriter(movie_pathout) as tif:
+    with tifffile.TiffWriter(movie_pathout,bigtiff=True) as tif:
 
         for num in tqdm(range(nframes)):
             temparray = img[num,:,:]
@@ -100,13 +216,6 @@ def TranslateStack(movie_path,matrix,bg=150,extend=True):
                 
             extend_img = cv2.copyMakeBorder(temparray, top, bottom, left, right, cv2.BORDER_CONSTANT, value=bg)
             translated_img = cv2.warpAffine(extend_img,TM,(width,height),borderValue =bg)#fill with gray
-            #Generates an image translated by dx and dy
-            # if num == 0:                    
-            #     tifffile.imwrite(movie_pathout, translated_img, append=False, bigtiff=True)
-            #     #Overrides any previous files saved to the same path
-            # else:
-            #     tifffile.imwrite(movie_pathout, translated_img, append=True, bigtiff=True)
-            #     #appends onto the tiff stack
             tif.write(translated_img, contiguous=True)
 
             
@@ -246,4 +355,181 @@ def template_match(imgpath, w=24):
     for num in iterate:
         TM[num,0] = dx[num]
         TM[num,1] = dy[num]
-    IO.writeCSV(csvpathout,TM)
+    IO.writeCSV(csvpathout,TM)
+
+
+def ATM_locglobal(path, NOF=50, csvout=True, TMout=True, TMdenoise=True, TMdenoise_window=5, extend=True, bg=150,search_margin_local=1, match_threshold=0.8):
+    '''
+    Function to produce adaptive template matching on TIFF image stack based on ROI selection with local and global selections
+    
+    Input:
+        path: Image path for grayscale TIFF stack
+        NOF: Number of frames for template to grow
+        csvout: Whether to write the translation matrix
+        TMout: Whether to write the template match found feature
+        TMdenoise: Whether to denoise the measured matrix to remove sudden change
+        TMdenoise_window: Window size for TMdenoise
+        bg: Background color (0-255)
+        extend: Whether to extend the image for the translation (avoid crop)
+        match_threshold: Threshold for considering the new ROI position close to the previous one
+    
+    Output:
+        Translated image stack
+        CSV file of translation matrix
+        Captured ROI location
+
+    Written by Meng Li (mona.mengli@gmail.com) 2024.07.06
+    '''
+
+    ###############################################################
+    # 1. Initial settings 
+
+
+    import sys
+
+    try:
+        stack = tifffile.imread(path)
+    except OSError as e:
+        print(f"Error reading the TIFF file: {e}")
+        sys.exit(1)
+
+    # stack = tifffile.imread(path)
+    nFrames, h, w = stack.shape
+    
+    TM = np.zeros((nFrames, 3))  # frame, TX, TY, max_val
+    pathout3 = path[:-4] + '_TM.csv'
+    pathout2 = path[:-4] + '_TM.tif'
+    
+    ###############################################################
+    # 2. Open the first frame and select ROI for template matching
+    img = stack[0]
+    
+    # Select ROI for template matching, returns x1,y1,w,h
+    r = cv2.selectROI("Select ROI, press ENTER to confirm", img, fromCenter=False, showCrosshair=False)
+    x1,y1,template_w,template_h=int(r[0]),int(r[1]),int(r[2]),int(r[3])
+    x2=x1+template_w
+    y2=y1+template_h
+
+    cv2.destroyWindow("Select ROI, press ENTER to confirm")
+    
+    # Crop image to get the template
+    # template = img[int(r[1]):int(r[1] + r[3]), int(r[0]):int(r[0] + r[2])]
+    template=img[y1:y2,x1:x2]
+    # template_h, template_w = template.shape
+    
+    # Display cropped image
+    cv2.imshow("Template, press ENTER to confirm", template)
+    cv2.waitKey(0)
+    cv2.destroyAllWindows()
+    cv2.waitKey(1)
+    
+    ###############################################################
+    # 3. Apply template matching
+    method = cv2.TM_CCOEFF_NORMED
+    
+    print("------------------------------------------")
+    print("Calculating drift~")  
+    
+    last_top_left = (x1,y1)
+    
+    last_max_val = None
+    
+
+    
+    with tifffile.TiffWriter(pathout2, bigtiff=True) as tif:
+        for i in tqdm.tqdm(range(nFrames)):
+            fr = stack[i]
+            
+            search_area_global=fr
+ 
+            # Apply global template matching
+            res_global = cv2.matchTemplate(search_area_global, template, method)
+            min_val_global, max_val_global, min_loc_global, max_loc_global = cv2.minMaxLoc(res_global)
+            
+            global_top_left = max_loc_global
+            
+
+            # Define the local search area around the last known ROI position
+            # search_margin_local = 1  # Local search margin
+            x1_local=int(x1-search_margin_local)
+            y1_local=int(y1-search_margin_local)
+            x2_local=int(x1+template_w+search_margin_local)
+            y2_local=int(y1+template_h+search_margin_local)
+            search_area_local = fr[y1_local:y2_local, x1_local:x2_local]
+            # Apply local template matching
+            res_local = cv2.matchTemplate(search_area_local, template, method)
+            min_val_local, max_val_local, min_loc_local, max_loc_local = cv2.minMaxLoc(res_local)
+            
+            local_top_left = (x1_local + max_loc_local[0], y1_local + max_loc_local[1])
+
+   
+
+            # # start_x_local = max(last_top_left[0] - search_margin_local, 0)
+            # # start_y_local = max(last_top_left[1] - search_margin_local, 0)
+            # # end_x_local=last_top_left[0]+template_w+search_margin_local
+            # # end_y_local = last_top_left[1] +template_h + search_margin_local
+            # # # end_x_local = min(last_top_left[0]+template_w + search_margin_local, w)
+            # # # end_y_local = min(last_top_left[1] +template_h + search_margin_local, h])
+            
+            # # search_area_local = fr[start_y_local:end_y_local, start_x_local:end_x_local]
+            
+            # # Apply local template matching
+            # res_local = cv2.matchTemplate(search_area_local, template, method)
+            # min_val_local, max_val_local, min_loc_local, max_loc_local = cv2.minMaxLoc(res_local)
+            
+            # local_top_left = (start_x_local + max_loc_local[0], start_y_local + max_loc_local[1])
+            
+            # Use the local match if the match value is within the threshold of the previous match
+            if last_max_val is not None and max_val_local >= max_val_global * match_threshold:
+                top_left = (local_top_left[0] , local_top_left[1])
+                max_val = max_val_local
+            else:
+                top_left = (global_top_left[0], global_top_left[1])
+                max_val = max_val_global
+            
+            TM[i, 0] = i
+            TM[i, 1] = top_left[0]
+            TM[i, 2] = top_left[1]
+            
+            # Update the last known position and match value
+            last_top_left = top_left
+            last_max_val = max_val
+            
+            # Draw rectangle for visualization
+            bottom_right = (top_left[0] + template_w, top_left[1] + template_h)
+            cv2.rectangle(fr, top_left, bottom_right, 255, 2)
+            
+            # Periodically update the template
+            if i % NOF == NOF - 1:
+                template = fr[top_left[1]:bottom_right[1], top_left[0]:bottom_right[0]]
+                template_h, template_w = template.shape
+                
+            if TMout:
+                tif.write(fr, contiguous=True)
+    
+    TM[:, 1] = TM[0, 1] - TM[:, 1]
+    TM[:, 2] = TM[0, 2] - TM[:, 2]
+    
+    ###############################################################
+    # 4. Apply translation matrix to movie
+    if TMdenoise:
+        TM = denoiseTM(TM, TMdenoise_window)
+        Mx = int(np.mean(TM[:, 1]))
+        My = int(np.mean(TM[:, 2]))
+        TM[:, 1] -= Mx
+        TM[:, 2] -= My
+    
+    print("------------------------------------------")
+    print("Saving files~")   
+    
+    plt.plot(TM[:, 0], TM[:, 1], 'b', TM[:, 0], TM[:, 2], 'r')
+
+    if csvout:
+        IO.writeCSV(pathout3, TM, fmt='%1.1d')
+    
+    TranslateStack(path, TM, bg=bg, extend=extend)
+    
+    print("Adaptive template matching done!")  
+    plt.show()
+
+

insitutem-0.1.7.dist-info/METADATA

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: insituTEM
+Version: 0.1.7
+Author: Meng Li
+Requires-Python: >=3.9
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: pandas
+Requires-Dist: tifffile
+Requires-Dist: tqdm
+Requires-Dist: opencv-python
+Requires-Dist: pillow
+Requires-Dist: scikit-image
+Requires-Dist: moviepy
+Requires-Dist: ncempy
+Requires-Dist: easygui
+Requires-Dist: pystackreg
+Requires-Dist: pyside6
+Dynamic: author

insitutem-0.1.7.dist-info/RECORD

@@ -0,0 +1,12 @@
+insituTEM/__ init __.py,sha256=L4AFZSmHZkQu6J-tlqBoTJaBFltRFZ5PArhk8pmDmco,283
+insituTEM/insitu_DENS.py,sha256=q2ZGbAoPPfsWbG8XlQqTdJa5_VNUNvjR9FzG2J3KkP4,10865
+insituTEM/insitu_DP.py,sha256=0HMGT7j9ndpYPAgXCNGHkZeg9yJ4KI4SMCim2kiG6C0,10930
+insituTEM/insitu_Diff.py,sha256=EpCMuprigdJKXaFbg9kIGZi_msKRqIDmdqvA1yofTco,11951
+insituTEM/insitu_EMraw.py,sha256=O7rwdQW4STkQlYr3yImnpJX_VqjIExHgFqFIoKblYYE,15347
+insituTEM/insitu_IO.py,sha256=za4ow7DPnv_YgroD_3fH12neXwYjw717w8jPzCRQvqg,25554
+insituTEM/insitu_Preprocess.py,sha256=xKnHnv8dc0gTHzzEPW_DivzzEJHNFSNGRD_r7UM2l6U,12779
+insituTEM/insitu_alignment.py,sha256=duH383I-jSStKhy6l7mzy9yijSl7Elf4JDFfV8ilFzM,19595
+insitutem-0.1.7.dist-info/METADATA,sha256=J88Jc0obYHWJp7-89Xab0ZdsSNkDRvWIc9v-RtKTgbs,438
+insitutem-0.1.7.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+insitutem-0.1.7.dist-info/top_level.txt,sha256=DEgrwrdz6iV62_cukvjFXu4dnZYupwvS41QyvTfcqjs,10
+insitutem-0.1.7.dist-info/RECORD,,

{insituTEM-0.1.5.dist-info → insitutem-0.1.7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

insituTEM-0.1.5.dist-info/METADATA

@@ -1,13 +0,0 @@
-Metadata-Version: 2.1
-Name: insituTEM
-Version: 0.1.5
-Summary: A package of tools for processing in situ TEM data
-Author: Meng Li
-Requires-Dist: tifffile
-Requires-Dist: moviepy
-Requires-Dist: tqdm
-Requires-Dist: numpy
-Requires-Dist: opencv-python
-Requires-Dist: scipy
-Requires-Dist: matplotlib
-