def __init__(self, bot): self.bot = bot self.last_result = None # I don't really use this... self.app_id = bot.api_keys['wolfram'] # our wolfram alpha client self.wolfram_client = wolframalpha.Client(self.app_id) # Globals for message removal self.messageHistory = set() self.compute_message_history = set() self.previousQuery = '' # DB interfacer for user location query localization self.reg = reg.Registration(self.bot) # Fun strings for invalid queries self.invalidQueryStrings = [ "Nobody knows.", "It's a mystery.", "I have no idea.", "No clue, sorry!", "I'm afraid I can't let you do that.", "Maybe another time.", "Ask someone else.", "That is anybody's guess.", "Beats me.", "I haven't the faintest idea." ] # Regex for IP address self.ipv4_regex = re.compile(r'\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b') self.ipv6_regex = re.compile( r'(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))' )
def update_set_application(request): c = {} c.update(csrf(request)) data = request.POST["prior"] regis = registration.Registration() st = regis.updateRegisteredApplicantData(data) print(st) return HttpResponse(st, content_type="application/type")
def do_registration(self, c, s): if not self.is_registration(s): r = registration.Registration(c, s) self.registrations.add(r) c.do_registration(s) return r else: return None
def registration_ui(request): c = {} c.update(csrf(request)) data = request.POST["vol_name"] print("data" + data) try: regis = registration.Registration() st = regis.register(data) except Exception as e: st = e return HttpResponse(st, content_type="application/type")
def already_ssn(request): c = {} c.update(csrf(request)) data = request.POST["ssn"] front_end_str10 = json.dumps({"data": [{"guardian_ssn": "342-909-8982"}]}) try: regis = registration.Registration() st = regis.alreadySsn(data) except Exception as e: st = e return HttpResponse(st, content_type="application/type")
def test_register(self): reg = registration.Registration() data = self.getFromCsv('sample_registration_data.csv', {}) success = [] error = [] for i in range(0, len(data)): return_front_end_dict = '{ "data": ' + json.dumps([data[i]]) + '}' return_data = reg.register(return_front_end_dict) front_end_dict = ast.literal_eval(return_data) if front_end_dict['status'] == 'success': success.append(front_end_dict['data'][0]) if front_end_dict['status'] == 'error': error.append(front_end_dict['data'][0]) data[i]['error_message'] = front_end_dict['message'] self.insertIntoCsv('actual_errors_data.csv', data[i])
def __init__(self, port): self.registration = registration.Registration(port) self.handshakePackage = handshake.Handshake(self.registration.addrMe) self.peersLocal = {} self.memPool = {} self.miner = None
mri_path = base_path + "mri/" labels_path = base_path + "labels/" masks_path = base_path + "masks/" atlas_path = base_path + "templates/MI/" ENABLE_PYRAMIDS = False if ENABLE_PYRAMIDS: out_path = base_path + "eval/ALPHA_SMD_PYRAMIDS_2/" else: out_path = base_path + "eval/ALPHA_SMD_2/" cnt = 20 r = reg.Registration(2, exe_path, dim=3, enable_logging=True) param = r.get_register_param_defaults() #param.pop("weights1", None) #param.pop("weights2", None) param["weights1"] = "hann" param["weights2"] = "hann" param["learning_rate"] = "0.5" param["relaxation_factor"] = "0.99" param["alpha_levels"] = "7" param["alpha_max_distance"] = "128" param["seed"] = "1000" param["metric"] = "alpha_smd" param["iterations"] = "3000" param["sampling_fraction"] = "0.05"
def connect(self): self.add_user = registration.Registration() self.add_user.show()
def main(): """Funkcja wykonująca cały program""" modul = modules.Modules() fun = function.Functions() file = files.Files() register = registration.Registration() files_with_code = pythonfiles.FileInDirectory() path = r'.\\' extend = 'py' result = files_with_code.list_directory(path, extend) files.Files.checking_connections_between_files(result) function_list1 = function.Functions.checking_connections_between_functions1( result) function_list2 = fun.checking_weight_of_connections_between_functions( result, function_list1) weight_fun = functions.write_to_file_fun_data(function_list1, function_list2) function.Functions.checking_connections_between_functions( result, weight_fun) modul_list = modules.Modules.searching_for_used_modules(result) modules.Modules.checking_connections_between_modules(result, modul_list) join_list = functions.convert_list_to_list_for_cc( files.Files.filesConnectionList, modules.Modules.modulConnectionList) join_list = list(set(join_list)) cyclomatic_complexity = functions.cyclomatic_complexity() cyclomatic_complexity = functions.compare(function_list1, cyclomatic_complexity) cyclomatic_complexity += join_list menu_choice = functions.menu() if menu_choice == 1: registration.Registration.write_to_file( "FILES", files.Files.filesConnectionList ) # Wpisywanie do pliku połączeń plików registration.Registration.write_to_file( "", files.Files.filesConnectionWeight) elif menu_choice == 2: registration.Registration.write_to_file( "Functions", function.Functions.functionsConnectionList ) # Wpisywanie do pliku połączeń funkcji registration.Registration.write_to_file( "", function.Functions.functionsConnectionWeight) registration.Registration.write_to_file("CYCLOMATIC_COMPLEXITY", cyclomatic_complexity) elif menu_choice == 3: registration.Registration.write_to_file( "Modules", files.Files.filesConnectionList ) # Wpisywanie do pliku połączeń modułów registration.Registration.write_to_file( "", modul.Modules.modulConnectionWeight) elif menu_choice == 4: registration.Registration.write_to_file( "FILES", files.Files.filesConnectionList ) # Wpisywanie do pliku połączeń plików registration.Registration.write_to_file( "", files.Files.filesConnectionWeight) registration.Registration.write_to_file( "Functions", function.Functions.functionsConnectionList ) # Wpisywanie do pliku połączeń funkcji registration.Registration.write_to_file( "", function.Functions.functionsConnectionWeight) registration.Registration.write_to_file("CYCLOMATIC_COMPLEXITY", cyclomatic_complexity) elif menu_choice == 5: registration.Registration.write_to_file( "FILES", files.Files.filesConnectionList ) # Wpisywanie do pliku połączeń plików registration.Registration.write_to_file( "", files.Files.filesConnectionWeight) registration.Registration.write_to_file( "Modules", modules.Modules.modulConnectionList ) # Wpisywanie do pliku połączeń modułów registration.Registration.write_to_file( "", modules.Modules.modulConnectionWeight) elif menu_choice == 6: registration.Registration.write_to_file( "Functions", function.Functions.functionsConnectionList ) # Wpisywanie do pliku połączeń funkcji registration.Registration.write_to_file( "", function.Functions.functionsConnectionWeight) registration.Registration.write_to_file( "Modules", modules.Modules.modulConnectionList ) # Wpisywanie do pliku połączeń modułów registration.Registration.write_to_file( "", modules.Modules.modulConnectionWeight) registration.Registration.write_to_file("CYCLOMATIC_COMPLEXITY", cyclomatic_complexity) elif menu_choice == 7: registration.Registration.write_to_file( "FILES", files.Files.filesConnectionList ) # Wpisywanie do pliku połączeń plików registration.Registration.write_to_file( "", files.Files.filesConnectionWeight) registration.Registration.write_to_file( "Functions", function.Functions.functionsConnectionList ) # Wpisywanie do pliku połączeń funkcji registration.Registration.write_to_file( "", function.Functions.functionsConnectionWeight) registration.Registration.write_to_file( "Modules", modules.Modules.modulConnectionList ) # Wpisywanie do pliku połączeń modułów registration.Registration.write_to_file( "", modules.Modules.modulConnectionWeight) registration.Registration.write_to_file("CYCLOMATIC_COMPLEXITY", cyclomatic_complexity) else: print("Wybrałeś opcję z poza zakresu") main()
def main(USE_PYRAMIDS, RANDOMIZE_TRANSFORMS, DO_AFFINE_REGISTRATION, DO_TRANSFORM_LANDMARKS, EVAL_LANDMARKS, metric_name, transformation_size, noise_level): # Windows #dataset_path = "C:/cygwin64/home/johan/itkAlphaCut/assets/01.png" #bin_path = "C:/cygwin64/home/johan/itkAlphaCut-release/Release/" # Linux dataset_path = "/home/johof680/work/itkAlphaCut-4j/itkAlphaCut/assets/01.png" bin_path = "/home/johof680/work/itkAlphaAMD-build2/" #weight_path = "/home/johof680/work/VironovaRegistrationImages/" out_path = dataset_path #"/home/johof680/work/VironovaRegistrationImages/" # image extension im_ext = "tif" # number of registrations to perform count = 1000 # create registration object parallel_count = 6 image_dimensions = 2 r = reg.Registration(parallel_count, bin_path, dim=image_dimensions, enable_logging=True) out_path1 = "/home/johof680/work/itkAlphaCut-4j/cilia_param_search8/" + transformation_size + "/" + noise_level + "/" #out_path1 = "C:/cygwin64/home/johan/cilia_random/large4/" # Generate random transforms if RANDOMIZE_TRANSFORMS: rnd_param = r.get_random_transforms_param_defaults() if noise_level == "none": rnd_param["noise"] = "0.0" elif noise_level == "large": rnd_param["noise"] = "0.1" else: raise "Illegal noise level." if transformation_size == "small": rnd_param["rotation"] = "10" rnd_param["translation"] = "10" rnd_param["min_rotation"] = "0" rnd_param["min_translation"] = "0" elif transformation_size == "medium": rnd_param["rotation"] = "20" rnd_param["translation"] = "20" rnd_param["min_rotation"] = "10" rnd_param["min_translation"] = "10" elif transformation_size == "large": rnd_param["rotation"] = "30" rnd_param["translation"] = "30" rnd_param["min_rotation"] = "20" rnd_param["min_translation"] = "20" elif transformation_size == "all": rnd_param["rotation"] = "30" rnd_param["translation"] = "30" rnd_param["min_rotation"] = "0" rnd_param["min_translation"] = "0" else: raise "Illegal transformation size." r.random_transforms(dataset_path, out_path1, count, rnd_param) st.create_directory(out_path1) r.run("Random transformations") in_path = out_path1 out_path1 = out_path1 + metric_name + "/" st.create_directory(out_path1) #learning_rates_list = [0.001, 0.01, 0.1, 0.5, 1.0] #sampling_fractions_list = [0.01, 0.05, 0.1, 0.2, 0.5, 1.0] #normalizations_list = [0.0, 0.01, 0.025, 0.05] #sampling_fractions_list = [0.01, 0.05, 0.1, 0.2, 0.5, 1.0] exponents = [ -3.75, -3.5, -3.25, -3, -2.75, -2.5, -2.25, -2.0, -1.75, -1.5, -1.25, -1.0, -0.75, -0.5, -0.25, 0.0 ] #sampling_fractions_list = [np.power(10.0, i) for i in exponents] #sampling_fractions_list = [0.1] #learning_rates_list = [0.5] #normalizations_list = [0.0] #alpha_levels_list = [7] sampling_fractions_list = [0.1] learning_rates_list = [0.5] normalizations_list = [0.0] alpha_levels_list = range(1, 32) param_comb = [(a, b, c, d) for a in learning_rates_list for b in sampling_fractions_list for c in normalizations_list for d in alpha_levels_list] print( "Parameter format (learning_rate, sampling_fraction, normalization percentile)" ) print(param_comb) # Do the registrations def register(rp, input1_path, input2_path, output_path, metric, cnt): for i in xrange(cnt): for j in xrange(len(param_comb)): (learning_rate, sampling_fraction, normalization, alpha_levels) = param_comb[j] pth = output_path + ("registration_%d_%d/" % (j + 1, i + 1)) rpar = rp.get_register_param_defaults() rpar.pop("weights1", None) rpar.pop("weights2", None) in1 = input1_path + "ref_image_%d.%s" % (i + 1, im_ext) in2 = input2_path + "transformed_image_%d.%s" % (i + 1, im_ext) msk2 = input2_path + "transformed_mask_%d.%s" % (i + 1, im_ext) if USE_PYRAMIDS: rpar["multiscale_sampling_factors"] = "4x2x1" rpar["multiscale_smoothing_sigmas"] = "5x3x0" else: rpar["multiscale_sampling_factors"] = "1" rpar["multiscale_smoothing_sigmas"] = "0" rpar["metric"] = metric rpar["learning_rate"] = str(learning_rate) rpar["alpha_outlier_rejection"] = "0.0" rpar["sampling_fraction"] = str(sampling_fraction) rpar["normalization"] = str(normalization) rpar["alpha_levels"] = str(alpha_levels) rpar["mask1"] = "circle" rpar["mask2"] = msk2 rp.register_affine(in1, in2, pth, rpar) #def landmark_transform(self, landmarks_in_path, out_path, out_name, transform_path): def transform_landmarks(rp, landmark_path, transform_path_base, cnt): for i in xrange(cnt): for j in xrange(len(param_comb)): transform_path = transform_path_base + ( "registration_%d_%d/transform_complete.txt" % (j + 1, i + 1)) input_path = landmark_path + "transformed_landmarks_%d.csv" % ( i + 1) out_name = "registered_landmarks_%d_%d.csv" % (j + 1, i + 1) rp.landmark_transform(input_path, transform_path_base, out_name, transform_path) if DO_AFFINE_REGISTRATION: register(r, in_path, in_path, out_path1, metric_name, count) r.run("Affine Registration") if DO_TRANSFORM_LANDMARKS: transform_landmarks(r, in_path, out_path1, count) r.run("Transform Landmarks") def eval_landmarks(ref_landmark_path, output_path, cnt): ref_lm = landmarks.read_csv( ref_landmark_path + "ref_landmarks.csv", False) #csv_2_np.read_csv(out1_path + "ref_landmarks.csv", False) out_succ_freq = [] out_succ_means = [] out_means = [] out_stddevs = [] out_dists = [] out_dist_summary = [] for j in xrange(len(param_comb)): dists = np.zeros(cnt) for i in xrange(cnt): tra_lm = landmarks.read_csv(output_path + "registered_landmarks_%d_%d.csv" % (j + 1, i + 1)) dists[i] = landmarks.mean_euclidean(ref_lm, tra_lm) succ_freq = np.count_nonzero( np.where(dists <= 1.0)) / np.float(cnt) succ_means = np.mean(dists[np.where(dists <= 1.0)]) out_succ_freq.append(succ_freq) out_succ_means.append(succ_means) out_means.append(np.mean(dists)) out_stddevs.append(np.std(dists)) out_dists.append(dists) out_dist_summary.append(dt.make_distribution(dists)) #np.sort(dists) return (out_succ_freq, out_succ_means, out_means, out_stddevs, out_dists, out_dist_summary) #print("%.4d: %f" % (i+1, dist)) #print(eval_landmarks(out_path1, out_path1, count)) def filter_set(values, tup, tup_index, tup_value): vals = [] tups = [] for i in xrange(len(tup)): if tup[i][tup_index] == tup_value: tups.append(tup[i]) vals.append(values[i]) return (np.array(vals), tups) if EVAL_LANDMARKS: (succ_freq, succ_means, mn, stddev, full_distri, distri) = eval_landmarks(in_path, out_path1, count) np.set_printoptions(precision=5) np.set_printoptions(suppress=True) print("") #print(full_distri) #print(distri) print("Succ freq: ") print(succ_freq) print("Succ means: ") print(succ_means) print("Means: ") print(mn) print(stddev) M = 9 if M > len(param_comb): M = len(param_comb) argsort = np.argsort(mn) best_indices = argsort[0:M] best_params = [param_comb[ind] for ind in best_indices] best_vals = [mn[ind] for ind in best_indices] worst_indices = argsort[len(argsort) - M:] worst_params = [param_comb[ind] for ind in worst_indices] worst_vals = [mn[ind] for ind in worst_indices] print("Best param: " + str(best_params)) print("Best vals: " + str(best_vals)) print("Worst param: " + str(worst_params)) print("Worst vals: " + str(worst_vals)) for i in xrange(len(full_distri)): np.savetxt(out_path1 + metric_name + "%d.csv" % (i + 1), full_distri[i], delimiter=",") print("For learning rate 0.5") (mn_lr_0_5, tup_lr_0_5) = filter_set(mn, param_comb, 0, 0.5) print(mn_lr_0_5) print(tup_lr_0_5) #print(str(param_comb)) #make_plot(distri) # Eval # param = r.get_register_param_defaults() # param["weights1"] = "hann" # param["weights2"] = "hann" # param["learning_rate"] = "0.05" # param["relaxation_factor"] = "0.99" # param["alpha_levels"] = "7" # param["alpha_max_distance"] = "128" # param["seed"] = "1000" # param["metric"] = "alpha_smd" # param["iterations"] = "1000" # param["sampling_fraction"] = "0.001" # param["spacing_mode"] = "default" # param["normalization"] = "0.005" # param["multiscale_sampling_factors"] = "4x2x1" # param["multiscale_smoothing_sigmas"] = "4.0x2.0x1.0" #def make_dir(path, index): # return st.makedir_string(path + "Out%.3d" % (index)) #def make_register(index, in1, in2, out, params): # return exe_path + " -in1 " + in1 + " -in2 " + in2 + " -out " + out + st.param_dict_to_string(params) def ind_str(prefix, index, postfix): return prefix + ("%.3d" % index) + postfix
def main(USE_PYRAMIDS, RANDOMIZE_TRANSFORMS, DO_AFFINE_REGISTRATION, DO_TRANSFORM_LANDMARKS, EVAL_LANDMARKS, metric_name, transformation_size, noise_level): # Windows #dataset_path = "c:/dev/data/VironovaRegistrationImages/" #bin_path = "C:/cygwin64/home/johan/itkAlphaCut-release/Release/" # Linux dataset_path = "/home/johof680/work/LPBA40_for_ANTs/mri/S01.nii.gz" bin_path = "/home/johof680/work/itkAlphaCut-4j/build-release/" # image extension im_ext = "nii.gz" # number of registrations to perform count = 200 # create registration object parallel_count = 6 image_dimensions = 3 r = reg.Registration(parallel_count, bin_path, dim=image_dimensions, enable_logging=True) out_path1 = "/home/johof680/work/itkAlphaCut-4j/lpba40_random_5/" + transformation_size + "/" + noise_level + "/" #metric_name = "ssd" #USE_PYRAMIDS = True #RANDOMIZE_TRANSFORMS = True #DO_AFFINE_REGISTRATION = True #DO_TRANSFORM_LANDMARKS = True #EVAL_LANDMARKS = True # Generate random transforms if RANDOMIZE_TRANSFORMS: rnd_param = r.get_random_transforms_param_defaults() if noise_level == "none": rnd_param["noise"] = "0.0" elif noise_level == "large": rnd_param["noise"] = "0.1" else: raise "Illegal noise level." if transformation_size == "small": rnd_param["rotation"] = "10" rnd_param["translation"] = "10" rnd_param["min_rotation"] = "0" rnd_param["min_translation"] = "0" elif transformation_size == "medium": rnd_param["rotation"] = "15" rnd_param["translation"] = "15" rnd_param["min_rotation"] = "10" rnd_param["min_translation"] = "10" elif transformation_size == "large": rnd_param["rotation"] = "20" rnd_param["translation"] = "20" rnd_param["min_rotation"] = "15" rnd_param["min_translation"] = "15" elif transformation_size == "all": rnd_param["rotation"] = "20" rnd_param["translation"] = "20" rnd_param["min_rotation"] = "0" rnd_param["min_translation"] = "0" else: raise "Illegal transformation size." #rnd_param["format_ext"] = im_ext r.random_transforms(dataset_path, out_path1, count, rnd_param) st.create_directory(out_path1) r.run("Random transformations") in_path = out_path1 out_path1 = out_path1 + metric_name + "/" if USE_PYRAMIDS: out_path1 = out_path1 + "w_pyramid/" else: out_path1 = out_path1 + "wo_pyramid/" st.create_directory(out_path1) # Do the registrations def register(rp, input1_path, input2_path, output_path, metric, cnt): for i in xrange(cnt): pth = output_path + ("registration_%d/" % (i + 1)) rpar = rp.get_register_param_defaults() rpar.pop("weights1", None) rpar.pop("weights2", None) in1 = input1_path + "ref_image_%d.%s" % (i + 1, im_ext) in2 = input2_path + "transformed_image_%d.%s" % (i + 1, im_ext) msk2 = input2_path + "transformed_mask_%d.%s" % (i + 1, im_ext) if USE_PYRAMIDS: rpar["multiscale_sampling_factors"] = "4x2x1" rpar["multiscale_smoothing_sigmas"] = "5x3x0" else: rpar["multiscale_sampling_factors"] = "1" rpar["multiscale_smoothing_sigmas"] = "0" rpar["metric"] = metric rpar["learning_rate"] = "0.5" rpar["alpha_outlier_rejection"] = "0.0" rpar["sampling_fraction"] = "0.01" rpar["mask1"] = "circle" rpar["mask2"] = msk2 rp.register_affine(in1, in2, pth, rpar) #def landmark_transform(self, landmarks_in_path, out_path, out_name, transform_path): def transform_landmarks(rp, landmark_path, transform_path_base, cnt): for i in xrange(cnt): transform_path = transform_path_base + ( "registration_%d/transform_complete.txt" % (i + 1)) input_path = landmark_path + "transformed_landmarks_%d.csv" % (i + 1) out_name = "registered_landmarks_%d.csv" % (i + 1) rp.landmark_transform(input_path, transform_path_base, out_name, transform_path) if DO_AFFINE_REGISTRATION: register(r, in_path, in_path, out_path1, metric_name, count) r.run("Affine Registration") if DO_TRANSFORM_LANDMARKS: transform_landmarks(r, in_path, out_path1, count) r.run("Transform Landmarks") def eval_landmarks(ref_landmark_path, output_path, cnt): ref_lm = landmarks.read_csv( ref_landmark_path + "ref_landmarks.csv", False) #csv_2_np.read_csv(out1_path + "ref_landmarks.csv", False) dists = np.zeros(cnt) for i in xrange(cnt): tra_lm = landmarks.read_csv(output_path + "registered_landmarks_%d.csv" % (i + 1)) dists[i] = landmarks.mean_euclidean(ref_lm, tra_lm) #np.sort(dists) return (np.mean(dists), np.std(dists), dists, dt.make_distribution(dists)) #print("%.4d: %f" % (i+1, dist)) #print(eval_landmarks(out_path1, out_path1, count)) # def count_less_than(sorted_distrib, value): # return np.searchsorted(sorted_distrib, value) # def compute_hist(distrib, bins): # yy = np.sort(distrib) # x = np.arange(0, 30.0, 30.0 / bins) # h = np.zeros(bins) # for i in xrange(bins): # h[i] = count_less_than(yy, x[i]) # return (x, h) # def make_plot(distrib): # fig, ax = plt.subplots(figsize = (8, 4)) # n_bins = 500 # (x, h) = compute_hist(distrib, n_bins) # #n, bins, patches = ax.hist(distrib, n_bins, normed=1, color=c[i], cumulative=True, label='alpha_smd') # c = ['r', 'b', 'g', 'y', 'k'] # ax.fill_between(x, 0, h) # #histtype='step' # ax.grid(True) # ax.legend(loc='right') # ax.set_title('Registration results') # ax.set_xlabel('Registration error (px)') # ax.set_ylabel('Success rate') # ax.set_ylim(0.0, 1.0) # ax.set_xlim(0.0, 1.0) # plt.show() if EVAL_LANDMARKS: (mn, stddev, full_distri, distri) = eval_landmarks(in_path, out_path1, count) np.set_printoptions(precision=5) np.set_printoptions(suppress=True) print("") print(distri) print(mn) print(stddev) np.savetxt(out_path1 + metric_name + ".csv", full_distri, delimiter=",") #make_plot(distri) # Eval # param = r.get_register_param_defaults() # param["weights1"] = "hann" # param["weights2"] = "hann" # param["learning_rate"] = "0.05" # param["relaxation_factor"] = "0.99" # param["alpha_levels"] = "7" # param["alpha_max_distance"] = "128" # param["seed"] = "1000" # param["metric"] = "alpha_smd" # param["iterations"] = "1000" # param["sampling_fraction"] = "0.001" # param["spacing_mode"] = "default" # param["normalization"] = "0.005" # param["multiscale_sampling_factors"] = "4x2x1" # param["multiscale_smoothing_sigmas"] = "4.0x2.0x1.0" #def make_dir(path, index): # return st.makedir_string(path + "Out%.3d" % (index)) #def make_register(index, in1, in2, out, params): # return exe_path + " -in1 " + in1 + " -in2 " + in2 + " -out " + out + st.param_dict_to_string(params) def ind_str(prefix, index, postfix): return prefix + ("%.3d" % index) + postfix
def post(self): minlen = 4 + 4 + 20 + 4 + 1 + 4 + 1 STR_VERSERVER = '01060000' INT_VERCLIENT = 0x01060000 STR_VERCLIENT = '1.6' # must be able to query for https if not os.environ.has_key('HTTPS'): self.resp_simple(0, 'HTTPS environment variable not found') return # must be able to query for server version if not os.environ.has_key('CURRENT_VERSION_ID'): self.resp_simple( 0, 'CURRENT_VERSION_ID environment variable not found') return HTTPS = os.environ.get('HTTPS', 'off') CURRENT_VERSION_ID = os.environ.get('CURRENT_VERSION_ID', STR_VERSERVER) # SSL must be enabled if HTTPS.__str__() != 'on': self.resp_simple(0, 'Secure socket required.') return # get the data from the post self.response.headers['Content-Type'] = 'application/octet-stream' data = self.request.body size = str.__len__(data) # size check if size < minlen: logging.debug("in body '%s'" % data) logging.debug("in size %d" % size) self.resp_simple(0, 'Request was formatted incorrectly.') return # unpack all incoming data client = (struct.unpack("!i", data[0:4]))[0] # client version check if client < INT_VERCLIENT: self.resp_simple(0, ( 'Client version mismatch; %s required. Download latest client release first.' % STR_VERCLIENT)) return server = int(CURRENT_VERSION_ID[0:8], 16) # init submissionAuth = None submissionType = 1 # unpack all incoming data, skip client version pos = 4 lenkeyid = (struct.unpack("!i", data[pos:(pos + 4)]))[0] pos = pos + 4 keyId = data[pos:(pos + lenkeyid)] pos = pos + lenkeyid lensubtok = (struct.unpack("!i", data[pos:(pos + 4)]))[0] pos = pos + 4 submissionToken = str(data[pos:(pos + lensubtok)]) pos = pos + lensubtok if lensubtok >= 32: # 256-bit original SHA-3 minimum, before base-64 encoding submissionAuth = submissionToken submissionType = 1 # version 1 of authentication lenregid = (struct.unpack("!i", data[pos:(pos + 4)]))[0] pos = pos + 4 registrationId = str(data[pos:(pos + lenregid)]) pos = pos + lenregid devtype = (struct.unpack("!i", data[pos:(pos + 4)]))[0] pos = pos + 4 # additional verifying for self signing if size > pos: # still has data lennonce = (struct.unpack("!i", data[pos:(pos + 4)]))[0] pos = pos + 4 nonce = str(data[pos:(pos + lennonce)]) pos = pos + lennonce lenpubkey = (struct.unpack("!i", data[pos:(pos + 4)]))[0] pos = pos + 4 pubkey = str(data[pos:(pos + lenpubkey)]) pos = pos + lenpubkey plain_pos = pos sig_len = (struct.unpack("!i", data[pos:(pos + 4)]))[0] pos = pos + 4 sig = data[pos:(pos + sig_len)] pos = pos + sig_len # signature verification if lenpubkey > 0: # load RSA public key rsa_key = RSA.importKey(base64.decodestring(pubkey)) # verify signature h = SHA.new() h.update(data[:plain_pos]) verifier = PKCS1_v1_5.new(rsa_key) if verifier.verify(h, sig): submissionAuth = pubkey submissionType = 2 # version 2 of authentication logging.debug( 'The signature is authentic. Registration continues.') else: logging.error( 'The signature is not authentic. Registration stops.') return # REGISTRATION STORAGE ============================================= # check if registration needs to be authenticated before insertion or update query = registration.Registration.all().order('-inserted') query.filter('key_id =', keyId) num = query.count() # key_id exists, submissionAuth must match if num >= 1: reg_old = query.get() # only want the oldest # follow update logic updateOld = False if submissionType > reg_old.submission_type: updateOld = True # authentication type upgraded elif submissionAuth == reg_old.submission_token: updateOld = True # previous authentication matches # token is authentic if updateOld: # if record exists, update it if registrationId == reg_old.registration_id: # update time and active status only reg_old.active = True reg_old.submission_token = submissionAuth reg_old.submission_type = submissionType reg_old.put() key = reg_old.key() if not key.has_id_or_name(): self.resp_simple(0, 'Unable to update registration.') return # if record missing, insert it else: reg_new = registration.Registration( key_id=keyId, submission_token=submissionAuth, submission_type=submissionType, registration_id=registrationId, notify_type=devtype, client_ver=client) reg_new.put() key = reg_new.key() if not key.has_id_or_name(): self.resp_simple(0, 'Unable to create new registration.') return # token not authentic, just log it else: logging.info( 'Registration failed: submission token in table %s, not matching submitted submission token %s' % (reg_old.submission_token[0:30], submissionAuth[0:30])) # key_id is new, submissionAuth can be inserted instantly else: reg_new = registration.Registration( key_id=keyId, submission_token=submissionAuth, submission_type=submissionType, registration_id=registrationId, notify_type=devtype, client_ver=client) reg_new.put() key = reg_new.key() if not key.has_id_or_name(): self.resp_simple(0, 'Unable to create new registration.') return # SEND RESPONSE ========================================= # this client background process does not need to log back insert/update errors to the client self.response.out.write('%s' % struct.pack('!i', server))
def regisgtrationFormCommand(): win.destroy() registrationObject = registration.Registration() registrationObject.show()
"legal_form":"", "helmet":"", "boot":"", "sleeping_bag":"", "water_bottle":"", "sunscreen":"", "bugs_spray":"", "check_in_status":"", "application_status":"", "guardian_ssn":"342-90-8982" }]}) front_end_str10 = json.dumps({"data" :[{"guardian_ssn":"342-909-8981"}]}) front_end_str11 = json.dumps({"data" :[{"applicant_id":"50"}]}) test = json.dumps({"data" :[{"camp_time_slots":"2017-02-12 00:00:00.000000","applicant_id":"15"}]}) regis = registration.Registration() #st = regis.register(front_end_str1) #st = regis.register(front_end_str3) #st = regis.register(front_end_str4) #st = regis.register(front_end_str5) #st = regis.alreadySsn(front_end_str10) st = regis.viewRegisteredApplicant(test) #st = regis.updateRegisteredApplicantData(front_end_str5) print(st)
def main(USE_PYRAMIDS, RANDOMIZE_TRANSFORMS, DO_AFFINE_REGISTRATION, DO_TRANSFORM_LANDMARKS, EVAL_LANDMARKS, metric_name, transformation_size, noise_level, reverse): out_path = dataset_path # image extension im_ext = "tif" # number of registrations to perform count = 1000 # create registration object parallel_count = 6 image_dimensions = 2 r = reg.Registration(parallel_count, bin_path, dim = image_dimensions, enable_logging = True) out_path1 = "/home/johof680/work/itkAlphaAMD-build/cilia/" + transformation_size + "/" + noise_level + "/" # Generate random transforms if RANDOMIZE_TRANSFORMS: rnd_param = r.get_random_transforms_param_defaults() if noise_level == "none": rnd_param["noise"] = "0.0" elif noise_level == "large": rnd_param["noise"] = "0.1" else: raise "Illegal noise level." if transformation_size == "small": rnd_param["rotation"] = "10" rnd_param["translation"] = "10" rnd_param["min_rotation"] = "0" rnd_param["min_translation"] = "0" elif transformation_size == "medium": rnd_param["rotation"] = "20" rnd_param["translation"] = "20" rnd_param["min_rotation"] = "10" rnd_param["min_translation"] = "10" elif transformation_size == "large": rnd_param["rotation"] = "30" rnd_param["translation"] = "30" rnd_param["min_rotation"] = "20" rnd_param["min_translation"] = "20" elif transformation_size == "all": rnd_param["rotation"] = "30" rnd_param["translation"] = "30" rnd_param["min_rotation"] = "0" rnd_param["min_translation"] = "0" else: raise "Illegal transformation size." r.random_transforms(dataset_path, out_path1, count, rnd_param) st.create_directory(out_path1) r.run("Random transformations") in_path = out_path1 if reverse: out_path1 = out_path1 + metric_name + "_reverse/" else: out_path1 = out_path1 + metric_name + "/" st.create_directory(out_path1) # Do the registrations def register(rp, input1_path, input2_path, output_path, metric, cnt): for i in xrange(cnt): pth = output_path + ("registration_%d/" % (i+1)) rpar = rp.get_register_param_defaults() rpar.pop("weights1", None) rpar.pop("weights2", None) msk2 = input2_path + "transformed_mask_%d.%s" % (i+1, im_ext) if reverse: rpar["mask2"] = "circle" rpar["mask1"] = msk2 in2 = input1_path + "ref_image_%d.%s" %(i+1, im_ext) in1 = input2_path + "transformed_image_%d.%s" % (i+1, im_ext) else: rpar["mask1"] = "circle" rpar["mask2"] = msk2 in1 = input1_path + "ref_image_%d.%s" %(i+1, im_ext) in2 = input2_path + "transformed_image_%d.%s" % (i+1, im_ext) if USE_PYRAMIDS: rpar["multiscale_sampling_factors"] = "4x2x1" rpar["multiscale_smoothing_sigmas"] = "5x3x0" else: rpar["multiscale_sampling_factors"] = "1" rpar["multiscale_smoothing_sigmas"] = "0" rpar["metric"] = metric rpar["learning_rate"] = "0.5" rpar["alpha_outlier_rejection"] = "0.0" rpar["sampling_fraction"] = "0.1" rpar["normalization"] = "0.05" rp.register_affine(in1, in2, pth, rpar) #def landmark_transform(self, landmarks_in_path, out_path, out_name, transform_path): def transform_landmarks(rp, landmark_path, landmark_prefix, transform_path_base, cnt): for i in xrange(cnt): transform_path = transform_path_base + ("registration_%d/transform_complete.txt" % (i+1)) if reverse: input_path = landmark_path + landmark_prefix + ".csv" else: input_path = landmark_path + landmark_prefix + "_%d.csv" % (i + 1) out_name = "registered_landmarks_%d.csv" % (i + 1) rp.landmark_transform(input_path, transform_path_base, out_name, transform_path) if DO_AFFINE_REGISTRATION: register(r, in_path, in_path, out_path1, metric_name, count) r.run("Affine Registration") if DO_TRANSFORM_LANDMARKS: if reverse: transform_landmarks(r, in_path, "ref_landmarks", out_path1, count) else: transform_landmarks(r, in_path, "transformed_landmarks", out_path1, count) r.run("Transform Landmarks") def eval_landmarks(ref_landmark_path, output_path, cnt): if reverse: dists = np.zeros(cnt) for i in xrange(cnt): ref_lm = landmarks.read_csv(in_path + "transformed_landmarks_%d.csv" % (i+1), False) #csv_2_np.read_csv(out1_path + "ref_landmarks.csv", False) tra_lm = landmarks.read_csv(output_path + "registered_landmarks_%d.csv" % (i+1)) dists[i] = landmarks.mean_euclidean(ref_lm, tra_lm) return (np.mean(dists), np.std(dists), dists, dt.make_distribution(dists)) else: ref_lm = landmarks.read_csv(ref_landmark_path + "ref_landmarks.csv", False) #csv_2_np.read_csv(out1_path + "ref_landmarks.csv", False) dists = np.zeros(cnt) for i in xrange(cnt): tra_lm = landmarks.read_csv(output_path + "registered_landmarks_%d.csv" % (i+1)) dists[i] = landmarks.mean_euclidean(ref_lm, tra_lm) return (np.mean(dists), np.std(dists), dists, dt.make_distribution(dists)) if EVAL_LANDMARKS: (mn, stddev, full_distri, distri) = eval_landmarks(in_path, out_path1, count) np.set_printoptions(precision=5) np.set_printoptions(suppress=True) print("") #print(full_distri) print(distri) print(mn) print(stddev) print("Metric:" + metric_name) print("Transformation: " + transformation_size) print("Noise level: " + noise_level) print("IsReverse: " + str(reverse)) np.savetxt(out_path1 + metric_name + ".csv", full_distri, delimiter=",") def ind_str(prefix, index, postfix): return prefix + ("%.3d" % index) + postfix
import registration as reg import numpy points_fixed = numpy.random.randn(100, 3) transform = reg.Affine() transform.parameter[:] = transform.identity transform.parameter[0] = numpy.pi / 8. points_moving = transform.transform_points(points_fixed) metric = reg.ExactLandmarkL2(points_moving, points_fixed, transform=None) opt = reg.ModifiedLBFGS(optimizer_args={'factr': 1, 'pgtol': 1e-10, 'disp': 1}) registration = reg.Registration( model=transform, metric=metric, optimizer=opt ) registration.register(points_moving) points_moving_transformed = transform.transform_points(points_moving) print "Initial Maximum MSE:", ((points_fixed - points_moving) ** 2).max() print "Registered Maximum MSE:", ((points_fixed - points_moving_transformed) ** 2).max()
def register(): registration.Registration(MAIN_WINDOW)