def test_a_distance(self):
a = Distance(self.earth, self.office)
for i in range(len(self.result)):
distance = a.get_km(self.testLat[i], self.testLon[i])
self.assertEqual(distance, self.result[i])
print('DISTANCE TESTS PASSED')
def __init__(self, node, outer_d, shortlist, key, find_value, rpc):
self.node = node
self.outer_d = outer_d
self.shortlist = shortlist
self.key = key
self.find_value = find_value
self.rpc = rpc
# all distance operations in this class only care about the distance
# to self.key, so this makes it easier to calculate those
self.distance = Distance(key)
# List of active queries; len() indicates number of active probes
#
# n.b: using lists for these variables, because Python doesn't
# allow binding a new value to a name in an enclosing
# (non-global) scope
self.active_probes = []
# List of contact IDs that have already been queried
self.already_contacted = []
# Probes that were active during the previous iteration
# A list of found and known-to-be-active remote nodes
self.active_contacts = []
# This should only contain one entry; the next scheduled iteration call
self.pending_iteration_calls = []
self.prev_closest_node = [None]
self.find_value_result = {}
self.slow_node_count = [0]
def __init__(self, node, shortlist, key, rpc, exclude=None):
self.exclude = set(exclude or [])
self.node = node
self.finished_deferred = defer.Deferred()
# all distance operations in this class only care about the distance
# to self.key, so this makes it easier to calculate those
self.distance = Distance(key)
# The closest known and active node yet found
self.closest_node = None if not shortlist else shortlist[0]
self.prev_closest_node = None
# Shortlist of contact objects (the k closest known contacts to the key from the routing table)
self.shortlist = shortlist
# The search key
self.key = str(key)
# The rpc method name (findValue or findNode)
self.rpc = rpc
# List of active queries; len() indicates number of active probes
self.active_probes = []
# List of contact (address, port) tuples that have already been queried, includes contacts that didn't reply
self.already_contacted = []
# A list of found and known-to-be-active remote nodes (Contact objects)
self.active_contacts = []
# Ensure only one searchIteration call is running at a time
self._search_iteration_semaphore = defer.DeferredSemaphore(1)
self._iteration_count = 0
self.find_value_result = {}
self.pending_iteration_calls = []
def get_crime_count(self, area_index):
dist = Dist()
output = []
for i in range(self.occurences - 1):
lat1, lon1 = self.areas[area_index][0], self.areas[area_index][1]
lat2, lon2 = self.crimeData["lat"][i +
1], self.crimeData["long"][i +
1]
d = dist.calculate_dist_in_miles(lat1, lon1, lat2, lon2)
if d <= self.MAX_DIST:
output.append(self.crimeData["type"][i])
# unique_elements, counts_elements = np.unique(np.array(output), return_counts=True)
output_dict = {}
# for i in range(unique_elements):
# output_dict[unique_elements[i]] = counts_elements[i]
df = pd.DataFrame(output, columns=['type'])
unique_elements = df['type'].value_counts().keys().tolist()
counts_elements = df['type'].value_counts().tolist()
for i in range(len(unique_elements)):
output_dict[unique_elements[i]] = counts_elements[i]
return output_dict
def reset(self, episode):
# prefix_state --> [split_point, index]
# suffix_state --> [index + 1, len - 1]
# return observation
self.split_point = 0
self.DIS = Distance(len(self.cand_train_data[episode]), len(self.query_train_data[episode]))
self.DIS_R = Distance(len(self.cand_train_data[episode]), len(self.query_train_data[episode]))
self.length = len(self.cand_train_data[episode])
self.presim = self.DIS.FRECHET(self.cand_train_data[episode][self.split_point:1], self.query_train_data[episode])
self.sufsim = self.DIS_R.FRECHET(self.cand_train_data[episode][1:][::-1],self.query_train_data[episode][::-1])
whole = self.DIS_R.FRECHET(self.cand_train_data[episode][::-1],self.query_train_data[episode][::-1]) #self.DIS.FRECHET(self.cand_train_data[episode], self.query_train_data[episode])
observation = np.array([whole, self.presim, self.sufsim]).reshape(1,-1)
self.subsim = min(whole, self.presim, self.sufsim)
#print('episode', episode, whole, self.presim, self.sufsim)
if self.subsim == whole:
self.subtraj = [0, self.length - 1]
if self.subsim == self.presim:
self.subtraj = [0, 0]
if self.subsim == self.sufsim:
self.subtraj = [1, self.length - 1]
return observation, self.length
def autopilot_process(self, q_state):
while True:
distance = Distance()
cm = distance.detect()
self.display_text('Distance:')
self.display_text(cm)
print int(cm)
if int(cm) <= 30:
self.display_text('Obstacle!')
self.stop_motors()
time.sleep(1)
self.run_down_start()
time.sleep(0.3)
self.run_down_stop()
time.sleep(0.3)
self.run_right_start()
time.sleep(0.3)
self.run_right_stop()
print 'end obstacle'
else:
self.display_text('run!')
self.run_up_start()
if not q_state.empty():
exit = q_state.get()
if exit == 'autopilot_stop':
print 'autopilot stop...'
break
if exit == 'exit':
print 'stoping autopilot...'
break
def is_in_way(self, plane, start_loc=None, heading=None):
# FIXME currently only testing linear part
if not start_loc:
start_loc = plane.loc
if not heading:
heading = plane.heading
turn_dist = Distance.get_turn_dist(plane)
turn_angle = Distance.get_turn_angle(plane)
wp_dist = start_loc.get_distance(plane.next_wp, angle=heading) \
.subtract(turn_dist).get_transform(turn_angle)
obs_dist = start_loc.get_distance(self.loc, angle=heading) \
.subtract(turn_dist).get_transform(turn_angle)
if obs_dist < 0 or obs_dist > wp_dist.y:
return False
pass_alt = plane.loc + turn_dist.z + obs_dist.y / float(wp_dist.y) \
* wp_dist.z
radius = self.get_avoid_radius(pass_alt)
return radius > obs_dist.x
def __init__(self, center=[], tag=""):
self.samples = [] # 本群分类进来的样本点
self.center = center # 群心
self.old_center = [] # 旧的群心
self.distance = Distance()
self.distance_method = Method.Eculidean
self.tag = tag
def step(self, episode, action, index):
if action == 0: #non-split
#state transfer
self.presim = self.DIS.DTW(
self.cand_train_data[episode][self.split_point:(index + 1)],
self.query_train_data[episode])
self.sufsim = self.DIS_R.DTW(
self.cand_train_data[episode][(index + 1):][::-1],
self.query_train_data[episode][::-1])
if (index + 1) == self.length:
self.sufsim = self.presim
observation = np.array([self.subsim, self.presim,
self.sufsim]).reshape(1, -1)
last_subsim = self.subsim
if self.presim < self.subsim:
self.subsim = self.presim
self.subtraj = [self.split_point, index]
if self.sufsim < self.subsim:
self.subsim = self.sufsim
self.subtraj = [index + 1, self.length - 1]
self.RW = last_subsim - self.subsim
#print('action0', self.RW)
return observation, self.RW
if action == 1: #split
self.split_point = index
self.DIS = Distance(
len(self.cand_train_data[episode][self.split_point:]),
len(self.query_train_data[episode]))
#state transfer
self.presim = self.DIS.DTW(
self.cand_train_data[episode][self.split_point:(index + 1)],
self.query_train_data[episode])
self.sufsim = self.DIS_R.DTW(
self.cand_train_data[episode][(index + 1):][::-1],
self.query_train_data[episode][::-1])
if (index + 1) == self.length:
self.sufsim = self.presim
observation = np.array([self.subsim, self.presim,
self.sufsim]).reshape(1, -1)
last_subsim = self.subsim
if self.presim < self.subsim:
self.subsim = self.presim
self.subtraj = [self.split_point, index]
if self.sufsim < self.subsim:
self.subsim = self.sufsim
self.subtraj = [index + 1, self.length - 1]
self.RW = last_subsim - self.subsim
#print('action1', self.RW)
return observation, self.RW
class Group:
def __init__(self, center=[], tag=""):
self.samples = [] # 本群分类进来的样本点
self.center = center # 群心
self.old_center = [] # 旧的群心
self.distance = Distance()
self.distance_method = Method.Eculidean
self.tag = tag
def add_sample(self, sample):
if not sample:
return
self.samples.append(sample)
# 更新群心
def update_center(self):
# e.g.
# samples = [x1, x2, x3]
# x1 = [2, 2, 3, 3]
# x2 = [4, 5, 6, 7]
# x3 = [7, 8, 9, 1]
#
# summed_vectors = [(2+4+7), (2+5+8), (3+6+9), (3+7+1)]
# = [13, 15, 18, 11]
#
# new_center = [13, 15, 18, 11] / len(samples)
# = [13, 15, 18, 11] / 3
# = [4.33333333, 5.0, 6.0, 3.66666667]
# 把所有所属的样本点做矩阵相加 （相同维度位置彼此相加), summed_vectors 会是 numpy.ndarray 型态
summedd_vectors = np.sum(self.samples, axis=0)
# 再把加总起来的矩阵值除以所有样本数，取得平均后的新群心的特征属性， new_center 也是 numpy.ndarray型态
new_center = summedd_vectors / float(len(self.samples))
# 更新新旧 Center 的记录 （要把 new_center 转回去 python 的List)
self.old_center = self.center
self.center = new_center.tolist()
# 清空记录的样本点
def clear(self):
# Romoving reference in this example is enough.
del self.samples[:]
# 计算本群里所有样本点对群心的距离总和，即为本群的 SSE 值
def sse(self):
if not self.samples:
return 0.0
sum = 0.0
for point in self.samples:
sum += self.distance.calculate(point, self.center,
self.distance_method)
return sum
# 新旧群心的变化距离
def diff_distance(self):
if not self.old_center:
return 0.0
return self.distance.calculate(self.center, self.old_center,
self.distance_method)
def test_args_valueerror(self):
with self.assertRaises(ValueError):
Distance("cosine")
inputs = [[1, "2", 3], [True, [], 3.], [9.3, 1., set()], {"e": "1"}]
for inp in inputs:
with self.subTest(text=inp), self.assertRaises(ValueError):
Distance("manhattan", (inp))
def __init__(self):
self.samples = [] # 训练样本集： [features array of each sample]
self.distance_method = Method.Eculidean # 要用什么距离算法
self.distance = Distance() # 距离算法
self.groups = [] # 每一个分类好的群聚 [Group]
self.convergence = 0.001 # 收敛误差
self.max_iteration = 100 # 最大迭代次数
self.m = 2 # 计算归属度的参数 （m 是模糊器， 用来决定每一个群聚的模糊程度，m 太小则算法效果会接近硬聚类，太大则效果差）
self.iteration_callback = None
self.completion_callback = None
def __init__(self, center=[], tag=""):
self.samples = [] # 本群分类进来的样本点 (跟 all_memberships 没有索引位置上的对应关系)
self.all_memberships = [] # 所有样本点对本群心的归属度
# FCM 是整体样本在做估计和运算（含更新群心、SSE)，不像 K-Means 是个体群在做运算和更新群心
self.center = center # 群心
self.old_center = [] # 旧的群心
self.distance = Distance()
self.distance_method = Method.Eculidean
self.tag = tag
self.sse = 0.0 # 本群 SSE （由外部提供， 這里做記錄）
def __calculateDistance__(src: str, dst: str, distanceStr: str,
distanceUpto: int) -> int:
if distanceUpto == -1:
return distanceUpto, Distance(src, dst, distanceUpto)
else:
distance = -1
if distanceStr.isnumeric():
distance = int(distanceStr, base=10)
return distance, Distance(src, dst, distance - distanceUpto)
else:
return distance, Distance(src, dst, distance)
def __init__(self):
self.samples = []
self.distance_method = Method.Eculidean
self.distance = Distance()
self.center_choice = Choice.Shuffing
self.center_maker = Maker()
self.groups = []
self.convergence = 0.001
self.max_iteration = 100
self.iteration_callback = None
self.completion_callback = None
def test_concatenation_error(self):
euc_dist = Distance("euclidean", 1, 2)
cos_dist = Distance("cosine", 3, 4)
with self.assertRaises(TypeError):
euc_dist.concatenate(cos_dist)
with self.assertRaises(TypeError):
cos_dist.concatenate(euc_dist)
def search_free_road(self, last_distance=None):
text = 'Looking for free road...'
print text
distance = Distance()
cm = distance.detect()
print int(cm)
if last_distance is not None:
if self.detect_no_movement(int(cm), last_distance):
self.skip_obstacle()
if int(cm) <= self.OBSTACLE_DISTANCE:
self.skip_obstacle()
self.search_free_road(last_distance)
else:
print "Run!"
PyMove().run_up_start()
def output(self, index, episode, label='E'):
#print('check', self.subsim, self.subtraj)
if label == 'T':
#print('check', self.subsim, self.subtraj, self.subsim_real)
return [self.subsim_real, self.subtraj]
if label == 'E':
self.DIS = Distance(
len(self.cand_train_data[episode]
[self.subtraj[0]:self.subtraj[1] + 1]),
len(self.query_train_data[episode]))
self.subsim_real = self.DIS.FRECHET(
self.cand_train_data[episode][self.subtraj[0]:self.subtraj[1] +
1],
self.query_train_data[episode])
return [self.subsim_real, self.subtraj]
class Route:
trajeto = []
total = 0
def __init__(self,trajeto):
self.distance = Distance()
self.trajeto = trajeto
def __eq__(self,obj):
return self.total == obj.total
def __lt__(self,obj):
return self.total < obj.total
def __gt__(self,obj):
return self.total > obj.total
def __ge__(self,obj):
return self.total >= obj.total
def __le__(self,obj):
return self.total <= obj.total
def totalDistance(self):
self.total = self.distance.totalDistance()
def numTrajetos(self):
return len(self.trajeto)
def bestRoute(self,obj):
return self.total <= obj.total32
def ExactS(traj_c, traj_q):
subsim = 999999
subtraj = [0, len(traj_c) - 1]
subset = {}
N = len(traj_c)
for i in range(N):
DIS = Distance(len(traj_c[i:]), len(traj_q))
for j in range(i, N):
temp = DIS.DTW(traj_c[i:j + 1], traj_q)
#temp = similaritymeasures.dtw(traj_c[i:j+1], traj_q)[0]
#print('sub-range:', [i, j], temp)
subset[(i, j)] = temp
if temp < subsim:
subsim = temp
subtraj = [i, j]
return subsim, subtraj, subset
def findCloseNodes(self, key, count=None, sender_node_id=None):
""" Finds a number of known nodes closest to the node/value with the
specified key.
@param key: the n-bit key (i.e. the node or value ID) to search for
@type key: str
@param count: the amount of contacts to return, default of k (8)
@type count: int
@param sender_node_id: Used during RPC, this is be the sender's Node ID
Whatever ID is passed in the paramater will get
excluded from the list of returned contacts.
@type sender_node_id: str
@return: A list of node contacts (C{kademlia.contact.Contact instances})
closest to the specified key.
This method will return C{k} (or C{count}, if specified)
contacts if at all possible; it will only return fewer if the
node is returning all of the contacts that it knows of.
@rtype: list
"""
exclude = [self._parentNodeID]
if sender_node_id:
exclude.append(sender_node_id)
if key in exclude:
exclude.remove(key)
count = count or constants.k
distance = Distance(key)
contacts = self.get_contacts()
contacts = [c for c in contacts if c.id not in exclude]
contacts.sort(key=lambda c: distance(c.id))
return contacts[:min(count, len(contacts))]
def knn_visual(k, locationid, model, database, this_vector=None):
nearest = {}
if not this_vector:
this_vector = Vectorizer.visual_vector(locationid, database, model)
others = database.get_location_ids()
others.remove(locationid)
# Get distance to each other vecctor and add to nearest if it is less than the
# distance to an existing vector.
for other in others:
other_vector = Vectorizer.visual_vector(other, database, model)
distance = Distance.l_p_distance(3,
this_vector,
other_vector,
positional=True)
if len(nearest) < k:
largest_key, largest_best = None, inf
else:
largest_key, largest_best = max(nearest.items(),
key=itemgetter(1))
if distance < largest_best:
if largest_key:
nearest.pop(largest_key)
nearest[other] = distance
return nearest
def knn_visual_all(k, locationid, models, database, this_vector=None):
nearest = {}
others = database.get_location_ids()
others.remove(locationid)
# Calculate this_vector
if not this_vector:
this_vector = Vectorizer.visual_vector_multimodel(
locationid, database, models)
# Make a vector where each item is an average for that model
for other in others:
other_vector = Vectorizer.visual_vector_multimodel(
locationid, database, models)
# get distance between vectors
distance = Distance.l_p_distance(3, this_vector, other_vector)
if len(nearest) < k:
largest_key, largest_best = None, inf
else:
largest_key, largest_best = max(nearest.items(),
key=itemgetter(1))
if distance < largest_best:
if largest_key:
nearest.pop(largest_key)
nearest[other] = distance
return nearest
def clustering(self, K, N=100):
classes = {}
# generate K initial points
pts = []
for i in range(K):
classes[i] = []
pt = []
for j in range(len(self.data[0][0])):
pt.append(random.random()) # normallized data
pts.append(pt)
#
for n in range(N):
for i in range(K):
classes[i] = []
for i in range(len(self.data)):
temp = 9999
flag = 0
for j in range(K):
dist = Distance.euclideanDist(self.data[i][0], pts[j])
if dist < temp:
temp = dist
flag = j
classes[flag].append(i)
#
for i in range(K):
means = [0]*len(self.data[0][0])
for j in range(len(classes[i])):
for k in range(len(self.data[0][0])):
means[k] = means[k]+self.data[j][0][k]
for k in range(len(self.data[0][0])):
means[k] = means[k]/len(self.data[0][0])
pts[i] = means
return classes
def distance(location1, location2):
"""
Using the Great Circle distance by using the Harversine formula.
>>> import geocoder
>>> d = geocoder.distance('Ottawa', 'Toronto')
>>> d.km
351.902264779
>>> d.miles
218.672067333
...
Different ways to use the Distance calculator, you can input the locations
by using a tuple (lat, lng) or a dictionary with lat/lng keys.
>>> import geocoder
>>> ottawa = (45.4215296, -75.69719309999999)
>>> toronto = {'lat':43.653226, 'lng':-79.3831843}
>>> d = geocoder.distance(ottawa, toronto)
>>> d.meters
351902
...
Wiki Docs
---------
http://en.wikipedia.org/wiki/Haversine_formula
"""
return Distance(location1, location2)
def test_distance_with_valid(self):
obj = Distance('euc')
expected = 'euclidean'
actual = obj.func.__name__
self.assertEqual(expected, actual)
def biomass_worker(driver, biomass, out_name, distance='hav'):
"""Worker function for parallel execution.
Computes the biomass emissions (AGB and BGB) by using ``biomass_emissions`` function.
Further, the pixel resolution in square meter is computed and delegated to ``biomass_emissions``.
Result is stored on disk as raster image by using the metadata profile of the first argument.
Args:
driver (str or Path): Path to Proximate Deforestation Driver tile.
biomass (str or Path): Path to Above-ground Woody Biomass Density stratum.
out_name (str or Path): Path plus name of out file.
distance (str, optional): Default is Haversine equation.
"""
with open(driver, 'r') as h1, open(biomass, 'r') as h2:
driver_data = h1.read(1)
biomass_data = h2.read(1)
profile = h1.profile
transform = h1.transform
haversine = Distance(distance)
x = haversine((transform.xoff, transform.yoff),
(transform.xoff + transform.a, transform.yoff))
y = haversine((transform.xoff, transform.yoff),
(transform.xoff, transform.yoff + transform.e))
area = round(x * y)
emissions = biomass_emissions(driver_data, biomass_data, area=area)
# write updates the dtype corresponding to the array dtype
write(emissions, out_name, **profile)
def get_distances(self, vectors, image_dict):
results = {}
result = []
for i in vectors:
print("Working on hash" + str(i))
dist = {}
projection = []
for image in image_dict:
a = np.array(vectors[i], dtype=np.float)
b = a[1]
a = a[0]
p = np.array(image_dict[image], dtype=np.float)
ap = p - a
ab = b - a
# distance = np.array(np.around((ab * ap) / Distance.E2_distance(a, b), decimals=4))
projection.append(
np.array(
np.around((a + np.dot(ab, ap) / np.dot(ab, ab) * ab),
decimals=3)))
# projection.append(np.array(np.around()))
min_proj = np.amin(projection, axis=0)
image_keys = list(image_dict.keys())
j = 0
# print(min_proj)
for x in projection:
distance = Distance.E2_distance(min_proj, x)
ind = image_keys[j]
dist[ind] = distance
j = j + 1
result.append(dist)
results['h' + str(i)] = result
result = []
# print(results)
return results
def test_distance_with_args(self):
obj = Distance('euc')
expected = (float, int)
actual = obj((4, 5), (1, 1))
self.assertTrue(isinstance(actual, expected))
def parse_population_generator(self) -> Population_Generator:
"""Parse the population generator object from the Population_Generator.json file.
Returns:
Population_Generator: The population generator object containing the population information.
"""
self.json_name = 'Population_Generator'
self.build_path()
# load json file
with open(self.path, 'r') as f:
self.json_dict = json.load(f)
# retrieve main attributes dictionaries
population_size = self.json_dict['population_size']
family_patterns = self.parse_family_patterns(
self.json_dict['family_patterns'])
community_types = self.parse_community_types(
self.json_dict['community_types'])
distance_function = Distance.map_str_to_function(
self.json_dict['distance_function'])
# build the object
population_generator = Population_Generator(population_size,
family_patterns,
community_types,
distance_function)
return population_generator
def enter():
game_framework.reset_time()
global map, player, house, background, avalanche, coin, snows, map_on_coins, game_over, santa, game_clear, distance, stones
map = Map()
player = Player()
house = House()
background = Background()
avalanche = Avalanche()
coin = Coin()
game_over = Game_over()
santa = Santa()
game_clear = Game_clear()
distance = Distance()
map_on_coins = [Map_on_Coin() for i in range(200)]
snows = [Snow() for i in range(20)]
stones = [Stone() for i in range(10)]
Player.x = 300.0
Player.y = 300.0
Player.unreal_x = 300.0
Player.unreal_y = 0
Player.jump_before_y = 0
Map.map_move_y_minor = 0
Avalanche.game_over = 0
Game_clear.game_clear = 0
Santa.game_clear = 0
class Group:
def __init__(self, center=[], tag=""):
self.samples = [] # 本群分类进来的样本点 (跟 all_memberships 没有索引位置上的对应关系)
self.all_memberships = [] # 所有样本点对本群心的归属度
# FCM 是整体样本在做估计和运算（含更新群心、SSE)，不像 K-Means 是个体群在做运算和更新群心
self.center = center # 群心
self.old_center = [] # 旧的群心
self.distance = Distance()
self.distance_method = Method.Eculidean
self.tag = tag
self.sse = 0.0 # 本群 SSE （由外部提供， 這里做記錄）
def add_sample(self, sample):
if not sample:
return
self.samples.append(sample)
def add_membership(self, membership=1.0):
self.all_memberships.append(membership)
# 要用全部的样本点（all_samples)来更新群心
# all_samples 会对应 self.all_memberships的索引位置
def update_center(self, all_samples=[], m=2):
# 把所有的样本点先各自乘上自己对本群心的归属度 m 次方后，再做矩阵相加（相同维度位置彼此相加）。
# membership_samples 和 summed_vectors 都会是 numpy.ndarray 型态
length = len(all_samples[0])
summed_vectors = np.zeros(length) # 先建一个跟样本点特征长度等长的零值阵列
for index, point in enumerate(all_samples):
# 取出该样本点对本群的归属度
membership = self.all_memberships[index]
# 归属度 m 次方
m_membership = membership**m
membership_point = np.multiply(point, m_membership)
# 加总
summed_vectors = np.add(membership_point, summed_vectors)
# 再把加总起来的 summed_vectors 矩阵值除以 "所有样本点对本群心的归属度 m 次方总和"，
# new_center 也是 numpy.ndarray 形态
summed_membership = 0.0
for membership in self.all_memberships:
summed_membership += (membership**m)
new_center = summed_vectors / summed_membership
# 更新新旧 Center 的记录（要把 new_center 从 numpy 物件转回去 python 的 List)
self.old_center = self.center
self.center = new_center.tolist()
# 清空记录的样本点
def clear(self):
del self.samples[:]
del self.all_memberships[:]
self.sse = 0.0
# 新旧群心的变化距离
def diff_distance(self):
if not self.old_center:
return 0.0
return self.distance.calculate(self.center, self.old_center,
self.distance_method)
def predict(self, sample, k):
candidats = [{9999: 0}] * k
ids = [0] * k
for i in range(len(self.tdata)):
dist = Distance.euclideanDist(sample, self.tdata[i][0])
if dist < candidats[-1].keys()[0]:
candidats.sort()
candidats.pop()
candidats.insert(0, {dist: i})
# most is the winner
counter = {}
for c in candidats:
counter[self.tdata[c.values()[0]][1]] = 0
for c in candidats:
counter[self.tdata[c.values()[0]][1]] = counter[self.tdata[c.values()[0]][1]] + 1
print counter
openevent.wait(10)
if openevent.is_set():
closedevent.wait()
# let em clear out
light.turnon()
eyes.turnoff()
threading.Timer(5, lambda: scaring.clear()).start()
door = Door(args=(open_callback, close_callback, closedevent), kwargs={'gpio_door': 11})
dist = Distance(args=(distance_callback, 190),
kwargs={'gpio_trigger': 16,
'gpio_echo': 18})
def stopthreads():
light.fullon()
spk.stop()
dist.stop()
light.stop()
eyes.stop()
door.stop()
eyes.join(1)
door.join(1)
spk.join(1)
dist.join(1)
light.join(1)
