def average_nearest_neighbor_distance(points, mark=None): if mark!=None: marked_points = [] shortest_path = [] for x in range(len(points)): if points[x].get_mark() == mark: marked_points.append(points[x].get_point()) for num1, p_one in enumerate(marked_points): distance = [] for num2, p_two in enumerate(marked_points): if num1 != num2: distance.append(utils.euclidean_distance(p_one, p_two)) shortest_path.append(min(distance)) mean_d = sum(shortest_path)/len(shortest_path) return mean_d else: shortest_path = [] for num1, p_one in enumerate(points): distance = [] for num2, p_two in enumerate(points): if num1 != num2: distance.append(utils.euclidean_distance(p_one, p_two)) shortest_path.append(min(distance)) mean_d = sum(shortest_path)/len(shortest_path) return mean_d
def test_euclidean_distance(self): """ A test to ensure that the distance between points is being properly computed. You do not need to make any changes to this test, instead, in utils.py, you must complete the `eucliden_distance` function so that the correct values are returned. Something to think about: Why might you want to test different cases, e.g. all positive integers, positive and negative floats, coincident points? """ point_a = (3, 7) point_b = (1, 9) distance = utils.euclidean_distance(point_a, point_b) self.assertAlmostEqual(2.8284271, distance, 4) point_a = (-1.25, 2.35) point_b = (4.2, -3.1) distance = utils.euclidean_distance(point_a, point_b) self.assertAlmostEqual(7.7074639, distance, 4) point_a = (0, 0) point_b = (0, 0) distance = utils.euclidean_distance(point_b, point_a) self.assertAlmostEqual(0.0, distance, 4)
def search( self, maze: List[List[int]], start: Tuple[int, int], goal: Tuple[int, int], neighborhood: str = "N8", radius: float = 0, ) -> List[Tuple[int, int]]: if not self._is_free_cell(start, maze): return [] open_set: PriorityQueue[Tuple[int, int]] = PriorityQueue() open_set.push(start, 0) came_from: Dict[Tuple[int, int], Optional[Tuple[int, int]]] = { start: None } dist: Dict[Tuple[int, int], float] = {start: 0} while not open_set.empty(): current = open_set.pop() if euclidean_distance(current, goal) <= radius: return self._reconstruct_path(current, came_from) for node in self._get_neighbors(current, maze, neighborhood): new_dist = dist[current] + euclidean_distance(current, node) if node not in dist or new_dist < dist[node]: came_from[node], dist[node] = current, new_dist open_set.push(node, new_dist + self.heuristic(node, goal)) return []
def random_solution(self): cost = 0 pending = [] result = [] mapped_result = [] mapped = {} for i in range(0, len(self.coordinates)): pending.append(self.coordinates[i]) mapped[self.coordinates[i]] = i while len(pending) != 0: pos = int(round(uniform(0, len(pending) - 1))) result.append(pending[pos]) mapped_result.append(mapped[pending[pos]] + 1) pending.remove(pending[pos]) if len(result) >= 2: cost += euclidean_distance(result[len(result) - 1], result[len(result) - 2]) if len(result) >= 2: cost += euclidean_distance(result[0], result[len(result) - 1]) return result, cost
def average_nearest_neighbor_distance(points,mark=None): mean_d = 0 if(mark==None): for i in range(len(points)): dist_nearest=math.inf for j in range(len(points)): temp_p1 = (points[i].x, points[i].y) temp_p2 = (points[j].x, points[j].y) dist = utils.euclidean_distance(temp_p1, temp_p2) if temp_p1 == temp_p2: continue elif dist < dist_nearest: dist_nearest = dist; mean_d += dist_nearest; mean_d=mean_d/(len(points)) else: for i in range(len(points)): dist_nearest=math.inf for j in range(len(points)): dist = utils.euclidean_distance((points[i].x, points[i].y), (points[j].x,points[j].y)) if temp_p1 == temp_p2: continue elif dist < dist_nearest and temp_p1==temp_p2: dist_nearest = dist; mean_d += dist_nearest; mean_d=mean_d/(len(points)) return mean_d
def complete_linkage(subcluster_1, subcluster_2): flattened_1 = flatten(subcluster_1) flattened_2 = flatten(subcluster_2) best_max = float("-inf") for x1 in flattened_1: for x2 in flattened_2: if best_max < euclidean_distance(x1, x2): best_max = euclidean_distance(x1, x2) return best_max
def single_linkage(subcluster_1, subcluster_2): flattened_1 = flatten(subcluster_1) flattened_2 = flatten(subcluster_2) best_min = float("inf") for x1 in flattened_1: for x2 in flattened_2: if best_min > euclidean_distance(x1, x2): best_min = euclidean_distance(x1, x2) return best_min
def test_euclidean_distance(self): p2D = [0.3, 0.5] q2D = [1.3, 1.2] self.assertAlmostEqual(utl.euclidean_distance(p2D, q2D), 1.220656, 6) p3D = [0.3, 0.5, 0.8] q3D = [1.3, 0.4, 1.2] self.assertAlmostEqual(utl.euclidean_distance(p3D, q3D), 1.081665, 6) p0 = [0.0] * 40 q0 = [0.0] * 40 self.assertEqual(utl.euclidean_distance(p0, q0), 0)
def calculate(self, individuals, membership_matrix, centers): """ fuzzy_membership should be ELEMENTSxCLUSTERS matrix """ min_cluster_distance = min(euclidean_distance(first, second) ** 2 for first, second in combinations(centers, 2)) clusterization_scattering = 0 for cluster_index in xrange(len(centers)): for individual_index in xrange(len(individuals)): membership = membership_matrix[individual_index][cluster_index] ** self._m distance = euclidean_distance(individuals[individual_index], centers[cluster_index]) ** 2 clusterization_scattering += membership * distance return clusterization_scattering / min_cluster_distance * self._c
def attaction_force(self, agent, myx, myy, fromx, fromy): # TODO - clean this up nx, ny = ((agent.position.y - fromy) / euclidean_distance((agent.position.x, agent.position.y), (fromx, fromy))), \ ((agent.position.x - fromx) / euclidean_distance((agent.x, agent.position.y), (fromx, fromy))) oc11, oc12 = agent.position.x + self.radius * nx, agent.position.y - self.radius * ny oc21, oc22 = agent.position.x - self.radius * nx, agent.position.y + self.radius * ny pn = self.normal_point(myx, myy, oc11, oc12, oc21, oc22) pdist = euclidean_distance((myx, myy), (pn[0],pn[1])) if pdist == 0: return (0, 0, 0) return ((pn[0]-myx)/pdist, (pn[1]-myy)/pdist, 0 )
def pair_triplet_accuracy(y_true: TensorLike, y_pred: TensorLike, margin: FloatTensorLike = 1.0, distance_metric: Union[str, Callable] = "L2"): """ Calculates how often predictions matches the cut/non cut labels. Convert two embeddings into label `labels_pred` by calculating distance and threshold using margin. It computes the frequency with which `labels_pred` matches `y_true`. This frequency is ultimately returned as `pair accuracy`. Args: y_true: Integer ground truth values. y_pred: 3-D float `Tensor` of representational embedding of RNA and gRNA. [batch, 2, embedding_dim] margin: Float, threshold distance. distance_metric: String, distance metric in use. Returns: Float, accuracy values. """ embeddings = ops.convert_to_tensor_v2_with_dispatch(y_pred) labels = ops.convert_to_tensor_v2_with_dispatch(y_true) convert_to_float32 = ( embeddings.dtype == tf.dtypes.float16 or \ embeddings.dtype == tf.dtypes.bfloat16 ) precise_embeddings = ( tf.cast(embeddings, tf.dtypes.float32) \ if convert_to_float32 else embeddings ) if distance_metric == "L2": dist = euclidean_distance(precise_embeddings[:, 0], precise_embeddings[:, 1]) elif distance_metric == "squared-L2": dist = tf.square( euclidean_distance(precise_embeddings[:, 0], precise_embeddings[:, 1])) elif distance_metric == "L1": dist = manhattan_distance(precise_embeddings[:, 0], precise_embeddings[:, 1]) else: # Callable dist = distance_metric(precise_embeddings[:, 0], precise_embeddings[:, 1]) labels_pred = dist <= margin return math_ops.cast( math_ops.equal(tf.cast(tf.math.floormod(y_true, 2), tf.dtypes.bool), labels_pred), K.floatx())
def _get_distance_matrix(self, sorted_locs: List[Location]) -> List[List[float]]: n = len(sorted_locs) matrix = [[0.0 for _ in range(n)] for _ in range(n)] for i in range(n): for j in range(n): matrix[i][j] = euclidean_distance(sorted_locs[i], sorted_locs[j]) return matrix
def h(self, node): """The heuristic h(n) function: here it's used the straight distance.""" locs = self.locations if locs: return int(euclidean_distance(locs[node.state], locs[self.goal])) else: return math.inf
def classify_one(self, test_example: Examples) -> int: committee = [] for train_example in self._train_examples: insort(committee, CommitteeWrapper(train_example[0], euclidean_distance(test_example, train_example))) votes_num, vote_for, vote_against, under_bound = 0, 0, 0, (0, 0) for vote in committee: if vote.distance < self._bound: under_bound = (vote_for, vote_against) if votes_num >= self._k: break if vote == 1: vote_for += 1 else: vote_against += 1 votes_num += 1 if vote_for >= vote_against: return 1 # KNN wants to classify as Negative to disease (healthy), let's get a second opinion if self._id3_classifier is None: self._id3_classifier = ID3ContinuousFeatures(self._train_examples) if self._id3_classifier.classify_one(test_example): return 1 # Both KNN and ID3 want to classify as Negative to disease (healthy), let's get a third final opinion return under_bound[0] > under_bound[1]
def compute_dbi(embs, clus_map, center_map): n_clus = len(center_map) c_centers = {} for c_center in center_map: cid = center_map[c_center] c_centers[int(cid)] = embs[c_center] M = [[0 for x in range(n_clus)] for y in range(n_clus)] R = [[0 for x in range(n_clus)] for y in range(n_clus)] S = [0 for x in range(n_clus)] D = [0 for x in range(n_clus)] for i in range(n_clus): c_embs = [embs[x] for x in clus_map[i]] S[i] = utils.euclidean_cluster(c_embs, c_centers[i]) for i in range(n_clus): for j in range(n_clus): if i != j: M[i][j] = utils.euclidean_distance(c_centers[i], c_centers[j]) R[i][j] = (S[i] + S[j]) / M[i][j] for i in range(n_clus): for j in range(n_clus): if i != j and R[i][j] > D[i]: D[i] = R[i][j] return sum(D) / len(D)
def _search_tree(self, root, x): """搜索kd树 Args: root: 开始搜索的树节点 x: 需要判定类别的样本 """ if root is None: return split_axis = root['split_axis'] if x[split_axis] < root['data'][split_axis]: self._search_tree(root['left'], x) else: self._search_tree(root['right'], x) heapq.heappush(self.neighbors, (-1 * euclidean_distance(x, root['data'][1:]), next(counter), root['data'])) if len(self.neighbors) > self.k: heapq.heappop(self.neighbors) split_dist = abs(x[split_axis] - root['data'][split_axis]) neighbor_max = -1 * heapq.nsmallest(1, self.neighbors)[0][0] if split_dist > neighbor_max: return if x[split_axis] < root['data'][split_axis]: self._search_tree(root['right'], x) else: self._search_tree(root['left'], x)
def predict(self, X_train, y_train, X_test, kd_tree=False): """用训练集来预测测试集 Args: X_train: 训练特征数据 y_train: 训练标签数据 X_test: 测试特征数据 kd_tree: True代表使用kd树搜索,False代表使用线性扫描 Returns pred: 针对X_test的预测结果 """ pred = np.empty(X_test.shape[0]) if kd_tree: data = np.insert(X_train, 0, y_train, axis=1) n_features = np.array(data).shape[1] self.split_order = random.sample(range(1, n_features), n_features - 1) root = self._build_kd_tree(data, 0) for i, sample in enumerate(X_test): # print(f'processing sample {i + 1} / {len(X_test)}') self.neighbors.clear() self._search_tree(root, sample) neighbors = np.array([x[0] for d, c, x in self.neighbors]) pred[i] = self._vote(neighbors) else: for i, sample in enumerate(X_test): # print(f'processing sample {i + 1} / {len(X_test)}') idx = np.argsort([euclidean_distance(x, sample) for x in X_train])[:self.k] neighbors = np.array([y_train[j] for j in idx]) pred[i] = self._vote(neighbors) return pred
def test_arange(): a = np.arange(4).reshape(2, 2) print(a) print(np.diag(a)) print(np.einsum('i...i', a)) print(euclidean_distance(p1_array, p2_array)) print(f1_score(p1_array, p2_array))
def get_costs_matrix(actual_blobs, detections, threshold): # the costs matrix width has to be larger or equal than height rows_count = len(actual_blobs) if rows_count > len(detections): columns_count = rows_count for i in range(0, len(actual_blobs) - len(detections)): detections = np.append(detections, Detection()) else: columns_count = len(detections) costs_matrix = np.zeros(shape=(rows_count, columns_count), dtype=float) for i, blob in enumerate(actual_blobs): for j, detection in enumerate(detections): if detection.position is None: costs_matrix[i][j] = INFINITE else: distance = euclidean_distance( blob_center(blob), blob_center(detection.position) ) costs_matrix[i][j] = \ distance if distance <= threshold else INFINITE return costs_matrix, detections
def assign_label(self): all_labeled_y, all_labeled_x = read_input('./datas/all_label.p') all_labeled_imgs = self.encoder.predict(all_labeled_x) all_unlabeled_x = read_input('./datas/all_unlabel.p') all_unlabeled_imgs = self.encoder.predict(all_unlabeled_x) index = -1 for unlabeled_img in tqdm(all_unlabeled_imgs): index += 1 target_img = all_unlabeled_x[index] target_img = target_img.reshape((1,) + target_img.shape) all_distance = [euclidean_distance(unlabeled_img, labeled_img) for labeled_img in all_labeled_imgs] index_of_max = min(range(len(all_distance)), key = lambda i: all_distance[i]) assigned_label = all_labeled_y[index_of_max] all_labeled_x = np.concatenate((all_labeled_x, target_img), axis=0) all_labeled_y = np.concatenate((all_labeled_y, np.array([assigned_label])), axis=0) # # for debug # origin_img = all_labeled_x[index_of_max] # target_img = np.reshape(target_img, (3, 32, 32)) # origin_img = np.reshape(origin_img, (3, 32, 32)) # pyplot.figure(figsize=[4, 4]) # pyplot.subplot(2, 2, 1) # pyplot.imshow(toimage(origin_img)) # pyplot.subplot(2, 2, 2) # pyplot.imshow(toimage(target_img)) # pyplot.show() output_dict = dict({'data': all_labeled_x, 'labels': all_labeled_y}) output_path = 'datas/relabeled_img.p' import pickle with open(output_path, 'wb') as handle: print("Save output at %s " % output_path) pickle.dump(output_dict, handle, protocol=pickle.HIGHEST_PROTOCOL)
def batch_hard(axs, ays): """ Returns hard positives and hard negatives for anchors (axs argument). Computes euclidean distance using numpy functionalities (W/O CUDA). Then, for each embedding finds farthest embedding as hard positive from the same class. As hard negatives it chooses nearest embedding from different class. :param axs: ndarray (N, EMBEDDING_SIZE) :param ays: ndarray (N,) :return: tuple, (hard_positives: ndarray (N, EMBEDDING_SIZE) , hard_negatives: ndarray (N, EMBEDDING_SIZE)) """ distance_matrix = euclidean_distance(axs, axs) # matrix side size ays = ays.reshape(-1, 1) num = ays.shape[0] diagonal_idxs = np.diag_indices(num) # mask items where labels are equal y_equals = ays == ays.T # let's find HARD POSITIVES y_equals[diagonal_idxs] = False d2p = distance_matrix.copy() # we are going to find hard positive - the most distant positive # therefore set -infinity distance to the same items d2p[y_equals == False] = -np.inf p_idxs = np.argmax(d2p, axis=1) hard_positives = axs[p_idxs] # let's find HARD NEGATIVES d2n = distance_matrix.copy() y_equals[diagonal_idxs] = True d2n[y_equals == True] = np.inf n_idxs = np.argmin(d2n, axis=1) hard_negatives = axs[n_idxs] return hard_positives, hard_negatives
def average_nearest_neighbor_distance(points_list, mark = None): points = None if mark is None: points = points_list else: points = list(filter(lambda current_point: current_point.mark['color'] == mark, points_list)) mean_d = 0 temp_nearest_neighbor = None for i, point in enumerate(points): for j, otherPoint in enumerate(points): if i == j: continue current_distance = utils.euclidean_distance((point.x, point.y), (otherPoint.x, otherPoint.y)) if temp_nearest_neighbor is None: temp_nearest_neighbor = current_distance elif temp_nearest_neighbor > current_distance: temp_nearest_neighbor = current_distance mean_d += temp_nearest_neighbor temp_nearest_neighbor = None mean_d /= len(points) return mean_d
def get_torso_subimage(self): """ Extract a subimage of just a torso for given person view. Should be better for histograms since contains less surroundings than the whole person box. :return: subimage containing only the torso """ image_width = self.original_image.shape[1] body_height = int( euclidean_distance(self.pose_top_coordinate, self.pose_bottom_coordinate)) # an average body's width from side is about one third of the height (half of the height from front) half_body_width = int(body_height / 6) pose_top_left = (min(self.pose_top_coordinate[0], self.pose_bottom_coordinate[0]), min(self.pose_top_coordinate[1], self.pose_bottom_coordinate[1])) pose_bottom_right = (max(self.pose_top_coordinate[0], self.pose_bottom_coordinate[0]), max(self.pose_top_coordinate[1], self.pose_bottom_coordinate[1])) roi_top_left = (max(0, pose_top_left[0] - half_body_width), pose_top_left[1]) roi_bottom_right = (min(image_width, pose_bottom_right[0] + half_body_width), pose_bottom_right[1]) return self.original_image[roi_top_left[1]:roi_bottom_right[1] + 1, roi_top_left[0]:roi_bottom_right[0] + 1]
def calculate_scatter(cls, cluster_individuals, center): """ Calculates the scatter of cluster. """ return (sum( euclidean_distance(individual, center) for individual in cluster_individuals) + 0.) / len(cluster_individuals)
def enumerate_states(player_model, start_state, graph, action_set): start_state_str = start_state.to_str() graph.add_node(start_state_str) unexplored_states = set([start_state_str]) explored_states = set() while len(unexplored_states) > 0: cur_state_str = unexplored_states.pop() explored_states.add(cur_state_str) cur_state = State.from_str(cur_state_str) for action in action_set: next_state = player_model.next_state(state=cur_state, action=action) next_state_str = next_state.to_str() if next_state_str not in explored_states and next_state_str not in unexplored_states: graph.add_node(next_state_str) unexplored_states.add(next_state_str) if not graph.has_edge(cur_state_str, next_state_str): distance = euclidean_distance((cur_state.x, cur_state.y), (next_state.x, next_state.y)) graph.add_edge(cur_state_str, next_state_str, weight=distance, action=[action.to_str()]) else: graph.get_edge_data(cur_state_str, next_state_str)["action"].append( action.to_str()) print('graph size:', len(graph.nodes), len(graph.edges)) return graph
def main(): players = Player.random_player_set(NUMBER_PLAYERS) # players = [] # players.append(Player(Personality(0., 0., 0.))) # players.append(Player(Personality(1., 0., 0.))) # players.append(Player(Personality(0., 1., 0.))) # players.append(Player(Personality(0., 0., 1.))) # players.append(Player(Personality(1., 0., 1.))) # players.append(Player(Personality(0., 1., 1.))) # players.append(Player(Personality(1., 1., 0.))) # players.append(Player(Personality(1., 1., 1.))) # players.append(Player(Personality(1., 1., 1.))) player_vectors = [] player_favourite_level_map = {} levels = Level.random_level_set(NUMBER_LEVELS) level_vectors = {level: level.to_vector() for level in levels} for player in players: player_vector, favourite_level = player.play_levels(levels, level_vectors) player_vectors.append(player_vector) player_favourite_level_map[player] = favourite_level # pprint.pprint(player_vectors) # pprint.pprint(level_vectors) # pprint.pprint(player_favourite_level_map) actual_player_vectors = [player.to_vector() for player in players] x_coordinates = [] x2_coordinates = [] y_coordinates = [] for i in range(len(players)): for j in range(i + 1, len(players)): x = euclidean_distance(player_vectors[i].values(), player_vectors[j].values()) x2 = euclidean_distance(actual_player_vectors[i].values(), actual_player_vectors[j].values()) y = euclidean_distance(level_vectors[player_favourite_level_map[players[i]]].values(), level_vectors[player_favourite_level_map[players[j]]].values()) x_coordinates.append(x) x2_coordinates.append(x2) y_coordinates.append(y) return x_coordinates, y_coordinates, x2_coordinates
def set_edges(graph, threshold): for v in graph.nodes(data=True): for u in (n for n in graph.nodes(data=True) if (n != v)): if (v[1]['long'] - threshold < u[1]['long'] < v[1]['long'] + threshold) \ and (v[1]['lat'] - threshold < u[1]['lat'] < v[1]['lat'] + threshold): graph.add_edge(v[0], u[0], a=v[1]['city'], b=u[1]['city'], weight=utils.euclidean_distance(v[1]['long'], v[1]['lat'], u[1]['long'], u[1]['lat'])) return graph
def count_close_point(self, x, cluster): close_point_count = 0 for j in range(len(cluster)): if (euclidean_distance(x, cluster[j]) <= self.epsilon): close_point_count += 1 return close_point_count
def find_marker(query, image): """ Searches for the marker object in the image Parameters: query: picture of the object to search for, also called the query image image: image to search within, also called the train image return: list containing top left and top right coordinate of rectangle around object rtype: list """ orb = cv2.ORB_create() kp_q, des_q = orb.detectAndCompute(query, None) kp_i, des_i = orb.detectAndCompute(image, None) bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True) matches = bf.match(des_q, des_i) matches = sorted(matches, key=lambda x: x.distance) top_half = matches[:(int(len(matches) / 2))] points = {} for match in top_half: idx = match.trainIdx points[idx] = kp_i[idx].pt x = 0 y = 0 cnt = 0 # accumulation for center for pair in points.values(): x += pair[0] y += pair[1] cnt += 1 center = (x / cnt, y / cnt) top_half = sorted( top_half, key=lambda x: utils.euclidean_distance(center[0], center[ 1], points[x.trainIdx][0], points[x.trainIdx][1])) good_matches = top_half[:(int(len(top_half) / 2))] # find bounding rectangle coords left = bottom = sys.maxsize right = top = -sys.maxsize - 1 for match in good_matches: idx = match.trainIdx pt = kp_i[idx].pt top = int(max(top, pt[1])) left = int(min(left, pt[0])) bottom = int(min(bottom, pt[1])) right = int(max(right, pt[0])) return [(top, left), (bottom, right)]
def test_euclidean_distance(self, xs, ys): """ Tests equivalence RMSE and computed distance.""" distance_matrix = euclidean_distance(xs, xs) is_ok = True for i in range(distance_matrix.shape[0]): rmse = np.sqrt(np.mean(np.square(xs[i:i+1] - xs), 1)) dm_1st_row = distance_matrix[i, :] is_ok = is_ok and np.array_equal(dm_1st_row, rmse) self.assertEqual(is_ok, True)
def init_distance_matrix(self): self.distance_matrix = [[0 for x in range(self.data_length)] for x in range(self.data_length)] for i in range(self.data_length): for j in range(i, self.data_length): self.distance_matrix[i][j] = euclidean_distance( self.data[i], self.data[j]) self.distance_matrix[j][i] = self.distance_matrix[i][j]
def reached_waypoint(self, waypoint): """ Check if the agent has reached the given waypoint so we advance to the next one. Reaching means being in the waypoint circle """ if euclidean_distance((self._position.x, self._position.y), waypoint.position) <= waypoint.radius: return True else: return False
def avg_group_linkage(subcluster_1, subcluster_2): flattened_1 = flatten(subcluster_1) flattened_2 = flatten(subcluster_2) # find mean / centroid avg_1 = tuple(sum(elements)/len(flattened_1) for elements in zip(*flattened_1)) avg_2 = tuple(sum(elements)/len(flattened_2) for elements in zip(*flattened_2)) # calculate distance between centroid return euclidean_distance(avg_1, avg_2)
def find_neighbors(self) -> list: n_rows, n_col = self.S.shape neighbors_list = [None for i in range(0, n_rows)] for i in range(0, n_rows): distance_vector = euclidean_distance(self.S[i, :], self.S) distance_vector[i] = np.inf # So that point isn't his own neighbor neighbors_list[i] = np.where( distance_vector <= self.nbr_max_distance) return neighbors_list
def _closest_centroid(self, sample, centroids): """ Return the index of the closest centroid to the sample """ closest_i = 0 closest_dist = float('inf') for i, centroid in enumerate(centroids): distance = euclidean_distance(sample, centroid) if distance < closest_dist: closest_i = i closest_dist = distance return closest_i
def calculate_distances(self): """Calculate distance between nodes and save it to a matrix.""" distances = np.zeros((self.n, self.n)) for i, node_i in enumerate(self.nodes): for j, node_j in enumerate(self.nodes): distances[i][j] = utils.euclidean_distance(node_i, node_j) return distances
def _circle_intersection(self, circle, point): """ Compute the distance and point on the boundary of the circle intersected by a line from its center to the point """ dist = euclidean_distance((circle[0], circle[1]), point) - circle[2] vun = vec2d((circle[0] - point[0]), (circle[1] - point[1])) v = vun.normalized() x, y = (point[0] + dist * v.x), (point[0] + dist * v.x) return dist, (x, y)
def average_nearest_neighbor_distance(points): mean_d = 0 for i in points: dist_nearest=1e9 for j in points: dist = utils.euclidean_distance(i, j) if i==j: continue elif dist < dist_nearest: dist_nearest = dist; mean_d += dist_nearest; mean_d=mean_d/(len(points)) return mean_d
def _line_intersection(self, line, point): """ Fine the point of intersetion of a line and a point Line is given as (x1,y1, x2,y2), point (x,y) based on http://paulbourke.net/geometry/pointlineplane/ """ den = euclidean_distance((line[0],line[1]), (line[2],line[3])) x1, y1, x2, y2 = line[0], line[1], line[2], line[3] x3, y3 = point[0], point[1] u = ( ((x3-x1) * (x2-x1)) + ((y3-y1) * (y2-y1)) ) / den x, y = (x1 + u * (x2-x1)), (y1 + u * (y2-y1)) dist = euclidean_distance((x,y), point) # pygame.draw.circle(self.screen, SIM_COLORS['aqua'], # (int(x*SCALE), int(y*SCALE)), # int(40), # 0) # print dist*SCALE, (x*SCALE,y*SCALE) return dist, (x, y)
def main(): parser = argparse.ArgumentParser() parser.add_argument('img', help=('Path of the image to perform the' ' transform')) parser.add_argument('--rmin', type=int, help='rmin parameter', default=23) parser.add_argument('--rmax', type=int, help='rmax parameter', default=48) args = parser.parse_args() try: with open(args.img, 'rb'): pass except IOError: print >> sys.stderr, "%s could not be opened" % args.img return 1 rmin_range = (0, 100) if not (rmin_range[0] < args.rmin < rmin_range[1]): print >> sys.stderr, "rmin should be between %d and %d" % rmin_range return 2 if not (rmin_range[0] < args.rmax < rmin_range[1]): print >> sys.stderr, "rmax should be between %d and %d" % rmin_range return 2 if args.rmin >= args.rmax: print >> sys.stderr, 'rmin should be less than rmax' return 3 aimg = image2array(args.img) freq_ = fft(aimg) shift_freq = fftshift(freq_) center = (shift_freq.shape[0] / 2, shift_freq.shape[1] / 2) distance_array = euclidean_distance(shift_freq, center) mask = (distance_array < args.rmin) != (distance_array > args.rmax) shift_freq_cpy = shift_freq.copy() shift_freq_cpy[mask] = 0 output = fft(fftshift(shift_freq_cpy, True), True) plot([aimg, prepare_show(shift_freq), prepare_show(shift_freq_cpy), prepare_show(output, False)]) return 0
def average_nearest_neighbor_distance_marks(points,mark=None): mean_d = 0 for i in range(len(points)): dist_nearest=1e9 for j in range(len(points)): temp_p1 = (points[i].x, points[i].y) temp_p2 = (points[j].x, points[j].y) dist = utils.euclidean_distance(temp_p1, temp_p2) if temp_p1 == temp_p2: continue elif dist < dist_nearest: dist_nearest = dist; mean_d += dist_nearest; mean_d=mean_d/(len(points)) return mean_d
def _calculate_distances_to_points(self): """ Method calculates the distance of each point to the neighbouring points (closed loop assumed) returns: distance matrix of dimensions (num_images, num_landmarks) """ distances = np.zeros((len(self.points), len(self.points[0]) / 2)) collector = DataManipulations.DataCollector(None) for img in range(len(self.points)): collector.read_vector(self.points[img, :]) points = collector.as_matrix() for ref_point_ind in range(len(points)): distances[img, ref_point_ind] = sum([utils.euclidean_distance(points[ref_point_ind, :], x) for x in points]) return distances
def write_your_own(gj): def mean_center(points): """ Given a set of points, compute the mean center Parameters ---------- points : list A list of points in the form (x,y) Returns ------- x : float Mean x coordinate y : float Mean y coordinate """ sums = map(sum,zip(*points)) sumsL = list(sums) avgs = map(lambda xy: xy/len(points),sumsL) avgsL = list(avgs) x = avgsL[0] y = avgsL[1] return x,y def average_nearest_neighbor_distance(points): """ Given a set of points, compute the average nearest neighbor. Parameters ---------- points : list A list of points in the form (x,y) Returns ------- mean_d : float Average nearest neighbor distance References ---------- Clark and Evan (1954 Distance to Nearest Neighbor as a Measure of Spatial Relationships in Populations. Ecology. 35(4) p. 445-453. """ shDistL =[] mean_sum = 0 for point in points: shortestDistance = 9999999999 for dpoint in points: if point != dpoint: dist = euclidean_distance(point, dpoint) if(shortestDistance > dist): shortestDistance = dist shDistL.append(shortestDistance) mean_sum = shortestDistance + mean_sum print(shDistL) sums = sum(shDistL) mean_d = mean_sum/len(shDistL) return mean_d