def apply_adjustment(camera, vehicle_center_pixel, vehicle_height, true_vehicle_center): """ Returns unadjusted and adjusted ground centers of the vehicle""" # project center pixel onto ground rough_vehicle_center = camera.pixel_to_plane(*vehicle_center_pixel) #rough_vehicle_center = camera.pixel_to_plane(*camera.world_to_pixel(*true_vehicle_center)) # height of camera position camera_position = camera.position camera_height = camera_position[2] multiplier = 1 if camera.model == 'perspective' else 1 # TODO play with between 2 and 1 depending on model and camera angle...? # get angle from Z axis (ie one camera is on) dist = np.linalg.norm(rough_vehicle_center[:2]) # ground plane distance direction_vec = helper.normalize(rough_vehicle_center) # overshoot = (vehicle_height/2)/(camera_height/dist) overshoot = multiplier * dist*vehicle_height/(camera_height*2) adjusted_center_distance = dist - overshoot ground_plane_direction_vector = direction_vec.copy() ground_plane_direction_vector[2] = 0.0 # flatten onto ground plane ground_plane_direction_vector = helper.normalize(ground_plane_direction_vector) adjusted_center = ground_plane_direction_vector * adjusted_center_distance return (rough_vehicle_center, adjusted_center, overshoot)
def main(image, template, methods): image_normalized = normalize(image) template_normalized = normalize(template) image_h, image_w = image.shape template_h, template_w = template.shape match_h, match_w = image_h - template_h + 1, image_w - template_w + 1 match = np.zeros((match_h, match_w), dtype='float64') result = {method_name: match.copy() for method_name in methods} for i in range(match_h): for j in range(match_w): window = image[i:template_h + i, j:template_w + j] window_normalized = image_normalized[i:template_h + i, j:template_w + j] for method_name, values in methods.items(): func = values['method'] normalized = values['normalized'] if normalized: result[method_name][i, j] = func(template_normalized, window_normalized) else: result[method_name][i, j] = func(template, window) for method_name, match in result.items(): if methods[method_name]['argmax']: top_left = np.unravel_index(match.argmax(), match.shape)[::-1] else: top_left = np.unravel_index(match.argmin(), match.shape)[::-1] show_result(image, template_w, template_h, match, top_left, method_name)
def search_signatures(self, neighborhoods): """ Search in database given a list of signatures. Return top NUMBER_OF_MATCHES mathced files. """ matched_files = {} total_signatures = 0 # Iterate over all signatures of the file for _, hashes_lst in neighborhoods.items(): for sig in hashes_lst: filehashes_lst = self.signatures_db.get(sig) if filehashes_lst is None: continue anchor_hashes_lst = self.anchors_db.get(sig) # Get the list of filenames. Split by HASH_DIGEST_SIZE bytes. filehashes_lst = [ filehashes_lst[i * _hp.HASH_DIGEST_SIZE:(i + 1) * _hp.HASH_DIGEST_SIZE] for i in range((len(filehashes_lst) + _hp.HASH_DIGEST_SIZE - 1) // _hp.HASH_DIGEST_SIZE ) ] # Get the list of anchor hashes that . Split by HASH_DIGEST_SIZE bytes. anchor_hashes_lst = [ anchor_hashes_lst[i * _hp.HASH_DIGEST_SIZE:(i + 1) * _hp.HASH_DIGEST_SIZE] for i in range((len(anchor_hashes_lst) + _hp.HASH_DIGEST_SIZE - 1) // _hp.HASH_DIGEST_SIZE ) ] # for filename_hash in filehashes_lst: for i in range(len(filehashes_lst)): filename_hash = filehashes_lst[i] filename = self.filenames_db.get(filename_hash).decode("utf-8") anchor_hash = anchor_hashes_lst[i] # If this is the first hash for that filename create a new inner dict if filename not in matched_files: matched_files[filename] = {} matched_files[filename]['total'] = 1 # Count occurences if anchor_hash not in matched_files[filename]: matched_files[filename][anchor_hash] = [] matched_files[filename]['anchors_matched'] = 0 matched_files[filename][anchor_hash].append(sig) matched_files[filename]['total'] += 1 total_signatures += 1 # Check how many signatures and neighborhoods matched anchor_matches = {} signatures_matches = {} signatures_dict = {} for filename, anchors in matched_files.items(): signatures_dict[filename] = {} signatures_dict[filename]['total'] = matched_files[filename]['total'] # for each anchor and the hashes in its neighborhood for anch, sigs in anchors.items(): # Skip the counters if anch == 'anchors_matched' or anch == 'total': continue if len(sigs) >= _hp.MIN_SIGNATURES_TO_MATCH: matched_files[filename]['anchors_matched'] += 1 for s in sigs: signatures_dict[filename][s] = 1 anchor_matches[filename] = anchors['anchors_matched'] / len(neighborhoods) signatures_matches[filename] = (len(signatures_dict[filename]) - 2) / total_signatures # Find top-K matches with 2 different criteria. anchor_matches = sorted(anchor_matches.items(), key=lambda x: x[1], reverse=True)[:_hp.NUMBER_OF_MATCHES] signatures_matches = sorted(signatures_matches.items(), key=lambda x: x[1], reverse=True)[:_hp.NUMBER_OF_MATCHES] # return lists of tuples _hp.normalize(anchor_matches) _hp.normalize(signatures_matches) return anchor_matches, signatures_matches
def combine_scores(features, feature_weights): final_scores = features.dot(feature_weights) final_scores = pd.Series( np.array(final_scores.values.reshape(final_scores.size, ))) final_scores.index = features.index final_scores = helper.normalize(final_scores.sort_values(ascending=False)) return final_scores
def actionProb(action, state, goal): index = None probs = [] for i, a in enumerate(legalActions(state)): ns = (state[0]+a[0], state[1]+a[1]) if a == action: index = i probs.append(math.exp(beta*q(a, state, goal))) probs = h.normalize(probs) return probs[index]
def update_text(selected_feature, selected_value): df_temp = df.loc[df[selected_feature] == selected_value] df_temp2 = df_temp.drop([selected_feature, 'first period grade','second period grade','third period grade'], axis = 1) df_temp2 = helper.handle_non_numerical_data(df_temp2) df_temp2 = helper.normalize(df_temp2) return 'Total number of students "{}"'.format(df_temp2.shape[0])
def update_details(selected_feature, selected_value): trace = [] df_temp = df.loc[df[selected_feature] == selected_value] df_temp2 = df_temp.drop([selected_feature, 'first period grade','second period grade','third period grade'], axis = 1) df_temp2 = helper.handle_non_numerical_data(df_temp2) df_temp2 = helper.normalize(df_temp2) for column in df_temp2.columns: trace.append(df_temp2[column].mean()) print(df_temp2.columns) print(trace) graph = [] graph.append( go.Bar( x = df_temp2.columns, y = trace, name = 'First Year Results', opacity=0.7, marker={ 'color' :'rgb(65,64,66 )', } ) ) return { 'data': graph, 'layout': go.Layout( xaxis={ 'title': 'Features', }, yaxis={ 'title': 'Average value of each feature', }, #margin={'l': 40, 'b': 30, 't': 0, 'r': 10}, height=450, hovermode='closest') }
def update_text(selected_feature, selected_value): df_temp = df.loc[df[selected_feature] == selected_value] df_temp2 = df_temp.drop([ selected_feature, 'first period grade', 'second period grade', 'third period grade' ], axis=1) df_temp2 = helper.handle_non_numerical_data(df_temp2) df_temp2 = helper.normalize(df_temp2) return 'Total number of students "{}"'.format(df_temp2.shape[0])
def __init__(self, filename, numbasecorr=20, Normalize=True, plot=True): self.__filename = filename self.__numbasecorr = numbasecorr RawData = RawTOFData(filename) self.__RawData = RawData idx = RawData.TOF.argsort() self.__TOF = RawData.TOF[idx] / 1000 Signal = (RawData.Baseline - RawData.Signal)[idx] self.__Signal = helper.subtract_baseline(Signal, left=self.__numbasecorr) if Normalize: self.__Signal = helper.normalize(self.__Signal) self.__ylabel = r"$\mathrm{Normalized\ REMPI\ Signal}$" else: self.__ylabel = r"$\mathrm{REMPI\ Signal}$" if plot: self.plot()
def write(input_string, output_path): with open(output_path, "w", newline="") as f: # To write .csv and .tsv, you first open a # file, then you call csv.writer() and give # it the file as an argument as seen below. # (It doesn't work if you haven't imported # the csv module above.) # writer = csv.writer(f) writer = csv.writer(f, delimiter="\t") # The csv.writer() method can either just take # one argument, the file it will write to, in # which case it looks just as above. It can, # however, take a second argument, and look # as follows: # csv.writer(f, delimiter=",") # which will tell the csv module explicitly # that we want to use , as a symbol to separate # the individual fields. # TODO: Change the csv.writer() call above so # that the csv module uses the tab as a # delimiter. Check exercise-5-readme.md # if you are unsure. # Then, you can use writer.writerows() to write # your .csv file. The writerows() function # takes as argument a list of lists. For example, # calling writerows( [ [ a , b ] , [ c , d ] ]) # will result in the following .csv file: # a,b # c,d # TODO: construct a list of lists in the # following form: # [ [ token1, normalised_form1 ] , # [ token2, normalised_form2 ] , # ... ] # using the helper.tokenize() and # helper.normalize() functions, then change # the below call to use your list of lists tokens = helper.tokenize(input_string) tokens_and_normalizations = [[token, helper.normalize(token)] for token in tokens] writer.writerows(tokens_and_normalizations)
def update_details(selected_feature, selected_value): trace = [] df_temp = df.loc[df[selected_feature] == selected_value] df_temp2 = df_temp.drop([ selected_feature, 'first period grade', 'second period grade', 'third period grade' ], axis=1) df_temp2 = helper.handle_non_numerical_data(df_temp2) df_temp2 = helper.normalize(df_temp2) for column in df_temp2.columns: trace.append(df_temp2[column].mean()) print(df_temp2.columns) print(trace) graph = [] graph.append( go.Bar(x=df_temp2.columns, y=trace, name='First Year Results', opacity=0.7, marker={ 'color': 'rgb(65,64,66 )', })) return { 'data': graph, 'layout': go.Layout( xaxis={ 'title': 'Features', }, yaxis={ 'title': 'Average value of each feature', }, #margin={'l': 40, 'b': 30, 't': 0, 'r': 10}, height=450, hovermode='closest') }
def write(input_string, output_path): with open(output_path, "w") as f: writer = csv.writer(f, delimiter="\t") tokens = helper.tokenize(input_string) normalizations = [] tokens_and_normalizations = [] for token in tokens: #normalizing and storing in list normalizations.append(helper.normalize(token)) for i in range(len(tokens)): #creating pairs and storing temporary_pair = [] #them in a nested list temporary_pair.append(tokens[i]) temporary_pair.append(normalizations[i]) tokens_and_normalizations.append(temporary_pair) writer.writerows(tokens_and_normalizations)
def forward(self, x): x = normalize(x) x = self.conv1(x) x = x_1 = self.prelu(x) for block in self.residual_part: x = block(x) x = self.conv2(x) x = self.batch1(x) x.add_(x_1) for block in self.upsample: x = block(x) x = self.conv3(x) x = self.tanh(x) x = denormalize(x) return x
def point_visible_from_camera(self, point, camera_placement): dest = camera_placement.real_camera.position diff = dest - point dist_to_camera = np.linalg.norm(diff) if dist_to_camera is None or dist_to_camera < 0: return False unit_dir = h.normalize(diff) for obj in self.world_objects: dist_to_object = obj.time_to_intersection(point, unit_dir) if dist_to_object is None: continue if obj.time_to_intersection(point, unit_dir) < dist_to_camera: return False return True
def __init__( self, Setup, filename, IRDelay, mode="Flux_vs_TOF", mass=28, verbose=False, plot=True, fit=True, numbasecorr=20, Normalize=True, ): """ ... """ self.__mass = mass self.__filename = filename self.__IRDelay = IRDelay self.__setup = Setup self.__l = Setup.FlightLength self.__offset = 400 self.__Normalize = Normalize self.__numbasecorr = numbasecorr self.__RawData = RawTOFData(filename) TOF, Signal = self.__treat_data(self.__RawData) v, E = self.__invert(TOF) Flux = self.__density_to_flux(Signal, v) if Normalize: Flux = [helper.normalize(flux, 5) for flux in Flux] self.__TOF = (TOF, Flux[0]) self.__v = (v, Flux[1]) self.__E = (E, Flux[2]) self.set_mode(mode) self.__fit = None self.__moments = None if fit: self.fit(verbose=verbose) if plot: self.plot()
def dataframe(self): stats = list() for tr in self.result_page.find("table", { "id": "sortableTable" }).find("tbody").find_all("tr", class_="row"): c = tr.find_all("td") stats.append([ hp.normalize(c[0], "date"), hp.normalize(c[1], "text"), hp.normalize(c[2], "distance"), hp.normalize(c[3], "only_digits"), hp.normalize(c[4], "float"), hp.normalize(c[5], "bends"), hp.normalize(c[6], "only_digits"), hp.normalize(c[7], "by"), hp.normalize(c[9], "remarks"), hp.normalize(c[10], "float"), hp.normalize(c[12], "float"), hp.normalize(c[14], "text"), hp.normalize(c[15], "float"), ]) self.df = pd.DataFrame(stats, columns=[ "date", "local", "distance", "trap", "split", "bends", "position", "by", "remarks", "win_time", "weight", "grade", "cal_time" ]) self.df = self.df[self.df["date"] < self.date] self.df["split"] = self.df["split"].fillna(self.df["split"].mean()) self.df["bends"] = self.df["bends"].fillna(self.df["bends"].mean()) self.df = self.df.dropna(subset=["position"], axis=0) self.total_df = len(self.df)
def _normalize(value): "normalize and do unicodesub" return normalize(self.unicodesub(_repl, value))
# Throwing away column label data_x = data_x[1:] data_y = data_y[1:] # Normalising and splitting dataset for i in range(len(data_x)): # | data_x[i].insert(0, data_y[i]) # | random.shuffle(data_x) # | # | Trecho todo só pra dar o shuffle mimic = copy(data_x) # | data_x, data_y = [], [] # | for row in mimic: # | data_x.append(row[1:]) # | data_y.append(row[0]) # | data_x = hp.normalize(data_x) # Normaliza # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # The THING itself # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ratio = 0.40 # Known base % k = 3 # K distance_func = 'euclidean' bound = int(ratio * len(data_y)) # The classification algorithm my_output_labels = knn(x_train=data_x[:bound], y_train=data_y[:bound], x_test=data_x[bound + 1:], distance=distance_func,
def kps(self): if not hasattr(self, '_kps'): self._kps = normalize(self.Kinv, self.kp) return self._kps
from openpyxl import load_workbook from openpyxl.utils.dataframe import dataframe_to_rows df1 = xl.parse('Script_Cat') df = pd.DataFrame() for i, row in enumerate(df1.values): print(i) codpost_ciudad = '{:02}'.format(int(str(row[10]).replace('<sp>', ' ').split('.')[0])) prov = helper.normalize(helper.getProvincia(codpost_ciudad + '0')) if prov is None: raise Exception('12', '-', 'LA PROVINCIA NO EXISTE') munic = helper.normalize (str(row[11]).replace('<sp>', ' ')) calle = helper.normalize(str(row[12]).replace('<sp>', ' ')) num = int(float(str(row[13]).replace('<sp>', ' '))) puerta = str(row[14]).replace('<sp>', ' ') piso = str(row[15]).replace('<sp>', ' ') try: datos_munic = catas.ConsultaMunicipio(provincia=prov, municipio=munic) data_calle = json.loads(json.dumps(catas.ConsultaVia(provincia=prov, municipio=munic, nombrevia=calle))) if (i == 48): print(i) cod_post = data_calle['consulta_callejero']['callejero']['calle']['loine']['cp'] cod_munic = data_calle['consulta_callejero']['callejero']['calle']['loine']['cm']
for f_sub in os.listdir(path): path_sub = os.path.join(path, f_sub) if os.path.isfile(path_sub): try: img = cv2.imread(path_sub) # rotate img = imutils.rotate( img, rotate) if rotate is not 0 else img # scale img = zoomin(img, scale) if scale > 1 else img # grayscale with 3 channels img = cv2.cvtColor( cv2.cvtColor(img, cv2.COLOR_BGR2GRAY), cv2.COLOR_GRAY2RGB) if grayscale else img # normalize and filter img = normalize(img, EXPECTED_MAX, MEDIAN_VALUE) # gather stat stat[img.shape] = stat[ img.shape] + 1 if img.shape in stat else 1 r = resize(img, EXPECTED_SIZE) append_data_and_label(r, i, data, labels) except Exception as err: print(err) print(path_sub) sys.exit(0) i += 1 count += 1 bar.update(count) bar.finish() print('{} records saved'.format(data.nrows))
validation_file = '../traffic-signs-data/valid.p' testing_file = '../traffic-signs-data/test.p' with open(training_file, mode='rb') as f: train = pickle.load(f) with open(validation_file, mode='rb') as f: valid = pickle.load(f) with open(testing_file, mode='rb') as f: test = pickle.load(f) X_train, y_train = train['features'], train['labels'] X_valid, y_valid = valid['features'], valid['labels'] X_test, y_test = test['features'], test['labels'] # pre-process data X_train_norm, X_valid_norm, X_test_norm = helper.normalize( X_train, X_valid, X_test) label_binarizer = LabelBinarizer() y_one_hot_train = label_binarizer.fit_transform(y_train) y_one_hot_valid = label_binarizer.fit_transform(y_valid) y_one_hot_test = label_binarizer.fit_transform(y_test) # fix the seed for reducing as much as possible variability in the results seed = 10 np.random.seed(seed) # Build Deep Network Model in Keras def create_model(): # create model model = Sequential()
image, brain_atlas = medim_obj.compute_mask("{Brain}", "full", interp=True) _, ventricle_atlas = medim_obj.compute_mask("{Ventricles}", "full", interp=True) raw_image = copy.deepcopy(image) raw_image = helper.z_pad(raw_image) raw_image = helper.xy_pad(raw_image) np.save( "/data/public/Segmentation_Dataset/MR_Dataset_Atlas/train/raw_images/{name}" .format(name=file_name), raw_image.data) image.data = helper.normalize(image.data, brain_atlas.data) image.data = helper.extract_brain(image.data, brain_atlas.data) skull_stripped = helper.z_pad(image) skull_stripped = helper.xy_pad(skull_stripped) np.save( "/data/public/Segmentation_Dataset/MR_Dataset_Atlas/train/skull_stripped/{name}" .format(name=file_name), skull_stripped.data) ventricle_atlas = helper.z_pad(ventricle_atlas) ventricle_atlas = helper.xy_pad(ventricle_atlas) np.save( "/data/public/Segmentation_Dataset/MR_Dataset_Atlas/train/ventricle_atlas/{name}" .format(name=file_name), ventricle_atlas.data)
def normalize_phases(self): helper.normalize(self.xFracs) helper.normalize(self.yFracs)
for goal in goalPos: y, x = goalPos[goal] for i in range(len(world)): for j in range(len(world[i])): if world[i][j] == -1: continue s = (i, j) stateVals[goal][s] = -1*lengthOfPath(s, goal) # Update state values iteratively for i in range(20): # policy is given by old q values oldValues = deepcopy(stateVals) for goal in goalPos: y, x = goalPos[goal] for state in oldValues[goal]: if state == (y, x): stateVals[goal][state] = 0 continue probs = [] vals = [] for a in legalActions(state): ns = (state[0]+a[0], state[1]+a[1]) qa = oldValues[goal][ns]-cost(a) probs.append(math.exp(beta*qa)) vals.append(qa) probs = h.normalize(probs) stateVals[goal][state] = sum([v1*v2 for v1,v2 in zip(probs,vals)])
while frame is not None: font = cv2.FONT_HERSHEY_SIMPLEX bottomLeftCornerOfText = (10, h-10) fontScale = 0.5 fontColor = (0, 0, 255) lineType = 2 # Since mhis are calculated by diffs of images, there will # necessarily be one less prediction than the number of frames img = frame if frame_index != 0 and binary_images[frame_index-1].sum() != 0: img = cv2.putText(frame, pred[frame_index-1], bottomLeftCornerOfText, font, fontScale, fontColor, lineType) if GENERATE_IMAGE and frame_index == 100: cv2.imwrite('classify1_handwaving.png', helper.normalize(img)) if GENERATE_IMAGE and frame_index == 110: cv2.imwrite('classify2_handwaving.png', helper.normalize(img)) if GENERATE_IMAGE and frame_index == 148: cv2.imwrite('classify_handclapping.png', helper.normalize(img)) video_out.write(img) frame = frame_gen.__next__() frame_index += 1 video_out.release()
def __init__(self, point, normal): self.p = point self.n = h.normalize(normal)
print(f"{i}/{len(scans)}") medim_obj = MedImage.create_from_files(scan) file_name = medim_obj.name.split("/")[-1] image, brain_mask = medim_obj.compute_mask("{Brain}", "full", interp=True) _, ventricle_mask = medim_obj.compute_mask("{Ventricles}", "full", interp=True) _, brain_atlas = medim_obj.compute_mask("{BrainAtlas}", "full", interp=True) _, ventricle_atlas = medim_obj.compute_mask("{VentriclesAtlas}", "full", interp=True) raw_image = copy.deepcopy(image) raw_image = helper.z_pad(raw_image) raw_image = helper.xy_pad(raw_image) image.data = helper.normalize(image.data, brain_mask.data) image.data = helper.extract_brain(image.data, brain_mask.data) skull_stripped = helper.z_pad(image) skull_stripped = helper.xy_pad(skull_stripped) ventricle_mask = helper.z_pad(ventricle_mask) ventricle_mask = helper.xy_pad(ventricle_mask) brain_mask = helper.z_pad(brain_mask) brain_mask = helper.xy_pad(brain_mask) ventricle_atlas = helper.z_pad(ventricle_atlas) ventricle_atlas = helper.xy_pad(ventricle_atlas) brain_atlas = helper.z_pad(brain_atlas)