def register(fixed_volume_path, moving_volume_path, output_folder, params_path): output_image_path = r"{}\new_vol.hdf5".format(output_folder) moving_image = read_volume(moving_volume_path) fixed_image = read_volume(fixed_volume_path) # moving_image = normalize_ct_volume(moving_image) # fixed_image = normalize_ct_volume(fixed_image) # show_histogram(fixed_image, moving_image) # run_slicer_functionality({'moving_image': moving_image, 'fixed_image': fixed_image}, int(moving_image.shape[1] / 2)) # exit() # rotated_moving_image = rotate_and_save(moving_image) # unrotated = moving_image.copy() moving_image = transform_moving_image(moving_image) moving_image, fixed_image = crop_volumes(moving_image, fixed_image) res_image_array = move_moving_image_to_fixed(moving_image, fixed_image, params_path, output_folder) copy_and_add_volume(fixed_volume_path, output_image_path, res_image_array) all_slicer_images = OrderedDict([ # ('moving', unrotated), ('moving_rotated', moving_image), ('moving_result', res_image_array), ('fixed', fixed_image) ]) Slicer(all_slicer_images, int(fixed_image.shape[1] / 2)).show()
def runSlicer(self): """ Launch an instance of Slicer with the current state of vars. Function that runs when the user presses the run button """ # DEBUG: self.printSlicerVars() num_iters = self.num_slices_entry.get() if not num_iters: num_iters = self.num_imgs else: num_iters = int(num_iters) slicer = Slicer( in_dir = self.curr_dir_lbl.get(), out_dir = self.out_dir_lbl.get(), img_ext = self.img_ext, mode = self.mode.get(), reverse = self.reverse.get(), curve_depth = self.curve_depth, num_slices = num_iters ) self.progress["value"] = 0 self.progress["maximum"] = num_iters slice_thread = threading.Thread(target=slicer.slice) slice_thread.daemon = True slice_thread.start() self.slicer_running = True prog_thread = threading.Thread(target=self.watchProgress, args=(slicer, num_iters)) prog_thread.daemon = True prog_thread.start()
def create_csurf_map(self, map_file): file_reader = open(map_file, 'r') lines = file_reader.readlines() csurf_map = defaultdict() for line in lines: path, sep, build_name = line.partition('\t') csurf_map[path] = build_name.split('\n')[0] self.csurf_map = csurf_map self.slicer = Slicer()
def __init__( self, values, base_values = None, data = None, display_data = None, instance_names = None, feature_names = None, output_names = None, output_indexes = None, lower_bounds = None, upper_bounds = None, main_effects = None, hierarchical_values = None, clustering = None ): self.op_history = [] # cloning. TODO: better cloning :) if issubclass(type(values), Explanation): e = values values = e.values base_values = e.base_values data = e.data output_dims = compute_output_dims(values, base_values, data) if len(_compute_shape(feature_names)) == 1: # TODO: should always be an alias once slicer supports per-row aliases values_shape = _compute_shape(values) if len(values_shape) >= 1 and len(feature_names) == values_shape[0]: feature_names = Alias(list(feature_names), 0) elif len(values_shape) >= 2 and len(feature_names) == values_shape[1]: feature_names = Alias(list(feature_names), 1) if len(_compute_shape(output_names)) == 1: # TODO: should always be an alias once slicer supports per-row aliases values_shape = _compute_shape(values) if len(values_shape) >= 1 and len(output_names) == values_shape[0]: output_names = Alias(list(output_names), 0) elif len(values_shape) >= 2 and len(output_names) == values_shape[1]: output_names = Alias(list(output_names), 1) self._s = Slicer( values = values, base_values = None if base_values is None else Obj(base_values, [0] + list(output_dims)), data = data, display_data = display_data, instance_names = None if instance_names is None else Alias(instance_names, 0), feature_names = feature_names, output_names = output_names, # None if output_names is None else Alias(output_names, output_dims), output_indexes = None if output_indexes is None else (output_dims, output_indexes), lower_bounds = lower_bounds, upper_bounds = lower_bounds, main_effects = main_effects, hierarchical_values = hierarchical_values, clustering = None if clustering is None else Obj(clustering, [0]) )
def __init__(self, expected_value, values, data=None, output_shape=tuple(), interaction_order=0, instance_names=None, input_names=None, output_names=None, output_indexes=None, feature_types=None, lower_bounds=None, upper_bounds=None, main_effects=None, hierarchical_values=None, partition_tree=None): input_shape = _compute_shape(data) values_dims = list( range(len(input_shape) + interaction_order + len(output_shape))) output_dims = range( len(input_shape) + interaction_order, values_dims[-1]) #main_effects_inds = values_dims[0:len(input_shape)] + values_dims[len(input_shape) + interaction_order:] self.output_names = output_names # TODO: needs to tracked after slicing still kwargs_dict = {} if lower_bounds is not None: kwargs_dict["lower_bounds"] = (values_dims, Slicer(lower_bounds)) if upper_bounds is not None: kwargs_dict["upper_bounds"] = (values_dims, Slicer(upper_bounds)) if main_effects is not None: kwargs_dict["main_effects"] = (values_dims, Slicer(main_effects)) if output_indexes is not None: kwargs_dict["output_indexes"] = (output_dims, Slicer(output_indexes)) if output_names is not None: kwargs_dict["output_names"] = (output_dims, Slicer(output_names)) if hierarchical_values is not None: kwargs_dict["hierarchical_values"] = (hierarchical_values, Slicer(hierarchical_values)) if partition_tree is not None: kwargs_dict["partition_tree"] = (partition_tree, Slicer(partition_tree)) super().__init__(data, values, input_shape, output_shape, expected_value, interaction_order, instance_names, input_names, feature_types, **kwargs_dict)
def slice(self): print "Taints: %s" % scanf_taint.taints taints = [] for _, v in self._hooks.iteritems(): taints.extend(v.taints) target_tmps, target_regs, target_addrs = self._slice_from_last_condition() try: slicer = Slicer(self._project, self._path, \ target_tmps, target_regs, target_addrs, \ self._mem_reads, self._mem_writes, taints) slicer.slice() except SlicerError: raise TracerError("Slicer failed") sources = self.insts_to_source(sorted(slicer.instructions)) for line in sources: print line
def __init__(self, size=(3, 3)): """ placeholder """ # list of train and test directories self._annotation_suffix = '_Annotated_Cars.png' # 15cm resolution self._GSD = 0.15 self._size = (int(round( (size[0] / self._GSD) / 2)), int(round((size[1] / self._GSD) / 2))) # xml conversion tweak self._custom_item_func = lambda x: 'object' # create image slicer self._slicer = Slicer() return
def __init__( self, values, base_values=None, data=None, display_data=None, instance_names=None, feature_names=None, output_names=None, output_indexes=None, lower_bounds=None, upper_bounds=None, main_effects=None, hierarchical_values=None, clustering=None, interactions=None, feature_groups=None, ): self.op_history = [] # cloning. TODO: better cloning :) if issubclass(type(values), Explanation): e = values values = e.values base_values = e.base_values data = e.data output_dims = compute_output_dims(values, base_values, data) if len( _compute_shape(feature_names) ) == 1: # TODO: should always be an alias once slicer supports per-row aliases values_shape = _compute_shape(values) if len(values_shape) >= 1 and len( feature_names) == values_shape[0]: feature_names = Alias(list(feature_names), 0) elif len(values_shape) >= 2 and len( feature_names) == values_shape[1]: feature_names = Alias(list(feature_names), 1) if len( _compute_shape(output_names) ) == 1: # TODO: should always be an alias once slicer supports per-row aliases values_shape = _compute_shape(values) output_names = Alias(list(output_names), output_dims[0]) # if len(values_shape) >= 1 and len(output_names) == values_shape[0]: # output_names = Alias(list(output_names), 0) # elif len(values_shape) >= 2 and len(output_names) == values_shape[1]: # output_names = Alias(list(output_names), 1) if output_names is not None and not isinstance(output_names, Alias): l = len(_compute_shape(output_names)) if l == 0: pass elif l == 1: output_names = Obj(output_names, output_dims) elif l == 2: output_names = Obj(output_names, [0] + list(output_dims)) else: raise ValueError( "shap.Explanation does not yet support output_names of order greater than 3!" ) self._s = Slicer( values=values, base_values=None if base_values is None else Obj( base_values, [0] + list(output_dims)), data=data, display_data=display_data, instance_names=None if instance_names is None else Alias( instance_names, 0), feature_names=feature_names, output_names=output_names, output_indexes=None if output_indexes is None else (output_dims, output_indexes), lower_bounds=lower_bounds, upper_bounds=upper_bounds, main_effects=main_effects, hierarchical_values=hierarchical_values, clustering=None if clustering is None else Obj(clustering, [0]), interactions=interactions, feature_groups=feature_groups)
def Compute3DDice(PID: Union[int, List[int]], netparams: str, patchsize: int, batch: int = 10, bydim: int = 1, doeval: bool = True, dev: str = 'cpu', step: int = 0, saveout: bool = False, savename: str = 'x') -> List[float]: #OBS: in case of deepmed, patchsize means the size of output patch! #(i.e. if patchsize=9, the input to network will be 25x25) <-but this done in the code #step = in what steps you take patches. if ==0, you take nonoverlapping ones. if K, patch starts # at prev_patch_start+K. #saveout = whether we save the ful subject output. (for viewing and debugging) # GET NET: net, in1, in2, in3D = getNetwork(netparams, dev) if doeval: net.eval() else: net.train() device = torch.device(dev) print('Net loaded.') # CUT AND EVAL: loop through cutting smaller pieces, moving to torch and eval if isinstance(PID, int): PID = [PID] segmented = torch.zeros((1, 7), device=dev) existing = torch.zeros((1, 7), device=dev) intersec = torch.zeros( (1, 7), device=dev ) #these three needed to gather results, for post dice compute Dices = torch.zeros((len(PID), 7), device=dev) axes = [0, 2, 3] + ([4] if in3D else []) #set the right function to use TensorCropping = CenterCropTensor3d padding = [(0, 0), (0, patchsize), (0, patchsize), (0, patchsize)] #(16,patchsize+16) paddingall = [(0, 0), (0, patchsize), (0, patchsize), (0, patchsize)] #(16,patchsize+16) if in2: #deep med, we need to pad the input on all sides to be able to cut pieces as wanted paddingall[1:] = [(16 + 8, patchsize + 16 + 8)] * 3 patchsize = patchsize - 16 #since patchsize, as it goes into slicer, means the size of network output if not in3D: padding[bydim + 1] = (0, 0) paddingall[bydim + 1] = (0, 0) TensorCropping = CenterCropTensor # LOAD DATA: for idx, pid in enumerate(PID): #set accumulators to 0: segmented.zero_() existing.zero_() intersec.zero_() allin, gt, mask = loadSubject(pid, patchsize // 2) size_full = allin[0].shape #shape of 3d img, one channel mask = np.pad(mask, padding[1:], mode='constant') gt = np.pad(gt, padding, mode='constant') allin = np.pad(allin, paddingall, mode='constant') # print((size_full, gt.shape)) empty_subj = torch.zeros( gt.shape[1:]) #allin.shape[1:]) #cause we dont need channels slicer = Slicer(size_full, patchsize, in1, in2, in3D, bydim, step) #return string slice, include all channels # for cutting out the middle part based on step: #slice((sf-step)//2, sf-np.ceil((sf-step)/2)) slicing = "".join([ f'.narrow({idx}, {(patchsize-step)//2}, {step})' for idx in range(2, (4 + in3D)) ]) if step > 0 else "" paddingup = [0, patchsize - step] * 3 if not in3D: paddingup[-1 - bydim * 2] = 0 print(f'Eval on subj{pid}...') with torch.no_grad(): while slicer.todo > 0: gtslices, in1slices, in2slices = slicer.get_batch( batch) #multiple slices gts = np.stack(list( map(eval, [f'gt[{slajs}]' for slajs in gtslices])), axis=0) in1s = np.stack(list( map(eval, [f'allin[{slajs}]' for slajs in in1slices])), axis=0) #maske = np.stack([eval(f'mask[{slajs[2:]}]') for slajs in gtslices], axis=0) maske = np.stack(list( map(eval, [f'mask[{slajs[2:]}]' for slajs in gtslices])), axis=0) # move to torch: target_oh = torch.from_numpy(gts).squeeze().to(device) data = [torch.from_numpy(in1s).squeeze().float().to(device) ] #input 1 if in2: #in2s = np.stack([eval(f'allin[{slajs}]') for slajs in in2slices], axis=0) in2s = np.stack(list( map(eval, [f'allin[{slajs}]' for slajs in in2slices])), axis=0) data.append( torch.from_numpy(in2s).squeeze().float().to( device)) #input 2 #run net on data. get output, save sums in dice gather lists out = net(*data).exp() target_oh, out = TensorCropping( target_oh, out ) #in case of PSP net, might be that output is bigger than input/GT #dices = AllDices(out, target_oh) maske = torch.from_numpy(maske).squeeze().unsqueeze( 1).float().to(device) #cut only the middle part of OUT, MASKE and TARGET_OH for eval (depending on the step size) maske = eval('maske' + slicing) target_oh = eval('target_oh' + slicing) out = eval('out' + slicing) #when summing up, use only the middle of the patches. Depending on how big 'step' was. segmented += torch.sum(out * maske, axis=axes) existing += torch.sum(target_oh * maske, axis=axes) intersec += torch.sum(target_oh * maske * out, axis=axes) #save output if required if saveout: #whats faster, simply saving to an existing tensor, or iffing every loop?? for idd, slajs in enumerate(gtslices): tmp = torch.argmax(out[idd, ...], dim=0) if not in3D: tmp = tmp.unsqueeze(bydim) # print(tmp.shape) tmp = torch.nn.functional.pad(tmp, paddingup) eval(f'empty_subj[{slajs[2:]}].copy_(tmp)') #all saved, now calc actual dices: Dices[idx, :] = 2 * intersec / (existing + segmented ) #calc dice from the gathering lists if saveout: #save img as npy. np.save(f'out{pid}_{savename}.npy', empty_subj.cpu().numpy()) print('Done.') #pidis = [int(p) for p in PIDS] dices = np.concatenate((np.array(PID)[:, None], Dices.cpu().numpy()), axis=1) np.save(f'dices_{savename}.npy', dices) return dices
def __init__(self, expected_value, values, data=None, output_shape=tuple(), interaction_order=0, instance_names=None, input_names=None, output_names=None, output_indexes=None, feature_types=None, lower_bounds=None, upper_bounds=None, main_effects=None, hierarchical_values=None, original_rows=None, clustering=None): self.transform_history = [] input_shape = _compute_shape(data) # trim any trailing None shapes since we don't want slicer to try and use those if len(input_shape) > 0 and input_shape[-1] is None: input_shape = input_shape[:-1] values_dims = list( range(len(input_shape) + interaction_order + len(output_shape))) output_dims = range( len(input_shape) + interaction_order, values_dims[-1]) #main_effects_inds = values_dims[0:len(input_shape)] + values_dims[len(input_shape) + interaction_order:] self.output_names = output_names # TODO: needs to tracked after slicing still kwargs_dict = {} if lower_bounds is not None: kwargs_dict["lower_bounds"] = (values_dims, Slicer(lower_bounds)) if upper_bounds is not None: kwargs_dict["upper_bounds"] = (values_dims, Slicer(upper_bounds)) if main_effects is not None: kwargs_dict["main_effects"] = (values_dims, Slicer(main_effects)) if output_indexes is not None: kwargs_dict["output_indexes"] = (output_dims, Slicer(output_indexes)) if output_names is not None: kwargs_dict["output_names"] = (output_dims, Slicer(output_names)) if hierarchical_values is not None: kwargs_dict["hierarchical_values"] = (values_dims, Slicer(hierarchical_values)) if input_names is not None: if not is_1d(input_names): input_name_dims = values_dims else: input_name_dims = values_dims[1:] kwargs_dict["input_names"] = (input_name_dims, Slicer(input_names)) if original_rows is not None: kwargs_dict["original_rows"] = (values_dims[1:], Slicer(original_rows)) if clustering is not None: kwargs_dict["clustering"] = ([0], Slicer(clustering)) if expected_value is not None: ndims = len(getattr(expected_value, "shape", [])) if ndims == len(values_dims): kwargs_dict["expected_value"] = (values_dims, Slicer(expected_value)) elif ndims == len(values_dims) - 1: kwargs_dict["expected_value"] = (values_dims[1:], Slicer(expected_value)) else: raise Exception( "The shape of the passed expected_value does not match the shape of the passed values!" ) # if clustering is not None: # self.clustering = clustering super().__init__(data, values, input_shape, output_shape, expected_value, interaction_order, instance_names, input_names, feature_types, **kwargs_dict)
def __init__( # pylint: disable=too-many-arguments self, values, base_values=None, data=None, display_data=None, instance_names=None, feature_names=None, output_names=None, output_indexes=None, lower_bounds=None, upper_bounds=None, error_std=None, main_effects=None, hierarchical_values=None, clustering=None, compute_time=None): self.op_history = [] self.compute_time = compute_time # cloning. TODOsomeday: better cloning :) if issubclass(type(values), Explanation): e = values values = e.values base_values = e.base_values data = e.data self.output_dims = compute_output_dims(values, base_values, data, output_names) values_shape = _compute_shape(values) if output_names is None and len(self.output_dims) == 1: output_names = [ f"Output {i}" for i in range(values_shape[self.output_dims[0]]) ] if len( _compute_shape(feature_names) ) == 1: # TODOsomeday: should always be an alias once slicer supports per-row aliases if len(values_shape) >= 1 and len( feature_names) == values_shape[0]: feature_names = Alias(list(feature_names), 0) elif len(values_shape) >= 2 and len( feature_names) == values_shape[1]: feature_names = Alias(list(feature_names), 1) if len( _compute_shape(output_names) ) == 1: # TODOsomeday: should always be an alias once slicer supports per-row aliases output_names = Alias(list(output_names), self.output_dims[0]) # if len(values_shape) >= 1 and len(output_names) == values_shape[0]: # output_names = Alias(list(output_names), 0) # elif len(values_shape) >= 2 and len(output_names) == values_shape[1]: # output_names = Alias(list(output_names), 1) if output_names is not None and not isinstance(output_names, Alias): l = len(_compute_shape(output_names)) if l == 0: pass elif l == 1: output_names = Obj(output_names, self.output_dims) elif l == 2: output_names = Obj(output_names, [0] + list(self.output_dims)) else: raise ValueError( "shap.Explanation does not yet support output_names of order greater than 3!" ) if not hasattr(base_values, "__len__") or len(base_values) == 0: pass elif len(_compute_shape(base_values)) == len(self.output_dims): base_values = Obj(base_values, list(self.output_dims)) else: base_values = Obj(base_values, [0] + list(self.output_dims)) self._s = Slicer( values=values, base_values=base_values, data=list_wrap(data), display_data=list_wrap(display_data), instance_names=None if instance_names is None else Alias( instance_names, 0), feature_names=feature_names, output_names=output_names, output_indexes=None if output_indexes is None else (self.output_dims, output_indexes), lower_bounds=list_wrap(lower_bounds), upper_bounds=list_wrap(upper_bounds), error_std=list_wrap(error_std), main_effects=list_wrap(main_effects), hierarchical_values=list_wrap(hierarchical_values), clustering=None if clustering is None else Obj(clustering, [0]))
from slicer import Slicer import time import datetime dir_name = "C:\\Users\\absch\\Desktop\\slicer-test-large\\" img_ext = ".jpg" test_timestamp = datetime.datetime.fromtimestamp( time.time()).strftime('%Y-%m-%d %H:%M:%S') f = open("timelog.txt", "a") begin = time.clock() slicer = Slicer(dir_name, img_ext, "simple", False) slicer.slice() f.write(test_timestamp + "\t\tSimple\t\t" + str(round(time.clock() - begin, 4)) + "\n") begin = time.clock() convex_slicer = Slicer(dir_name, img_ext, "convex", False, 10) convex_slicer.slice() f.write(test_timestamp + "\t\tConvex\t\t" + str(round(time.clock() - begin, 4)) + "\n") begin = time.clock() concave_slicer = Slicer(dir_name, img_ext, "concave", False, 10) concave_slicer.slice() f.write(test_timestamp + "\t\tConcave\t\t" + str(round(time.clock() - begin, 4)) + "\n")
#============================================================================== # Process Raw Data #============================================================================== if args.intype[0] == 'raw': if args.interpolate: process_series_files.process_all_in_dir(args.indir[0], join(out_dir, 'data')) data_dir = join(out_dir, 'data') """ else: #just copy the files print "Copying data files to ", data_dir for csvf in glob.iglob(join(args.indir[0],"*.csv")): shutil.copyfile(csvf, join(data_dir, os.path.basename(csvf))) """ print "Instantiating Slicer and loading series" slicer = Slicer(taskfile=join(data_dir, 'task.xls')) filelist=[join(data_dir,f) for f in os.listdir(data_dir) if \ re.compile(".*\.csv").match(f)] num_subjects = len(filelist) slicer.load_series_from_csv('raw', filelist) if args.stats: pp = PdfPages(join(report_dir, 'stats.pdf')) stats.plot_all(slicer, pp) fig, ax = plt.subplots() ax.plot(range(1, num_subjects + 1)) plt.title("Number of subjects") pp.savefig(fig) pp.close()
from slicer import Slicer #dir_name = "C:\\Users\\absch\\Desktop\\Slicer-test\\" dir_name = "/mnt/c/Users/absch/Desktop/Slicer-test/" img_ext = ".jpg" slicer = Slicer(dir_name, img_ext, "simple", reverse=False, num_slices=20) slicer.slice() # convex_slicer = Slicer(dir_name, img_ext, "convex", False, 10) # convex_slicer.slice() # # concave_slicer = Slicer(dir_name, img_ext, "concave", False, 10) # concave_slicer.slice()
row = [] for _ in range(0, len(template[row_index])): row.append(" ") picture.append(row) return picture def add_piece(picture, slices): print_picture(picture) for i in slices: for j in i: picture[j[2]][j[1]] = j[0] print_picture(picture) def print_picture(picture): os.system('cls' if os.name == 'nt' else 'clear') for i in range(0, len(picture)): output = "" for j in range(0, len(picture[i])): output += picture[i][j] print(output) if __name__ == "__main__": lib = Library(input("Type your special character: ")) template = lib.assemble_line(input("Type your phrase: ")) slicer = Slicer(template) slices = slicer.get_pattern() picture = get_picture(template) add_piece(picture, slices)
slicer.extract_rolling_median(seriesname='raw', window_size=ws) rm = slicer.series['raw_rolling_median_' + str(ws)][start:end] rm_x = [ int(j.microseconds / 1000) for j in [i - rm.index[0] for i in rm.index] ] rm_y = [i for i in rm] #rm.plot(xticks=rm.index) plt.plot(rm_x, rm_y) plt.legend(['512Hz EEG']+[ 'Window size: %d' % ws \ for ws in window_sizes] ,loc='best') plt.ylabel(r"Potential ($\mu$V)") plt.xlabel(r"Time after stimulus (ms)") plt.grid() #plt.title('10 Hz rolling median, compared to 512Hz signal') ax.set_ylim(ax.get_ylim()[::-1]) pdfpages.savefig() #plt.show() #debug if __name__ == "__main__": slicer = Slicer() print 'loading raw from list of csvfiles' slicer.load_series_from_csv('raw', sys.argv[1:]) pp = PdfPages('rolling_median.pdf') do_charts(slicer, pp) pp.close()