biomedisa 2024.5.17__py3-none-any.whl → 2024.5.19__py3-none-any.whl

biomedisa/biomedisa_features/biomedisa_helper.py

@@ -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:
@@ -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:
@@ -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/create_slices.py

@@ -38,6 +38,7 @@ import numba
 import shutil
 import cv2
 import tarfile
+import tempfile
 
 def unique(arr):
     arr = arr.astype(np.uint8)
@@ -110,37 +111,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 +171,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)

biomedisa/biomedisa_features/crop_helper.py

@@ -27,7 +27,7 @@
 ##########################################################################
 
 import os
-from biomedisa_features.keras_helper import read_img_list, remove_extracted_data
+from biomedisa_features.keras_helper import read_img_list
 from biomedisa_features.biomedisa_helper import img_resize, load_data, save_data, set_labels_to_zero
 from tensorflow.python.framework.errors_impl import ResourceExhaustedError
 from tensorflow.keras.applications import DenseNet121, densenet
@@ -43,12 +43,11 @@ from glob import glob
 import h5py
 import tarfile
 import matplotlib.pyplot as plt
+import tempfile
 
 class InputError(Exception):
-    def __init__(self, message=None, img_names=[], label_names=[]):
+    def __init__(self, message=None):
         self.message = message
-        self.img_names = img_names
-        self.label_names = label_names
 
 def save_history(history, path_to_model):
     # summarize history for accuracy
@@ -98,124 +97,122 @@ def make_densenet(inputshape):
 def load_cropping_training_data(normalize, img_list, label_list, x_scale, y_scale, z_scale,
     labels_to_compute, labels_to_remove, img_in, label_in, normalization_parameters=None, channels=None):
 
-    # read image lists
-    if any(img_list):
-        img_names, label_names = read_img_list(img_list, label_list)
-        InputError.img_names = img_names
-        InputError.label_names = label_names
-
-    # load first label
-    if any(img_list):
-        a, _, _ = load_data(label_names[0], 'first_queue', True)
-        if a is None:
-            InputError.message = f'Invalid label data "{os.path.basename(label_names[0])}"'
-            raise InputError()
-    elif type(label_in) is list:
-        a = label_in[0]
-    else:
-        a = label_in
-    a = a.astype(np.uint8)
-    a = set_labels_to_zero(a, labels_to_compute, labels_to_remove)
-    label_z = np.any(a,axis=(1,2))
-    label_y = np.any(a,axis=(0,2))
-    label_x = np.any(a,axis=(0,1))
-    label = np.append(label_z,label_y,axis=0)
-    label = np.append(label,label_x,axis=0)
-
-    # load first img
-    if any(img_list):
-        img, _ = load_data(img_names[0], 'first_queue')
-        if img is None:
-            InputError.message = f'Invalid image data "{os.path.basename(img_names[0])}"'
-            raise InputError()
-    elif type(img_in) is list:
-        img = img_in[0]
-    else:
-        img = img_in
-    # handle all images having channels >=1
-    if len(img.shape)==3:
-        z_shape, y_shape, x_shape = img.shape
-        img = img.reshape(z_shape, y_shape, x_shape, 1)
-    if channels is None:
-        channels = img.shape[3]
-    if img.shape[3] != channels:
-        InputError.message = f'Number of channels must be {channels} for "{os.path.basename(img_names[0])}"'
-        raise InputError()
-    img = img.astype(np.float32)
-    img_z = img_resize(img, a.shape[0], y_scale, x_scale)
-    img_y = np.swapaxes(img_resize(img, z_scale, a.shape[1], x_scale),0,1)
-    img_x = np.swapaxes(img_resize(img, z_scale, y_scale, a.shape[2]),0,2)
-    img = np.append(img_z,img_y,axis=0)
-    img = np.append(img,img_x,axis=0)
+    # make temporary directories
+    with tempfile.TemporaryDirectory() as temp_img_dir:
+        with tempfile.TemporaryDirectory() as temp_label_dir:
 
-    # normalize image data
-    for c in range(channels):
-        img[:,:,:,c] -= np.amin(img[:,:,:,c])
-        img[:,:,:,c] /= np.amax(img[:,:,:,c])
-        if normalization_parameters is None:
-            normalization_parameters = np.zeros((2,channels))
-            normalization_parameters[0,c] = np.mean(img[:,:,:,c])
-            normalization_parameters[1,c] = np.std(img[:,:,:,c])
-        elif normalize:
-            mean, std = np.mean(img[:,:,:,c]), np.std(img[:,:,:,c])
-            img[:,:,:,c] = (img[:,:,:,c] - mean) / std
-            img[:,:,:,c] = img[:,:,:,c] * normalization_parameters[1,c] + normalization_parameters[0,c]
-
-    # loop over list of images
-    if any(img_list) or type(img_in) is list:
-        number_of_images = len(img_names) if any(img_list) else len(img_in)
-
-        for k in range(1, number_of_images):
+            # read image lists
+            if any(img_list):
+                img_names, label_names = read_img_list(img_list, label_list, temp_img_dir, temp_label_dir)
 
-            # append label
-            if any(label_list):
-                a, _ = load_data(label_names[k], 'first_queue')
+            # load first label
+            if any(img_list):
+                a, _, _ = load_data(label_names[0], 'first_queue', True)
                 if a is None:
-                    InputError.message = f'Invalid label data "{os.path.basename(label_names[k])}"'
+                    InputError.message = f'Invalid label data "{os.path.basename(label_names[0])}"'
                     raise InputError()
+            elif type(label_in) is list:
+                a = label_in[0]
             else:
-                a = label_in[k]
+                a = label_in
             a = a.astype(np.uint8)
             a = set_labels_to_zero(a, labels_to_compute, labels_to_remove)
-            next_label_z = np.any(a,axis=(1,2))
-            next_label_y = np.any(a,axis=(0,2))
-            next_label_x = np.any(a,axis=(0,1))
-            label = np.append(label,next_label_z,axis=0)
-            label = np.append(label,next_label_y,axis=0)
-            label = np.append(label,next_label_x,axis=0)
-
-            # append image
+            label_z = np.any(a,axis=(1,2))
+            label_y = np.any(a,axis=(0,2))
+            label_x = np.any(a,axis=(0,1))
+            label = np.append(label_z,label_y,axis=0)
+            label = np.append(label,label_x,axis=0)
+
+            # load first img
             if any(img_list):
-                a, _ = load_data(img_names[k], 'first_queue')
-                if a is None:
-                    InputError.message = f'Invalid image data "{os.path.basename(img_names[k])}"'
+                img, _ = load_data(img_names[0], 'first_queue')
+                if img is None:
+                    InputError.message = f'Invalid image data "{os.path.basename(img_names[0])}"'
                     raise InputError()
+            elif type(img_in) is list:
+                img = img_in[0]
             else:
-                a = img_in[k]
-            if len(a.shape)==3:
-                z_shape, y_shape, x_shape = a.shape
-                a = a.reshape(z_shape, y_shape, x_shape, 1)
-            if a.shape[3] != channels:
-                InputError.message = f'Number of channels must be {channels} for "{os.path.basename(img_names[k])}"'
+                img = img_in
+            # handle all images having channels >=1
+            if len(img.shape)==3:
+                z_shape, y_shape, x_shape = img.shape
+                img = img.reshape(z_shape, y_shape, x_shape, 1)
+            if channels is None:
+                channels = img.shape[3]
+            if img.shape[3] != channels:
+                InputError.message = f'Number of channels must be {channels} for "{os.path.basename(img_names[0])}"'
                 raise InputError()
-            a = a.astype(np.float32)
-            img_z = img_resize(a, a.shape[0], y_scale, x_scale)
-            img_y = np.swapaxes(img_resize(a, z_scale, a.shape[1], x_scale),0,1)
-            img_x = np.swapaxes(img_resize(a, z_scale, y_scale, a.shape[2]),0,2)
-            next_img = np.append(img_z,img_y,axis=0)
-            next_img = np.append(next_img,img_x,axis=0)
+            img = img.astype(np.float32)
+            img_z = img_resize(img, a.shape[0], y_scale, x_scale)
+            img_y = np.swapaxes(img_resize(img, z_scale, a.shape[1], x_scale),0,1)
+            img_x = np.swapaxes(img_resize(img, z_scale, y_scale, a.shape[2]),0,2)
+            img = np.append(img_z,img_y,axis=0)
+            img = np.append(img,img_x,axis=0)
+
+            # normalize image data
             for c in range(channels):
-                next_img[:,:,:,c] -= np.amin(next_img[:,:,:,c])
-                next_img[:,:,:,c] /= np.amax(next_img[:,:,:,c])
-                if normalize:
-                    mean, std = np.mean(next_img[:,:,:,c]), np.std(next_img[:,:,:,c])
-                    next_img[:,:,:,c] = (next_img[:,:,:,c] - mean) / std
-                    next_img[:,:,:,c] = next_img[:,:,:,c] * normalization_parameters[1,c] + normalization_parameters[0,c]
-            img = np.append(img, next_img, axis=0)
-
-    # remove extracted data
-    if any(img_list):
-        remove_extracted_data(img_names, label_names)
+                img[:,:,:,c] -= np.amin(img[:,:,:,c])
+                img[:,:,:,c] /= np.amax(img[:,:,:,c])
+                if normalization_parameters is None:
+                    normalization_parameters = np.zeros((2,channels))
+                    normalization_parameters[0,c] = np.mean(img[:,:,:,c])
+                    normalization_parameters[1,c] = np.std(img[:,:,:,c])
+                elif normalize:
+                    mean, std = np.mean(img[:,:,:,c]), np.std(img[:,:,:,c])
+                    img[:,:,:,c] = (img[:,:,:,c] - mean) / std
+                    img[:,:,:,c] = img[:,:,:,c] * normalization_parameters[1,c] + normalization_parameters[0,c]
+
+            # loop over list of images
+            if any(img_list) or type(img_in) is list:
+                number_of_images = len(img_names) if any(img_list) else len(img_in)
+
+                for k in range(1, number_of_images):
+
+                    # append label
+                    if any(label_list):
+                        a, _ = load_data(label_names[k], 'first_queue')
+                        if a is None:
+                            InputError.message = f'Invalid label data "{os.path.basename(label_names[k])}"'
+                            raise InputError()
+                    else:
+                        a = label_in[k]
+                    a = a.astype(np.uint8)
+                    a = set_labels_to_zero(a, labels_to_compute, labels_to_remove)
+                    next_label_z = np.any(a,axis=(1,2))
+                    next_label_y = np.any(a,axis=(0,2))
+                    next_label_x = np.any(a,axis=(0,1))
+                    label = np.append(label,next_label_z,axis=0)
+                    label = np.append(label,next_label_y,axis=0)
+                    label = np.append(label,next_label_x,axis=0)
+
+                    # append image
+                    if any(img_list):
+                        a, _ = load_data(img_names[k], 'first_queue')
+                        if a is None:
+                            InputError.message = f'Invalid image data "{os.path.basename(img_names[k])}"'
+                            raise InputError()
+                    else:
+                        a = img_in[k]
+                    if len(a.shape)==3:
+                        z_shape, y_shape, x_shape = a.shape
+                        a = a.reshape(z_shape, y_shape, x_shape, 1)
+                    if a.shape[3] != channels:
+                        InputError.message = f'Number of channels must be {channels} for "{os.path.basename(img_names[k])}"'
+                        raise InputError()
+                    a = a.astype(np.float32)
+                    img_z = img_resize(a, a.shape[0], y_scale, x_scale)
+                    img_y = np.swapaxes(img_resize(a, z_scale, a.shape[1], x_scale),0,1)
+                    img_x = np.swapaxes(img_resize(a, z_scale, y_scale, a.shape[2]),0,2)
+                    next_img = np.append(img_z,img_y,axis=0)
+                    next_img = np.append(next_img,img_x,axis=0)
+                    for c in range(channels):
+                        next_img[:,:,:,c] -= np.amin(next_img[:,:,:,c])
+                        next_img[:,:,:,c] /= np.amax(next_img[:,:,:,c])
+                        if normalize:
+                            mean, std = np.mean(next_img[:,:,:,c]), np.std(next_img[:,:,:,c])
+                            next_img[:,:,:,c] = (next_img[:,:,:,c] - mean) / std
+                            next_img[:,:,:,c] = next_img[:,:,:,c] * normalization_parameters[1,c] + normalization_parameters[0,c]
+                    img = np.append(img, next_img, axis=0)
 
     # limit intensity range
     img[img<0] = 0
@@ -359,8 +356,6 @@ def load_data_to_crop(path_to_img, channels, x_scale, y_scale, z_scale,
     # read image data
     if img is None:
         img, _, _ = load_data(path_to_img, 'first_queue', return_extension=True)
-        InputError.img_names = [path_to_img]
-        InputError.label_names = []
     img_data = np.copy(img, order='C')
     if img is None:
         InputError.message = "Invalid image data %s." %(os.path.basename(path_to_img))