def predict_semantic_segmentation(img, position, path_to_model, path_to_final, z_patch, y_patch, x_patch, z_shape, y_shape, x_shape, compress, header, img_header, channels, stride_size, allLabels, batch_size, region_of_interest): # img shape zsh, ysh, xsh = img.shape # list of IDs list_IDs = [] # get nIds of patches for k in range(0, zsh - z_patch + 1, stride_size): for l in range(0, ysh - y_patch + 1, stride_size): for m in range(0, xsh - x_patch + 1, stride_size): list_IDs.append(k * ysh * xsh + l * xsh + m) # make length of list divisible by batch size rest = batch_size - (len(list_IDs) % batch_size) list_IDs = list_IDs + list_IDs[:rest] # parameters params = { 'dim': (z_patch, y_patch, x_patch), 'dim_img': (zsh, ysh, xsh), 'batch_size': batch_size, 'n_channels': channels } # data generator predict_generator = PredictDataGenerator(img, position, list_IDs, **params) # create a MirroredStrategy if os.name == 'nt': cdo = tf.distribute.HierarchicalCopyAllReduce() else: cdo = tf.distribute.NcclAllReduce() strategy = tf.distribute.MirroredStrategy(cross_device_ops=cdo) # load model with strategy.scope(): model = load_model(str(path_to_model)) # predict probabilities = model.predict(predict_generator, verbose=0, steps=None) # create final final = np.zeros((zsh, ysh, xsh, probabilities.shape[4]), dtype=np.float32) nb = 0 for k in range(0, zsh - z_patch + 1, stride_size): for l in range(0, ysh - y_patch + 1, stride_size): for m in range(0, xsh - x_patch + 1, stride_size): final[k:k + z_patch, l:l + y_patch, m:m + x_patch] += probabilities[nb] nb += 1 # get final out = np.argmax(final, axis=3) out = out.astype(np.uint8) # rescale final to input size np_unique = np.unique(out) label = np.zeros((z_shape, y_shape, x_shape), dtype=out.dtype) for k in np_unique: tmp = np.zeros_like(out) tmp[out == k] = 1 tmp = img_resize(tmp, z_shape, y_shape, x_shape) label[tmp == 1] = k # revert automatic cropping if np.any(region_of_interest): min_z, max_z, min_y, max_y, min_x, max_x, z_shape, y_shape, x_shape = region_of_interest[:] tmp = np.zeros((z_shape, y_shape, x_shape), dtype=out.dtype) tmp[min_z:max_z, min_y:max_y, min_x:max_x] = label label = np.copy(tmp) # save final label = label.astype(np.uint8) label = get_labels(label, allLabels) if header is not None: header = get_image_dimensions(header, label) if img_header is not None: try: header = get_physical_size(header, img_header) except: pass save_data(path_to_final, label, header=header, compress=compress)
def refine_semantic_segmentation(path_to_img, path_to_final, path_to_model, patch_size, compress, header, img_header, normalize, stride_size, allLabels, mu, sig, batch_size): # load refine data img, label, final, z_shape, y_shape, x_shape = load_refine_data( path_to_img, path_to_final, patch_size, normalize, allLabels, mu, sig) # get number of 3D-patches nb = 0 zsh, ysh, xsh = img.shape for k in range(0, zsh - patch_size + 1, stride_size): for l in range(0, ysh - patch_size + 1, stride_size): for m in range(0, xsh - patch_size + 1, stride_size): tmp = label[k:k + patch_size, l:l + patch_size, m:m + patch_size] #if 0.1 * patch_size**3 < np.sum(tmp > 0) < 0.9 * patch_size**3: if np.any(tmp[1:] != tmp[0, 0, 0]): nb += 1 # create prediction set x_test = np.empty((nb, patch_size, patch_size, patch_size, 2), dtype=img.dtype) nb = 0 zsh, ysh, xsh = img.shape for k in range(0, zsh - patch_size + 1, stride_size): for l in range(0, ysh - patch_size + 1, stride_size): for m in range(0, xsh - patch_size + 1, stride_size): tmp = label[k:k + patch_size, l:l + patch_size, m:m + patch_size] #if 0.1 * patch_size**3 < np.sum(tmp > 0) < 0.9 * patch_size**3: if np.any(tmp[1:] != tmp[0, 0, 0]): x_test[nb, :, :, :, 0] = img[k:k + patch_size, l:l + patch_size, m:m + patch_size] x_test[nb, :, :, :, 1] = final[k:k + patch_size, l:l + patch_size, m:m + patch_size] nb += 1 # reshape prediction data x_test = x_test.reshape(nb, patch_size, patch_size, patch_size, 2) # create a MirroredStrategy if os.name == 'nt': cdo = tf.distribute.HierarchicalCopyAllReduce() else: cdo = tf.distribute.NcclAllReduce() strategy = tf.distribute.MirroredStrategy(cross_device_ops=cdo) # load model with strategy.scope(): model = load_model(str(path_to_model)) # predict prob = model.predict(x_test, batch_size=batch_size, verbose=0, steps=None) # create final nb = 0 zsh, ysh, xsh = img.shape final = np.zeros((zsh, ysh, xsh, prob.shape[4]), dtype=np.float32) for k in range(0, zsh - patch_size + 1, stride_size): for l in range(0, ysh - patch_size + 1, stride_size): for m in range(0, xsh - patch_size + 1, stride_size): tmp = label[k:k + patch_size, l:l + patch_size, m:m + patch_size] #if 0.1 * patch_size**3 < np.sum(tmp > 0) < 0.9 * patch_size**3: if np.any(tmp[1:] != tmp[0, 0, 0]): final[k:k + patch_size, l:l + patch_size, m:m + patch_size] += prob[nb] nb += 1 final = np.argmax(final, axis=3) final = final.astype(np.uint8) out = np.copy(label) for k in range(0, zsh - patch_size + 1, stride_size): for l in range(0, ysh - patch_size + 1, stride_size): for m in range(0, xsh - patch_size + 1, stride_size): tmp = label[k:k + patch_size, l:l + patch_size, m:m + patch_size] #if 0.1 * patch_size**3 < np.sum(tmp > 0) < 0.9 * patch_size**3: if np.any(tmp[1:] != tmp[0, 0, 0]): out[k:k + patch_size, l:l + patch_size, m:m + patch_size] = final[k:k + patch_size, l:l + patch_size, m:m + patch_size] # save final out = out.astype(np.uint8) out = get_labels(out, allLabels) out = out[:z_shape, :y_shape, :x_shape] if header is not None: header = get_image_dimensions(header, out) if img_header is not None: try: header = get_physical_size(header, img_header) except: pass save_data(path_to_final, out, header=header, compress=compress)
def _diffusion_child(comm, bm=None): rank = comm.Get_rank() ngpus = comm.Get_size() nodename = socket.gethostname() name = '%s %s' %(nodename, rank) print(name) if rank == 0: # split indices on GPUs indices_split = _split_indices(bm.indices, ngpus) print('Indices:', indices_split) # send data to GPUs for k in range(1, ngpus): sendToChild(comm, bm.indices, indices_split[k], k, bm.data, bm.labels, bm.label.nbrw, bm.label.sorw, bm.label.allaxis) # init cuda device cuda.init() dev = cuda.Device(rank) ctx = dev.make_context() # select the desired script if bm.label.allaxis: from pycuda_small_allx import walk else: from pycuda_small import walk # run random walks tic = time.time() walkmap = walk(bm.data, bm.labels, bm.indices, indices_split[0], bm.label.nbrw, bm.label.sorw, name) tac = time.time() print('Walktime_%s: ' %(name) + str(int(tac - tic)) + ' ' + 'seconds') # gather data zsh_tmp = bm.argmax_z - bm.argmin_z ysh_tmp = bm.argmax_y - bm.argmin_y xsh_tmp = bm.argmax_x - bm.argmin_x if ngpus > 1: final_zero = np.empty((bm.nol, zsh_tmp, ysh_tmp, xsh_tmp), dtype=np.float32) for k in range(bm.nol): sendbuf = np.copy(walkmap[k]) recvbuf = np.empty((zsh_tmp, ysh_tmp, xsh_tmp), dtype=np.float32) comm.Barrier() comm.Reduce([sendbuf, MPI.FLOAT], [recvbuf, MPI.FLOAT], root=0, op=MPI.SUM) final_zero[k] = recvbuf else: final_zero = walkmap # block and grid size block = (32, 32, 1) x_grid = (xsh_tmp // 32) + 1 y_grid = (ysh_tmp // 32) + 1 grid = (int(x_grid), int(y_grid), int(zsh_tmp)) xsh_gpu = np.int32(xsh_tmp) ysh_gpu = np.int32(ysh_tmp) # smooth if bm.label.smooth: try: update_gpu = _build_update_gpu() curvature_gpu = _build_curvature_gpu() a_gpu = gpuarray.empty((zsh_tmp, ysh_tmp, xsh_tmp), dtype=np.float32) b_gpu = gpuarray.zeros((zsh_tmp, ysh_tmp, xsh_tmp), dtype=np.float32) except Exception as e: print('Warning: GPU out of memory to allocate smooth array. Process starts without smoothing.') bm.label.smooth = 0 if bm.label.smooth: final_smooth = np.copy(final_zero) for k in range(bm.nol): a_gpu = gpuarray.to_gpu(final_smooth[k]) for l in range(bm.label.smooth): curvature_gpu(a_gpu, b_gpu, xsh_gpu, ysh_gpu, block=block, grid=grid) update_gpu(a_gpu, b_gpu, xsh_gpu, ysh_gpu, block=block, grid=grid) final_smooth[k] = a_gpu.get() final_smooth = np.argmax(final_smooth, axis=0).astype(np.uint8) final_smooth = get_labels(final_smooth, bm.allLabels) final = np.zeros((bm.zsh, bm.ysh, bm.xsh), dtype=np.uint8) final[bm.argmin_z:bm.argmax_z, bm.argmin_y:bm.argmax_y, bm.argmin_x:bm.argmax_x] = final_smooth final = final[1:-1, 1:-1, 1:-1] bm.path_to_smooth = unique_file_path(bm.path_to_smooth, bm.image.user.username) save_data(bm.path_to_smooth, final, bm.header, bm.final_image_type, bm.label.compression) # uncertainty if bm.label.uncertainty: try: max_gpu = gpuarray.zeros((3, zsh_tmp, ysh_tmp, xsh_tmp), dtype=np.float32) a_gpu = gpuarray.zeros((zsh_tmp, ysh_tmp, xsh_tmp), dtype=np.float32) kernel_uncertainty = _build_kernel_uncertainty() kernel_max = _build_kernel_max() for k in range(bm.nol): a_gpu = gpuarray.to_gpu(final_zero[k]) kernel_max(max_gpu, a_gpu, xsh_gpu, ysh_gpu, block=block, grid=grid) kernel_uncertainty(max_gpu, a_gpu, xsh_gpu, ysh_gpu, block=block, grid=grid) uq = a_gpu.get() uq *= 255 uq = uq.astype(np.uint8) final = np.zeros((bm.zsh, bm.ysh, bm.xsh), dtype=np.uint8) final[bm.argmin_z:bm.argmax_z, bm.argmin_y:bm.argmax_y, bm.argmin_x:bm.argmax_x] = uq final = final[1:-1, 1:-1, 1:-1] bm.path_to_uq = unique_file_path(bm.path_to_uq, bm.image.user.username) save_data(bm.path_to_uq, final, compress=bm.label.compression) except Exception as e: print('Warning: GPU out of memory to allocate uncertainty array. Process starts without uncertainty.') bm.label.uncertainty = False # free device ctx.pop() del ctx # argmax final_zero = np.argmax(final_zero, axis=0).astype(np.uint8) # save finals final_zero = get_labels(final_zero, bm.allLabels) final = np.zeros((bm.zsh, bm.ysh, bm.xsh), dtype=np.uint8) final[bm.argmin_z:bm.argmax_z, bm.argmin_y:bm.argmax_y, bm.argmin_x:bm.argmax_x] = final_zero final = final[1:-1, 1:-1, 1:-1] bm.path_to_final = unique_file_path(bm.path_to_final, bm.image.user.username) save_data(bm.path_to_final, final, bm.header, bm.final_image_type, bm.label.compression) # create final objects shortfilename = os.path.basename(bm.path_to_final) filename = 'images/' + bm.image.user.username + '/' + shortfilename tmp = Upload.objects.create(pic=filename, user=bm.image.user, project=bm.image.project, final=1, active=1, imageType=3, shortfilename=shortfilename) tmp.friend = tmp.id tmp.save() if bm.label.uncertainty: shortfilename = os.path.basename(bm.path_to_uq) filename = 'images/' + bm.image.user.username + '/' + shortfilename Upload.objects.create(pic=filename, user=bm.image.user, project=bm.image.project, final=4, imageType=3, shortfilename=shortfilename, friend=tmp.id) if bm.label.smooth: shortfilename = os.path.basename(bm.path_to_smooth) filename = 'images/' + bm.image.user.username + '/' + shortfilename smooth = Upload.objects.create(pic=filename, user=bm.image.user, project=bm.image.project, final=5, imageType=3, shortfilename=shortfilename, friend=tmp.id) # write in logs t = int(time.time() - bm.TIC) if t < 60: time_str = str(t) + ' sec' elif 60 <= t < 3600: time_str = str(t // 60) + ' min ' + str(t % 60) + ' sec' elif 3600 < t: time_str = str(t // 3600) + ' h ' + str((t % 3600) // 60) + ' min ' + str(t % 60) + ' sec' with open(bm.path_to_time, 'a') as timefile: print('%s %s %s %s MB %s on %s' %(time.ctime(), bm.image.user.username, bm.image.shortfilename, bm.imageSize, time_str, config['SERVER_ALIAS']), file=timefile) print('Total calculation time:', time_str) # send notification send_notification(bm.image.user.username, bm.image.shortfilename, time_str, config['SERVER_ALIAS']) # start subprocesses if config['OS'] == 'linux': # acwe q = Queue('acwe', connection=Redis()) job = q.enqueue_call(active_contour, args=(bm.image.id, tmp.id, bm.label.id,), timeout=-1) # cleanup q = Queue('cleanup', connection=Redis()) job = q.enqueue_call(remove_outlier, args=(bm.image.id, tmp.id, tmp.id, bm.label.id,), timeout=-1) if bm.label.smooth: job = q.enqueue_call(remove_outlier, args=(bm.image.id, smooth.id, tmp.id, bm.label.id, False,), timeout=-1) # create slices q = Queue('slices', connection=Redis()) job = q.enqueue_call(create_slices, args=(bm.path_to_data, bm.path_to_final,), timeout=-1) if bm.label.smooth: job = q.enqueue_call(create_slices, args=(bm.path_to_data, bm.path_to_smooth,), timeout=-1) if bm.label.uncertainty: job = q.enqueue_call(create_slices, args=(bm.path_to_uq, None,), timeout=-1) elif config['OS'] == 'windows': # acwe Process(target=active_contour, args=(bm.image.id, tmp.id, bm.label.id)).start() # cleanup Process(target=remove_outlier, args=(bm.image.id, tmp.id, tmp.id, bm.label.id)).start() if bm.label.smooth: Process(target=remove_outlier, args=(bm.image.id, smooth.id, tmp.id, bm.label.id, False)).start() # create slices Process(target=create_slices, args=(bm.path_to_data, bm.path_to_final)).start() if bm.label.smooth: Process(target=create_slices, args=(bm.path_to_data, bm.path_to_smooth)).start() if bm.label.uncertainty: Process(target=create_slices, args=(bm.path_to_uq, None)).start() else: data_z, data_y, data_x, data_dtype = comm.recv(source=0, tag=0) data = np.empty((data_z, data_y, data_x), dtype=data_dtype) if data_dtype == 'uint8': comm.Recv([data, MPI.BYTE], source=0, tag=1) else: comm.Recv([data, MPI.FLOAT], source=0, tag=1) allx, nbrw, sorw = comm.recv(source=0, tag=2) if allx: labels = [] for k in range(3): labels_z, labels_y, labels_x = comm.recv(source=0, tag=k+3) labels_tmp = np.empty((labels_z, labels_y, labels_x), dtype=np.int32) comm.Recv([labels_tmp, MPI.INT], source=0, tag=k+6) labels.append(labels_tmp) else: labels_z, labels_y, labels_x = comm.recv(source=0, tag=3) labels = np.empty((labels_z, labels_y, labels_x), dtype=np.int32) comm.Recv([labels, MPI.INT], source=0, tag=6) indices = comm.recv(source=0, tag=9) indices_child = comm.recv(source=0, tag=10) # init cuda device cuda.init() dev = cuda.Device(rank) ctx = dev.make_context() # select the desired script if allx: from pycuda_small_allx import walk else: from pycuda_small import walk # run random walks tic = time.time() walkmap = walk(data, labels, indices, indices_child, nbrw, sorw, name) tac = time.time() print('Walktime_%s: ' %(name) + str(int(tac - tic)) + ' ' + 'seconds') # free device ctx.pop() del ctx # send data for k in range(walkmap.shape[0]): datatemporaer = np.copy(walkmap[k]) comm.Barrier() comm.Reduce([datatemporaer, MPI.FLOAT], None, root=0, op=MPI.SUM)
def active_contour(image_id, friend_id, label_id): # time TIC = time.time() # create biomedisa bm = Biomedisa() # path to logfiles bm.path_to_time = config['PATH_TO_BIOMEDISA'] + '/log/time.txt' bm.path_to_logfile = config['PATH_TO_BIOMEDISA'] + '/log/logfile.txt' # get objects try: bm.image = Upload.objects.get(pk=image_id) bm.label = Upload.objects.get(pk=label_id) friend = Upload.objects.get(pk=friend_id) bm.success = True except Upload.DoesNotExist: bm.success = False # path to data bm.path_to_data = bm.image.pic.path bm.path_to_labels = friend.pic.path # pre-processing if bm.success: bm.process = 'acwe' bm = pre_processing(bm) if bm.success: # final filename filename, extension = os.path.splitext(bm.path_to_labels) if extension == '.gz': filename = filename[:-4] bm.path_to_acwe = filename + '.acwe' + bm.final_image_type # data type bm.data = img_to_uint8(bm.data) # get acwe parameters alpha = bm.label.ac_alpha smooth = bm.label.ac_smooth steps = bm.label.ac_steps # run acwe final = activeContour(bm.data, bm.labelData, alpha, smooth, steps) try: # check if final still exists friend = Upload.objects.get(pk=friend_id) # save result bm.path_to_acwe = unique_file_path(bm.path_to_acwe, bm.image.user.username) save_data(bm.path_to_acwe, final, bm.header, bm.final_image_type, bm.label.compression) # save django object shortfilename = os.path.basename(bm.path_to_acwe) pic_path = 'images/' + bm.image.user.username + '/' + shortfilename Upload.objects.create(pic=pic_path, user=bm.image.user, project=friend.project, final=3, imageType=3, shortfilename=shortfilename, friend=friend_id) # create slices if config['OS'] == 'linux': q = Queue('slices', connection=Redis()) job = q.enqueue_call(create_slices, args=( bm.path_to_data, bm.path_to_acwe, ), timeout=-1) elif config['OS'] == 'windows': Process(target=create_slices, args=(bm.path_to_data, bm.path_to_acwe)).start() except Upload.DoesNotExist: pass
def _diffusion_child(comm, bm=None): rank = comm.Get_rank() ngpus = comm.Get_size() nodename = socket.gethostname() name = '%s %s' % (nodename, rank) print(name) if rank == 0: # reduce blocksize bm.data = np.copy(bm.data[bm.argmin_z:bm.argmax_z, bm.argmin_y:bm.argmax_y, bm.argmin_x:bm.argmax_x], order='C') bm.labelData = np.copy(bm.labelData[bm.argmin_z:bm.argmax_z, bm.argmin_y:bm.argmax_y, bm.argmin_x:bm.argmax_x], order='C') # domain decomposition sizeofblocks = (bm.argmax_z - bm.argmin_z) // ngpus blocks = [0] for k in range(ngpus - 1): block_temp = blocks[-1] + sizeofblocks blocks.append(block_temp) blocks.append(bm.argmax_z - bm.argmin_z) print('blocks =', blocks) # read labeled slices if bm.label.allaxis: tmp = np.swapaxes(bm.labelData, 0, 1) tmp = np.ascontiguousarray(tmp) indices_01, _ = read_labeled_slices_allx(tmp) tmp = np.swapaxes(tmp, 0, 2) tmp = np.ascontiguousarray(tmp) indices_02, _ = read_labeled_slices_allx(tmp) # send data to childs for destination in range(ngpus - 1, -1, -1): # ghost blocks blockmin = blocks[destination] blockmax = blocks[destination + 1] datablockmin = blockmin - 100 datablockmax = blockmax + 100 datablockmin = 0 if datablockmin < 0 else datablockmin datablockmax = (bm.argmax_z - bm.argmin_z) if datablockmax > ( bm.argmax_z - bm.argmin_z) else datablockmax datablock = np.copy(bm.data[datablockmin:datablockmax], order='C') labelblock = np.copy(bm.labelData[datablockmin:datablockmax], order='C') # read labeled slices if bm.label.allaxis: labelblock[:blockmin - datablockmin] = -1 labelblock[blockmax - datablockmin:] = -1 indices_child, labels_child = [], [] indices_00, labels_00 = read_labeled_slices_allx(labelblock) indices_child.append(indices_00) labels_child.append(labels_00) tmp = np.swapaxes(labelblock, 0, 1) tmp = np.ascontiguousarray(tmp) labels_01 = np.zeros((0, tmp.shape[1], tmp.shape[2]), dtype=np.int32) for slcIndex in indices_01: labels_01 = np.append(labels_01, [tmp[slcIndex]], axis=0) indices_child.append(indices_01) labels_child.append(labels_01) tmp = np.swapaxes(tmp, 0, 2) tmp = np.ascontiguousarray(tmp) labels_02 = np.zeros((0, tmp.shape[1], tmp.shape[2]), dtype=np.int32) for slcIndex in indices_02: labels_02 = np.append(labels_02, [tmp[slcIndex]], axis=0) indices_child.append(indices_02) labels_child.append(labels_02) else: labelblock[:blockmin - datablockmin] = 0 labelblock[blockmax - datablockmin:] = 0 indices_child, labels_child = read_labeled_slices(labelblock) # print indices of labels print('indices child %s:' % (destination), indices_child) if destination > 0: blocks_temp = blocks[:] blocks_temp[destination] = blockmin - datablockmin blocks_temp[destination + 1] = blockmax - datablockmin dataListe = splitlargedata(datablock) sendToChild(comm, indices_child, destination, dataListe, labels_child, bm.label.nbrw, bm.label.sorw, blocks_temp, bm.label.allaxis, bm.allLabels, bm.label.smooth, bm.label.uncertainty) else: # select the desired script if bm.label.allaxis: from pycuda_large_allx import walk else: from pycuda_large import walk # init cuda device cuda.init() dev = cuda.Device(rank) ctx = dev.make_context() queue = None # run random walks tic = time.time() memory_error, final, final_uncertainty, final_smooth = walk( comm, datablock, labels_child, indices_child, bm.label.nbrw, bm.label.sorw, blockmin - datablockmin, blockmax - datablockmin, name, bm.allLabels, bm.label.smooth, bm.label.uncertainty, ctx, queue) tac = time.time() print('Walktime_%s: ' % (name) + str(int(tac - tic)) + ' ' + 'seconds') # free device ctx.pop() del ctx if memory_error: bm = _error_(bm, 'GPU out of memory. Image too large.') else: # gather data for source in range(1, ngpus): lendataListe = comm.recv(source=source, tag=0) for l in range(lendataListe): data_z, data_y, data_x = comm.recv(source=source, tag=10 + (2 * l)) receivedata = np.empty((data_z, data_y, data_x), dtype=np.uint8) comm.Recv([receivedata, MPI.BYTE], source=source, tag=10 + (2 * l + 1)) final = np.append(final, receivedata, axis=0) # save finals final2 = np.zeros((bm.zsh, bm.ysh, bm.xsh), dtype=np.uint8) final2[bm.argmin_z:bm.argmax_z, bm.argmin_y:bm.argmax_y, bm.argmin_x:bm.argmax_x] = final final2 = final2[1:-1, 1:-1, 1:-1] bm.path_to_final = unique_file_path(bm.path_to_final, bm.image.user.username) save_data(bm.path_to_final, final2, bm.header, bm.final_image_type, bm.label.compression) # uncertainty if final_uncertainty is not None: final_uncertainty *= 255 final_uncertainty = final_uncertainty.astype(np.uint8) for source in range(1, ngpus): lendataListe = comm.recv(source=source, tag=0) for l in range(lendataListe): data_z, data_y, data_x = comm.recv(source=source, tag=10 + (2 * l)) receivedata = np.empty((data_z, data_y, data_x), dtype=np.uint8) comm.Recv([receivedata, MPI.BYTE], source=source, tag=10 + (2 * l + 1)) final_uncertainty = np.append(final_uncertainty, receivedata, axis=0) # save finals final2 = np.zeros((bm.zsh, bm.ysh, bm.xsh), dtype=np.uint8) final2[bm.argmin_z:bm.argmax_z, bm.argmin_y:bm.argmax_y, bm.argmin_x:bm.argmax_x] = final_uncertainty final2 = final2[1:-1, 1:-1, 1:-1] bm.path_to_uq = unique_file_path(bm.path_to_uq, bm.image.user.username) save_data(bm.path_to_uq, final2, compress=bm.label.compression) # smooth if final_smooth is not None: for source in range(1, ngpus): lendataListe = comm.recv(source=source, tag=0) for l in range(lendataListe): data_z, data_y, data_x = comm.recv(source=source, tag=10 + (2 * l)) receivedata = np.empty((data_z, data_y, data_x), dtype=np.uint8) comm.Recv([receivedata, MPI.BYTE], source=source, tag=10 + (2 * l + 1)) final_smooth = np.append(final_smooth, receivedata, axis=0) # save finals final2 = np.zeros((bm.zsh, bm.ysh, bm.xsh), dtype=np.uint8) final2[bm.argmin_z:bm.argmax_z, bm.argmin_y:bm.argmax_y, bm.argmin_x:bm.argmax_x] = final_smooth final2 = final2[1:-1, 1:-1, 1:-1] bm.path_to_smooth = unique_file_path(bm.path_to_smooth, bm.image.user.username) save_data(bm.path_to_smooth, final2, bm.header, bm.final_image_type, bm.label.compression) # create final objects shortfilename = os.path.basename(bm.path_to_final) filename = 'images/' + bm.image.user.username + '/' + shortfilename tmp = Upload.objects.create(pic=filename, user=bm.image.user, project=bm.image.project, final=1, active=1, imageType=3, shortfilename=shortfilename) tmp.friend = tmp.id tmp.save() if final_uncertainty is not None: shortfilename = os.path.basename(bm.path_to_uq) filename = 'images/' + bm.image.user.username + '/' + shortfilename Upload.objects.create(pic=filename, user=bm.image.user, project=bm.image.project, final=4, imageType=3, shortfilename=shortfilename, friend=tmp.id) if final_smooth is not None: shortfilename = os.path.basename(bm.path_to_smooth) filename = 'images/' + bm.image.user.username + '/' + shortfilename smooth = Upload.objects.create(pic=filename, user=bm.image.user, project=bm.image.project, final=5, imageType=3, shortfilename=shortfilename, friend=tmp.id) # write in logs t = int(time.time() - bm.TIC) if t < 60: time_str = str(t) + ' sec' elif 60 <= t < 3600: time_str = str(t // 60) + ' min ' + str(t % 60) + ' sec' elif 3600 < t: time_str = str(t // 3600) + ' h ' + str( (t % 3600) // 60) + ' min ' + str(t % 60) + ' sec' with open(bm.path_to_time, 'a') as timefile: print('%s %s %s %s MB %s on %s' % (time.ctime(), bm.image.user.username, bm.image.shortfilename, bm.imageSize, time_str, config['SERVER_ALIAS']), file=timefile) print('Total calculation time:', time_str) # send notification send_notification(bm.image.user.username, bm.image.shortfilename, time_str, config['SERVER_ALIAS']) # start subprocesses if config['OS'] == 'linux': # acwe q = Queue('acwe', connection=Redis()) job = q.enqueue_call(active_contour, args=( bm.image.id, tmp.id, bm.label.id, ), timeout=-1) # cleanup q = Queue('cleanup', connection=Redis()) job = q.enqueue_call(remove_outlier, args=( bm.image.id, tmp.id, tmp.id, bm.label.id, ), timeout=-1) if final_smooth is not None: job = q.enqueue_call(remove_outlier, args=( bm.image.id, smooth.id, tmp.id, bm.label.id, False, ), timeout=-1) # create slices q = Queue('slices', connection=Redis()) job = q.enqueue_call(create_slices, args=( bm.path_to_data, bm.path_to_final, ), timeout=-1) if final_smooth is not None: job = q.enqueue_call(create_slices, args=( bm.path_to_data, bm.path_to_smooth, ), timeout=-1) if final_uncertainty is not None: job = q.enqueue_call(create_slices, args=( bm.path_to_uq, None, ), timeout=-1) elif config['OS'] == 'windows': # acwe Process(target=active_contour, args=(bm.image.id, tmp.id, bm.label.id)).start() # cleanup Process(target=remove_outlier, args=(bm.image.id, tmp.id, tmp.id, bm.label.id)).start() if final_smooth is not None: Process(target=remove_outlier, args=(bm.image.id, smooth.id, tmp.id, bm.label.id, False)).start() # create slices Process(target=create_slices, args=(bm.path_to_data, bm.path_to_final)).start() if final_smooth is not None: Process(target=create_slices, args=(bm.path_to_data, bm.path_to_smooth)).start() if final_uncertainty is not None: Process(target=create_slices, args=(bm.path_to_uq, None)).start() else: lendataListe = comm.recv(source=0, tag=0) for k in range(lendataListe): data_z, data_y, data_x, data_dtype = comm.recv(source=0, tag=10 + (2 * k)) if k == 0: data = np.zeros((0, data_y, data_x), dtype=data_dtype) data_temp = np.empty((data_z, data_y, data_x), dtype=data_dtype) if data_dtype == 'uint8': comm.Recv([data_temp, MPI.BYTE], source=0, tag=10 + (2 * k + 1)) else: comm.Recv([data_temp, MPI.FLOAT], source=0, tag=10 + (2 * k + 1)) data = np.append(data, data_temp, axis=0) nbrw, sorw, allx, smooth, uncertainty = comm.recv(source=0, tag=1) if allx: labels = [] for k in range(3): lenlabelsListe = comm.recv(source=0, tag=2 + k) for l in range(lenlabelsListe): labels_z, labels_y, labels_x = comm.recv(source=0, tag=100 + (2 * k)) if l == 0: labels_tmp = np.zeros((0, labels_y, labels_x), dtype=np.int32) tmp = np.empty((labels_z, labels_y, labels_x), dtype=np.int32) comm.Recv([tmp, MPI.INT], source=0, tag=100 + (2 * k + 1)) labels_tmp = np.append(labels_tmp, tmp, axis=0) labels.append(labels_tmp) else: lenlabelsListe = comm.recv(source=0, tag=2) for k in range(lenlabelsListe): labels_z, labels_y, labels_x = comm.recv(source=0, tag=100 + (2 * k)) if k == 0: labels = np.zeros((0, labels_y, labels_x), dtype=np.int32) tmp = np.empty((labels_z, labels_y, labels_x), dtype=np.int32) comm.Recv([tmp, MPI.INT], source=0, tag=100 + (2 * k + 1)) labels = np.append(labels, tmp, axis=0) allLabels = comm.recv(source=0, tag=99) indices = comm.recv(source=0, tag=8) blocks = comm.recv(source=0, tag=9) blockmin = blocks[rank] blockmax = blocks[rank + 1] # select the desired script if allx: from pycuda_large_allx import walk else: from pycuda_large import walk # init cuda device cuda.init() dev = cuda.Device(rank) ctx = dev.make_context() queue = None # run random walks tic = time.time() memory_error, final, final_uncertainty, final_smooth = walk( comm, data, labels, indices, nbrw, sorw, blockmin, blockmax, name, allLabels, smooth, uncertainty, ctx, queue) tac = time.time() print('Walktime_%s: ' % (name) + str(int(tac - tic)) + ' ' + 'seconds') # free device ctx.pop() del ctx # send finals if not memory_error: dataListe = splitlargedata(final) comm.send(len(dataListe), dest=0, tag=0) for k, dataTemp in enumerate(dataListe): dataTemp = dataTemp.copy(order='C') comm.send( [dataTemp.shape[0], dataTemp.shape[1], dataTemp.shape[2]], dest=0, tag=10 + (2 * k)) comm.Send([dataTemp, MPI.BYTE], dest=0, tag=10 + (2 * k + 1)) if final_uncertainty is not None: final_uncertainty *= 255 final_uncertainty = final_uncertainty.astype(np.uint8) dataListe = splitlargedata(final_uncertainty) comm.send(len(dataListe), dest=0, tag=0) for k, dataTemp in enumerate(dataListe): dataTemp = dataTemp.copy(order='C') comm.send([ dataTemp.shape[0], dataTemp.shape[1], dataTemp.shape[2] ], dest=0, tag=10 + (2 * k)) comm.Send([dataTemp, MPI.BYTE], dest=0, tag=10 + (2 * k + 1)) if final_smooth is not None: dataListe = splitlargedata(final_smooth) comm.send(len(dataListe), dest=0, tag=0) for k, dataTemp in enumerate(dataListe): dataTemp = dataTemp.copy(order='C') comm.send([ dataTemp.shape[0], dataTemp.shape[1], dataTemp.shape[2] ], dest=0, tag=10 + (2 * k)) comm.Send([dataTemp, MPI.BYTE], dest=0, tag=10 + (2 * k + 1))
def remove_outlier(image_id, final_id, friend_id, label_id, fill_holes=True): # get objects try: image = Upload.objects.get(pk=image_id) final = Upload.objects.get(pk=final_id) friend = Upload.objects.get(pk=friend_id) label = Upload.objects.get(pk=label_id) success = True except Upload.DoesNotExist: success = False # path to data path_to_data = image.pic.path path_to_final = final.pic.path if success: # final filenames filename, extension = os.path.splitext(path_to_final) if extension == '.gz': extension = '.nii.gz' filename = filename[:-4] path_to_cleaned = filename + '.cleaned' + extension path_to_filled = filename + '.filled' + extension path_to_cleaned_filled = filename + '.cleaned.filled' + extension # load data and header final, header = load_data(path_to_final, 'cleanup') if extension not in ['.tif', '.am']: _, header = load_data(label.pic.path, 'cleanup') # remove outlier final_cleaned = clean(final, label.delete_outliers) try: # check if final still exists friend = Upload.objects.get(pk=friend_id) # save results path_to_cleaned = unique_file_path(path_to_cleaned, label.user.username) save_data(path_to_cleaned, final_cleaned, header, extension, label.compression) # save django object shortfilename = os.path.basename(path_to_cleaned) pic_path = 'images/' + friend.user.username + '/' + shortfilename if fill_holes: Upload.objects.create(pic=pic_path, user=friend.user, project=friend.project, final=2, imageType=3, shortfilename=shortfilename, friend=friend_id) else: Upload.objects.create(pic=pic_path, user=friend.user, project=friend.project, final=6, imageType=3, shortfilename=shortfilename, friend=friend_id) # create slices for sliceviewer if config['OS'] == 'linux': q_slices = Queue('slices', connection=Redis()) job = q_slices.enqueue_call(create_slices, args=( path_to_data, path_to_cleaned, ), timeout=-1) elif config['OS'] == 'windows': p = Process(target=create_slices, args=(path_to_data, path_to_cleaned)) p.start() p.join() except Upload.DoesNotExist: success = False # fill holes if fill_holes and success: final_filled = fill(final, label.fill_holes) final_cleaned_filled = final_cleaned + (final_filled - final) try: # check if final still exists friend = Upload.objects.get(pk=friend_id) # save results path_to_filled = unique_file_path(path_to_filled, label.user.username) save_data(path_to_filled, final_filled, header, extension, label.compression) path_to_cleaned_filled = unique_file_path( path_to_cleaned_filled, label.user.username) save_data(path_to_cleaned_filled, final_cleaned_filled, header, extension, label.compression) # save django object shortfilename = os.path.basename(path_to_cleaned_filled) pic_path = 'images/' + friend.user.username + '/' + shortfilename Upload.objects.create(pic=pic_path, user=friend.user, project=friend.project, final=8, imageType=3, shortfilename=shortfilename, friend=friend_id) shortfilename = os.path.basename(path_to_filled) pic_path = 'images/' + friend.user.username + '/' + shortfilename Upload.objects.create(pic=pic_path, user=friend.user, project=friend.project, final=7, imageType=3, shortfilename=shortfilename, friend=friend_id) # create slices for sliceviewer if config['OS'] == 'linux': q_slices = Queue('slices', connection=Redis()) job = q_slices.enqueue_call(create_slices, args=( path_to_data, path_to_filled, ), timeout=-1) job = q_slices.enqueue_call(create_slices, args=( path_to_data, path_to_cleaned_filled, ), timeout=-1) elif config['OS'] == 'windows': p = Process(target=create_slices, args=(path_to_data, path_to_filled)) p.start() p.join() p = Process(target=create_slices, args=(path_to_data, path_to_cleaned_filled)) p.start() p.join() except Upload.DoesNotExist: pass