biomedisa 2024.5.18__py3-none-any.whl → 2024.5.20__py3-none-any.whl

biomedisa/{biomedisa_features → features}/biomedisa_helper.py

@@ -1,6 +1,6 @@
 ##########################################################################
 ##                                                                      ##
-##  Copyright (c) 2024 Philipp Lösel. All rights reserved.              ##
+##  Copyright (c) 2019-2024 Philipp Lösel. All rights reserved.         ##
 ##                                                                      ##
 ##  This file is part of the open source project biomedisa.             ##
 ##                                                                      ##
@@ -27,9 +27,9 @@
 ##########################################################################
 
 import os
-BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-from biomedisa_features.amira_to_np.amira_helper import amira_to_np, np_to_amira
-from biomedisa_features.nc_reader import nc_to_np, np_to_nc
+import biomedisa
+from biomedisa.features.amira_to_np.amira_helper import amira_to_np, np_to_amira
+from biomedisa.features.nc_reader import nc_to_np, np_to_nc
 from tifffile import imread, imwrite
 from medpy.io import load, save
 import SimpleITK as sitk
@@ -41,10 +41,10 @@ import cv2
 import time
 import zipfile
 import numba
-import shutil
 import subprocess
 import re
 import math
+import tempfile
 
 def silent_remove(filename):
     try:
@@ -53,7 +53,7 @@ def silent_remove(filename):
         pass
 
 # create a unique filename
-def unique_file_path(path, dir_path=BASE_DIR+'/private_storage/'):
+def unique_file_path(path, dir_path=biomedisa.BASE_DIR+'/private_storage/'):
 
     # get extension
     username = os.path.basename(os.path.dirname(path))
@@ -116,7 +116,7 @@ def Dice_score(ground_truth, result, average_dice=False):
 
 def ASSD(ground_truth, result):
     try:
-        from biomedisa_features.assd import ASSD_one_label
+        from biomedisa.features.assd import ASSD_one_label
         number_of_elements = 0
         distances = 0
         hausdorff = 0
@@ -280,92 +280,85 @@ def load_data(path_to_data, process='None', return_extension=False):
             data, header = None, None
 
     elif extension == '.zip' or os.path.isdir(path_to_data):
-        # extract files
-        if extension=='.zip':
-            path_to_dir = BASE_DIR + '/tmp/' + id_generator(40)
-            try:
-                zip_ref = zipfile.ZipFile(path_to_data, 'r')
-                zip_ref.extractall(path=path_to_dir)
-                zip_ref.close()
-            except Exception as e:
-                print(e)
-                print('Using unzip package...')
-                try:
-                    success = subprocess.Popen(['unzip',path_to_data,'-d',path_to_dir]).wait()
-                    if success != 0:
-                        if os.path.isdir(path_to_dir):
-                            shutil.rmtree(path_to_dir)
-                        data, header = None, None
-                except Exception as e:
-                    print(e)
-                    if os.path.isdir(path_to_dir):
-                        shutil.rmtree(path_to_dir)
-                    data, header = None, None
-            path_to_data = path_to_dir
-
-        # load files
-        if os.path.isdir(path_to_data):
-            files = []
-            for data_type in ['.[pP][nN][gG]','.[tT][iI][fF]','.[tT][iI][fF][fF]','.[dD][cC][mM]','.[dD][iI][cC][oO][mM]','.[bB][mM][pP]','.[jJ][pP][gG]','.[jJ][pP][eE][gG]','.nc','.nc.bz2']:
-                files += [file for file in glob.glob(path_to_data+'/**/*'+data_type, recursive=True) if not os.path.basename(file).startswith('.')]
-            nc_extension = False
-            for file in files:
-                if os.path.splitext(file)[1] == '.nc' or os.path.splitext(os.path.splitext(file)[0])[1] == '.nc':
-                    nc_extension = True
-            if nc_extension:
+        with tempfile.TemporaryDirectory() as temp_dir:
+
+            # extract files
+            if extension=='.zip':
                 try:
-                    data, header = nc_to_np(path_to_data)
+                    zip_ref = zipfile.ZipFile(path_to_data, 'r')
+                    zip_ref.extractall(path=temp_dir)
+                    zip_ref.close()
                 except Exception as e:
                     print(e)
-                    data, header = None, None
-            else:
-                try:
-                    # remove unreadable files or directories
-                    for name in files:
-                        if os.path.isfile(name):
-                            try:
-                                img, _ = load(name)
-                            except:
+                    print('Using unzip package...')
+                    try:
+                        success = subprocess.Popen(['unzip',path_to_data,'-d',temp_dir]).wait()
+                        if success != 0:
+                            data, header = None, None
+                    except Exception as e:
+                        print(e)
+                        data, header = None, None
+                path_to_data = temp_dir
+
+            # load files
+            if os.path.isdir(path_to_data):
+                files = []
+                for data_type in ['.[pP][nN][gG]','.[tT][iI][fF]','.[tT][iI][fF][fF]','.[dD][cC][mM]','.[dD][iI][cC][oO][mM]','.[bB][mM][pP]','.[jJ][pP][gG]','.[jJ][pP][eE][gG]','.nc','.nc.bz2']:
+                    files += [file for file in glob.glob(path_to_data+'/**/*'+data_type, recursive=True) if not os.path.basename(file).startswith('.')]
+                nc_extension = False
+                for file in files:
+                    if os.path.splitext(file)[1] == '.nc' or os.path.splitext(os.path.splitext(file)[0])[1] == '.nc':
+                        nc_extension = True
+                if nc_extension:
+                    try:
+                        data, header = nc_to_np(path_to_data)
+                    except Exception as e:
+                        print(e)
+                        data, header = None, None
+                else:
+                    try:
+                        # remove unreadable files or directories
+                        for name in files:
+                            if os.path.isfile(name):
+                                try:
+                                    img, _ = load(name)
+                                except:
+                                    files.remove(name)
+                            else:
                                 files.remove(name)
+                        files.sort()
+
+                        # get data size
+                        img, _ = load(files[0])
+                        if len(img.shape)==3:
+                            ysh, xsh, csh = img.shape[0], img.shape[1], img.shape[2]
+                            channel = 'last'
+                            if ysh < csh:
+                                csh, ysh, xsh = img.shape[0], img.shape[1], img.shape[2]
+                                channel = 'first'
                         else:
-                            files.remove(name)
-                    files.sort()
-
-                    # get data size
-                    img, _ = load(files[0])
-                    if len(img.shape)==3:
-                        ysh, xsh, csh = img.shape[0], img.shape[1], img.shape[2]
-                        channel = 'last'
-                        if ysh < csh:
-                            csh, ysh, xsh = img.shape[0], img.shape[1], img.shape[2]
-                            channel = 'first'
-                    else:
-                        ysh, xsh = img.shape[0], img.shape[1]
-                        csh, channel = 0, None
-
-                    # load data slice by slice
-                    data = np.empty((len(files), ysh, xsh), dtype=img.dtype)
-                    header, image_data_shape = [], []
-                    for k, file_name in enumerate(files):
-                        img, img_header = load(file_name)
-                        if csh==3:
-                            img = rgb2gray(img, channel)
-                        elif csh==1 and channel=='last':
-                            img = img[:,:,0]
-                        elif csh==1 and channel=='first':
-                            img = img[0,:,:]
-                        data[k] = img
-                        header.append(img_header)
-                    header = [header, files, data.dtype]
-                    data = np.swapaxes(data, 1, 2)
-                    data = np.copy(data, order='C')
-                except Exception as e:
-                    print(e)
-                    data, header = None, None
-
-        # remove extracted files
-        if extension=='.zip' and os.path.isdir(path_to_data):
-            shutil.rmtree(path_to_data)
+                            ysh, xsh = img.shape[0], img.shape[1]
+                            csh, channel = 0, None
+
+                        # load data slice by slice
+                        data = np.empty((len(files), ysh, xsh), dtype=img.dtype)
+                        header, image_data_shape = [], []
+                        for k, file_name in enumerate(files):
+                            img, img_header = load(file_name)
+                            if csh==3:
+                                img = rgb2gray(img, channel)
+                            elif csh==1 and channel=='last':
+                                img = img[:,:,0]
+                            elif csh==1 and channel=='first':
+                                img = img[0,:,:]
+                            data[k] = img
+                            header.append(img_header)
+                        header = [header, files, data.dtype]
+                        data = np.swapaxes(data, 1, 2)
+                        data = np.copy(data, order='C')
+                    except Exception as e:
+                        print(e)
+                        data, header = None, None
 
     elif extension == '.mrc':
         try:
@@ -396,7 +389,7 @@ def load_data(path_to_data, process='None', return_extension=False):
 
 def _error_(bm, message):
     if bm.django_env:
-        from biomedisa_features.django_env import create_error_object
+        from biomedisa.features.django_env import create_error_object
         create_error_object(message, bm.remote, bm.queue, bm.img_id)
         with open(bm.path_to_logfile, 'a') as logfile:
             print('%s %s %s %s' %(time.ctime(), bm.username, bm.shortfilename, message), file=logfile)
@@ -495,34 +488,31 @@ def save_data(path_to_final, final, header=None, final_image_type=None, compress
         simg.CopyInformation(header)
         sitk.WriteImage(simg, path_to_final, useCompression=compress)
     elif final_image_type in ['.zip', 'directory', '']:
-        # make results directory
-        if final_image_type == '.zip':
-            results_dir = BASE_DIR + '/tmp/' + id_generator(40)
-            os.makedirs(results_dir)
-            os.chmod(results_dir, 0o770)
-        else:
-            results_dir = path_to_final
-            if not os.path.isdir(results_dir):
-                os.makedirs(results_dir)
-                os.chmod(results_dir, 0o770)
-        # save data as NC blocks
-        if os.path.splitext(header[1][0])[1] == '.nc':
-            np_to_nc(results_dir, final, header)
-            file_names = header[1]
-        # save data as PNG, TIF, DICOM slices
-        else:
-            header, file_names, final_dtype = header[0], header[1], header[2]
-            final = final.astype(final_dtype)
-            final = np.swapaxes(final, 2, 1)
-            for k, file in enumerate(file_names):
-                save(final[k], results_dir + '/' + os.path.basename(file), header[k])
-        # zip data
-        if final_image_type == '.zip':
-            with zipfile.ZipFile(path_to_final, 'w') as zip:
-                for file in file_names:
-                    zip.write(results_dir + '/' + os.path.basename(file), os.path.basename(file))
-            if os.path.isdir(results_dir):
-                shutil.rmtree(results_dir)
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # make results directory
+            if final_image_type == '.zip':
+                results_dir = temp_dir
+            else:
+                results_dir = path_to_final
+                if not os.path.isdir(results_dir):
+                    os.makedirs(results_dir)
+                    os.chmod(results_dir, 0o770)
+            # save data as NC blocks
+            if os.path.splitext(header[1][0])[1] == '.nc':
+                np_to_nc(results_dir, final, header)
+                file_names = header[1]
+            # save data as PNG, TIF, DICOM slices
+            else:
+                header, file_names, final_dtype = header[0], header[1], header[2]
+                final = final.astype(final_dtype)
+                final = np.swapaxes(final, 2, 1)
+                for k, file in enumerate(file_names):
+                    save(final[k], results_dir + '/' + os.path.basename(file), header[k])
+            # zip data
+            if final_image_type == '.zip':
+                with zipfile.ZipFile(path_to_final, 'w') as zip:
+                    for file in file_names:
+                        zip.write(results_dir + '/' + os.path.basename(file), os.path.basename(file))
     else:
         imageSize = int(final.nbytes * 10e-7)
         bigtiff = True if imageSize > 2000 else False

biomedisa/{biomedisa_features → features}/create_slices.py

@@ -1,7 +1,7 @@
 #!/usr/bin/python3
 ##########################################################################
 ##                                                                      ##
-##  Copyright (c) 2024 Philipp Lösel. All rights reserved.              ##
+##  Copyright (c) 2019-2024 Philipp Lösel. All rights reserved.         ##
 ##                                                                      ##
 ##  This file is part of the open source project biomedisa.             ##
 ##                                                                      ##
@@ -28,9 +28,7 @@
 ##########################################################################
 
 import sys, os
-BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-sys.path.append(BASE_DIR)
-from biomedisa_features.biomedisa_helper import load_data, color_to_gray, img_to_uint8, img_resize, id_generator
+from biomedisa.features.biomedisa_helper import load_data, color_to_gray, img_to_uint8, img_resize, id_generator
 from PIL import Image
 import numpy as np
 from glob import glob
@@ -38,6 +36,7 @@ import numba
 import shutil
 import cv2
 import tarfile
+import tempfile
 
 def unique(arr):
     arr = arr.astype(np.uint8)
@@ -110,37 +109,33 @@ def create_slices(path_to_data, path_to_label, on_site=False):
             # load data and reduce data size
             path_to_dir, extension = os.path.splitext(path_to_data)
             if extension == '.gz':
-                path_to_dir, extension = os.path.splitext(path_to_dir)
+                extension = os.path.splitext(path_to_dir)[1]
             if extension == '.tar' or os.path.isdir(path_to_data):
-                # extract files
-                if extension == '.tar':
-                    path_to_dir = BASE_DIR + '/tmp/' + id_generator(40)
-                    tar = tarfile.open(path_to_data)
-                    tar.extractall(path=path_to_dir)
-                    tar.close()
-                else:
-                    path_to_dir = path_to_data
-                # load files
-                img_names = []
-                for data_type in ['.tif','.tiff','.am','.hdr','.mhd','.mha','.nrrd','.nii','.nii.gz','.zip','.mrc']:
-                    img_names.extend(glob(path_to_dir+'/**/*'+data_type, recursive=True))
-                img_names = sorted(img_names)
-                raw = None
-                for name in img_names:
-                    arr, _ = load_data(name, 'create_slices')
-                    if arr is not None and raw is None:
-                        zsh, ysh, xsh = arr.shape
-                        scale = float(256) / float(max(zsh, ysh, xsh))
-                        z_scale = int(zsh * scale)
-                        y_scale = int(ysh * scale)
-                        x_scale = int(xsh * scale)
-                        raw = img_resize(arr, z_scale, y_scale, x_scale)
-                    elif arr is not None:
-                        arr = img_resize(arr, z_scale, y_scale, x_scale)
-                        raw = np.append(raw, arr, axis=0)
-                # remove extracted files
-                if extension == '.tar' and os.path.isdir(path_to_dir):
-                    shutil.rmtree(path_to_dir)
+                with tempfile.TemporaryDirectory() as temp_dir:
+                    # extract files
+                    if extension == '.tar':
+                        tar = tarfile.open(path_to_data)
+                        tar.extractall(path=temp_dir)
+                        tar.close()
+                        path_to_data = temp_dir
+                    # load files
+                    img_names = []
+                    for data_type in ['.tif','.tiff','.am','.hdr','.mhd','.mha','.nrrd','.nii','.nii.gz','.zip','.mrc']:
+                        img_names.extend(glob(path_to_data+'/**/*'+data_type, recursive=True))
+                    img_names = sorted(img_names)
+                    raw = None
+                    for name in img_names:
+                        arr, _ = load_data(name, 'create_slices')
+                        if arr is not None and raw is None:
+                            zsh, ysh, xsh = arr.shape
+                            scale = float(256) / float(max(zsh, ysh, xsh))
+                            z_scale = int(zsh * scale)
+                            y_scale = int(ysh * scale)
+                            x_scale = int(xsh * scale)
+                            raw = img_resize(arr, z_scale, y_scale, x_scale)
+                        elif arr is not None:
+                            arr = img_resize(arr, z_scale, y_scale, x_scale)
+                            raw = np.append(raw, arr, axis=0)
             else:
                 raw, _ = load_data(path_to_data, 'create_slices')
                 zsh, ysh, xsh = raw.shape
@@ -174,33 +169,29 @@ def create_slices(path_to_data, path_to_label, on_site=False):
                 # load data
                 path_to_dir, extension = os.path.splitext(path_to_label)
                 if extension == '.gz':
-                    path_to_dir, extension = os.path.splitext(path_to_dir)
+                    extension = os.path.splitext(path_to_dir)[1]
                 if extension == '.tar' or os.path.isdir(path_to_label):
-                    # extract files
-                    if extension == '.tar':
-                        path_to_dir = BASE_DIR + '/tmp/' + id_generator(40)
-                        tar = tarfile.open(path_to_label)
-                        tar.extractall(path=path_to_dir)
-                        tar.close()
-                    else:
-                        path_to_dir = path_to_label
-                    # load files
-                    img_names = []
-                    for data_type in ['.tif','.tiff','.am','.hdr','.mhd','.mha','.nrrd','.nii','.nii.gz','.zip','.mrc']:
-                        img_names.extend(glob(path_to_dir+'/**/*'+data_type, recursive=True))
-                    img_names = sorted(img_names)
-                    # load and scale label data to corresponding img data
-                    mask = np.zeros((0, y_scale, x_scale), dtype=np.uint8)
-                    for name in img_names:
-                        arr, _ = load_data(name, 'create_slices')
-                        if arr is not None:
-                            arr = color_to_gray(arr)
-                            arr = arr.astype(np.uint8)
-                            arr = img_resize(arr, z_scale, y_scale, x_scale, labels=True)
-                            mask = np.append(mask, arr, axis=0)
-                    # remove extracted files
-                    if extension == '.tar' and os.path.isdir(path_to_dir):
-                        shutil.rmtree(path_to_dir)
+                    with tempfile.TemporaryDirectory() as temp_dir:
+                        # extract files
+                        if extension == '.tar':
+                            tar = tarfile.open(path_to_label)
+                            tar.extractall(path=temp_dir)
+                            tar.close()
+                            path_to_label = temp_dir
+                        # load files
+                        img_names = []
+                        for data_type in ['.tif','.tiff','.am','.hdr','.mhd','.mha','.nrrd','.nii','.nii.gz','.zip','.mrc']:
+                            img_names.extend(glob(path_to_label+'/**/*'+data_type, recursive=True))
+                        img_names = sorted(img_names)
+                        # load and scale label data to corresponding img data
+                        mask = np.zeros((0, y_scale, x_scale), dtype=np.uint8)
+                        for name in img_names:
+                            arr, _ = load_data(name, 'create_slices')
+                            if arr is not None:
+                                arr = color_to_gray(arr)
+                                arr = arr.astype(np.uint8)
+                                arr = img_resize(arr, z_scale, y_scale, x_scale, labels=True)
+                                mask = np.append(mask, arr, axis=0)
                 else:
                     mask, _ = load_data(path_to_label, 'create_slices')
                     mask = color_to_gray(mask)