def __init__(self, window):
if have_numpy:
self.window = numpy.array(window)
else:
self.window = list(window)
self.buffer = Ringbuffer(len(window))
class WindowedAverage:
def __init__(self, window):
if have_numpy:
self.window = numpy.array(window)
else:
self.window = list(window)
self.buffer = Ringbuffer(len(window))
def new_sample(self, x):
self.buffer.new_sample(x)
if have_numpy:
avg = numpy.mean(self.buffer.get_samples() * self.window)
else:
i = 0
sum = 0
for s in self.buffer.get_samples():
sum += self.window[i]*s
i = i + 1
avg = sum/len(self.window)
return avg
class Erosion:
def __init__(self, window):
self.window = window
self.buffer = Ringbuffer(window)
def new_sample(self, x):
self.buffer.new_sample(x)
return min(self.buffer.get_samples())
class MovingAverage:
def __init__(self, window_len):
self.window_len = window_len
self.buffer = Ringbuffer(window_len)
def new_sample(self, x):
self.buffer.new_sample(x)
return self.buffer.get_sum() / float(self.window_len)
def __init__(self, taps):
self.taps = taps
max_t = 0
for time, scale in taps:
if time > max_t:
max_t = time
self.buffer = Ringbuffer(max_t)
class Erosion:
def __init__(self, window):
self.window = window
self.buffer = Ringbuffer(window)
def new_sample(self, x):
self.buffer.new_sample(x)
return min(self.buffer.get_samples())
class RandomDelay:
def __init__(self, window):
self.window = window
self.buffer = Ringbuffer(window)
def new_sample(self, x):
self.buffer.new_sample(x)
s = self.buffer.get_samples
return random.choice(s)
class EnergyBuffer:
def __init__(self, len):
self.buffer = Ringbuffer(len)
self.differentiator = Differentiator()
def new_sample(self, x):
d = self.differentiator.new_sample(x)
self.buffer.new_sample(x*x)
return math.sqrt(self.buffer.get_mean())
class EnergyBuffer:
def __init__(self, len):
self.buffer = Ringbuffer(len)
self.differentiator = Differentiator()
def new_sample(self, x):
d = self.differentiator.new_sample(x)
self.buffer.new_sample(x * x)
return math.sqrt(self.buffer.get_mean())
class RandomDelay:
def __init__(self, window):
self.window = window
self.buffer = Ringbuffer(window)
def new_sample(self, x):
self.buffer.new_sample(x)
s = self.buffer.get_samples
return random.choice(s)
class MovingAverage:
def __init__(self, window_len):
self.window_len = window_len
self.buffer = Ringbuffer(window_len)
def new_sample(self, x):
self.buffer.new_sample(x)
return self.buffer.get_sum()/float(self.window_len)
class PLL:
#phase locked loop
def __init__(self, bp_filter, lp_filter, centre_freq, sr, loop_gain=1.0, in_gain=1.0):
self.sr = sr
self.base_rate = (centre_freq*2*math.pi) / sr
self.int = 0
self.bp_filter = bp_filter
self.lp_filter = lp_filter
self.phase_buffer = Ringbuffer(int(sr/centre_freq))
self.loop_gain = loop_gain
self.in_gain = in_gain
def set_gain(self, gain):
self.gain = gain
def set_base_freq(self, freq):
self.base_rate = (freq*2*math.pi) / self.sr
def get_sync(self):
return abs(self.phase_buffer.get_sum())
def new_sample(self, x):
(osc,int,y) = self.run(x)
return int
def run(self, x):
#band pass the input
y = self.bp_filter.new_sample(x*self.in_gain)
# drive the oscillator at natural frequency
self.int = self.int + self.base_rate
osc = math.sin(self.int)
#compute phase difference
phase_com = osc * y
#store phase comparison
self.phase_buffer.new_sample(phase_com)
# filter the phase comparator
ph_adj = self.lp_filter.new_sample(phase_com)
# shift the integrator
self.int = self.int + ph_adj * self.loop_gain
#return value of oscillator, the phase value (unwrapped), and the bp filtered input signal
return (osc, self.int, y)
def __init__(self, B, A):
"""Create an IIR filter, given the B and A coefficient vectors"""
self.B = B
self.A = A
if len(A)>2:
self.prev_outputs = Ringbuffer(len(A)-1)
else:
self.prev_outputs = Ringbuffer(3)
self.prev_inputs = Ringbuffer(len(B))
class PLL:
#phase locked loop
def __init__(self,
bp_filter,
lp_filter,
centre_freq,
sr,
loop_gain=1.0,
in_gain=1.0):
self.sr = sr
self.base_rate = (centre_freq * 2 * math.pi) / sr
self.int = 0
self.bp_filter = bp_filter
self.lp_filter = lp_filter
self.phase_buffer = Ringbuffer(int(sr / centre_freq))
self.loop_gain = loop_gain
self.in_gain = in_gain
def set_gain(self, gain):
self.gain = gain
def set_base_freq(self, freq):
self.base_rate = (freq * 2 * math.pi) / self.sr
def get_sync(self):
return abs(self.phase_buffer.get_sum())
def new_sample(self, x):
(osc, int, y) = self.run(x)
return int
def run(self, x):
#band pass the input
y = self.bp_filter.new_sample(x * self.in_gain)
# drive the oscillator at natural frequency
self.int = self.int + self.base_rate
osc = math.sin(self.int)
#compute phase difference
phase_com = osc * y
#store phase comparison
self.phase_buffer.new_sample(phase_com)
# filter the phase comparator
ph_adj = self.lp_filter.new_sample(phase_com)
# shift the integrator
self.int = self.int + ph_adj * self.loop_gain
#return value of oscillator, the phase value (unwrapped), and the bp filtered input signal
return (osc, self.int, y)
class WindowedReduceFilter:
def __init__(self, binop, window):
self.state = None
self.window = window
self.buffer = Ringbuffer(window)
self.binop = binop
def new_sample(self, x):
self.buffer.new_sample(x)
samples = self.buffer.get_samples()
state = reduce(self.binop, samples)
return state
class WindowedReduceFilter:
def __init__(self, binop, window):
self.state = None
self.window = window
self.buffer = Ringbuffer(window)
self.binop = binop
def new_sample(self, x):
self.buffer.new_sample(x)
samples = self.buffer.get_samples()
state = reduce(self.binop, samples)
return state
def __init__(self,
bp_filter,
lp_filter,
centre_freq,
sr,
loop_gain=1.0,
in_gain=1.0):
self.sr = sr
self.base_rate = (centre_freq * 2 * math.pi) / sr
self.int = 0
self.bp_filter = bp_filter
self.lp_filter = lp_filter
self.phase_buffer = Ringbuffer(int(sr / centre_freq))
self.loop_gain = loop_gain
self.in_gain = in_gain
class Delay:
def __init__(self, delay):
self.delay = delay
self.buffer = Ringbuffer(delay)
def new_sample(self, x):
return self.buffer.new_sample(x)
class Median:
def __init__(self, window):
self.window = window
self.buffer = Ringbuffer(window)
def new_sample(self, x):
self.buffer.new_sample(x)
b = list(self.buffer.get_samples())
b.sort()
lb = len(b)
# even case
if lb % 2 == 0:
return b[len(b) / 2] + b[len(b) / 2 + 1]
else:
# odd case
return b[len(b + 1) / 2]
class Delay:
def __init__(self, delay):
self.delay = delay
self.buffer = Ringbuffer(delay)
def new_sample(self, x):
return self.buffer.new_sample(x)
class Median:
def __init__(self, window):
self.window = window
self.buffer = Ringbuffer(window)
def new_sample(self, x):
self.buffer.new_sample(x)
b = list(self.buffer.get_samples())
b.sort()
lb = len(b)
# even case
if lb%2==0:
return b[len(b)/2]+b[len(b)/2+1]
else:
# odd case
return b[len(b+1)/2]
def __init__(self, window):
if have_numpy:
self.window = numpy.array(window)
else:
self.window = list(window)
self.buffer = Ringbuffer(len(window))
def __init__(self, taps):
self.taps = taps
max_t = 0
for time,scale in taps:
if time>max_t:
max_t = time
self.buffer = Ringbuffer(max_t)
def __init__(self, bp_filter, lp_filter, centre_freq, sr, loop_gain=1.0, in_gain=1.0):
self.sr = sr
self.base_rate = (centre_freq*2*math.pi) / sr
self.int = 0
self.bp_filter = bp_filter
self.lp_filter = lp_filter
self.phase_buffer = Ringbuffer(int(sr/centre_freq))
self.loop_gain = loop_gain
self.in_gain = in_gain
class Filter:
def __init__(self, B, A):
"""Create an IIR filter, given the B and A coefficient vectors"""
self.B = B
self.A = A
if len(A) > 2:
self.prev_outputs = Ringbuffer(len(A) - 1)
else:
self.prev_outputs = Ringbuffer(3)
self.prev_inputs = Ringbuffer(len(B))
def filter(self, x):
#take one sample, and filter it. Return the output
y = 0
self.prev_inputs.new_sample(x)
k = 0
for b in self.B:
y = y + b * self.prev_inputs.reverse_index(k)
k = k + 1
k = 0
for a in self.A[1:]:
y = y - a * self.prev_outputs.reverse_index(k)
k = k + 1
y = y / self.A[0]
self.prev_outputs.new_sample(y)
return y
def new_sample(self, x):
return self.filter(x)
class Filter:
def __init__(self, B, A):
"""Create an IIR filter, given the B and A coefficient vectors"""
self.B = B
self.A = A
if len(A)>2:
self.prev_outputs = Ringbuffer(len(A)-1)
else:
self.prev_outputs = Ringbuffer(3)
self.prev_inputs = Ringbuffer(len(B))
def filter(self, x):
#take one sample, and filter it. Return the output
y = 0
self.prev_inputs.new_sample(x)
k =0
for b in self.B:
y = y + b * self.prev_inputs.reverse_index(k)
k = k + 1
k = 0
for a in self.A[1:]:
y = y - a * self.prev_outputs.reverse_index(k)
k = k + 1
y = y / self.A[0]
self.prev_outputs.new_sample(y)
return y
def new_sample(self,x):
return self.filter(x)
class WindowedAverage:
def __init__(self, window):
if have_numpy:
self.window = numpy.array(window)
else:
self.window = list(window)
self.buffer = Ringbuffer(len(window))
def new_sample(self, x):
self.buffer.new_sample(x)
if have_numpy:
avg = numpy.mean(self.buffer.get_samples() * self.window)
else:
i = 0
sum = 0
for s in self.buffer.get_samples():
sum += self.window[i] * s
i = i + 1
avg = sum / len(self.window)
return avg
class SparseMultiTapDelay:
def __init__(self, taps):
self.taps = taps
max_t = 0
for time, scale in taps:
if time > max_t:
max_t = time
self.buffer = Ringbuffer(max_t)
def new_sample(self, x):
result = 0
for time, scale in self.taps:
result = result + self.buffer.reverse_index(time) * scale
return result
class SparseMultiTapDelay:
def __init__(self, taps):
self.taps = taps
max_t = 0
for time,scale in taps:
if time>max_t:
max_t = time
self.buffer = Ringbuffer(max_t)
def new_sample(self, x):
result = 0
for time, scale in self.taps:
result = result + self.buffer.reverse_index(time) * scale
return result
def __init__(self, B, A):
"""Create an IIR filter, given the B and A coefficient vectors"""
self.B = B
self.A = A
if len(A) > 2:
self.prev_outputs = Ringbuffer(len(A) - 1)
else:
self.prev_outputs = Ringbuffer(3)
self.prev_inputs = Ringbuffer(len(B))
def __init__(self, len):
self.buffer = Ringbuffer(len)
self.differentiator = Differentiator()
def __init__(self, delay):
self.delay = delay
self.buffer = Ringbuffer(delay)
def __init__(self, binop, window):
self.state = None
self.window = window
self.buffer = Ringbuffer(window)
self.binop = binop
def __init__(self, window):
self.window = window
self.buffer = Ringbuffer(window)
def __init__(self, delay):
self.delay = delay
self.buffer = Ringbuffer(delay)
def __init__(self, window):
self.window = window
self.buffer = Ringbuffer(window)
def __init__(self, window_len):
self.window_len = window_len
self.buffer = Ringbuffer(window_len)
def load_reID(self):
logging.basicConfig(filename='feature_extractor_wrapper.log',
level=logging.DEBUG)
self.feature_extractor = feature_extraction('0', self.model, '1',
self.batch_size)
self.ringbuffer = Ringbuffer(200, 10000)
def __init__(self, binop, window):
self.state = None
self.window = window
self.buffer = Ringbuffer(window)
self.binop = binop
def __init__(self, window_len):
self.window_len = window_len
self.buffer = Ringbuffer(window_len)
def main():
'''
detect and print the detected goals
'''
buf = Ringbuffer(4 * FPS)
replay_it = None
gd = GoalDetector()
classifier = Classifier('trainingdata')
videopath = './match2.h264'
camera = cv2.VideoCapture(videopath)
print(np.shape(camera))
cv2.namedWindow("window", cv2.WND_PROP_FULLSCREEN)
cv2.setWindowProperty(
"window",
cv2.WND_PROP_FULLSCREEN,
cv2.WINDOW_FULLSCREEN)
(grabbed, frame) = camera.read()
for i in range(100): # TODO delete
camera.read()
# TODO make read() wait for a frame to be ready
t0 = time.time()
while grabbed:
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
t1 = time.time()
if replay_it:
try:
cv2.imshow('window', next(replay_it))
except StopIteration:
replay_it = None
else:
obs, _ = gd.step(hsv)
t2 = time.time()
# resized = cv2.resize(hsv, (960, 540))
cv2.imshow('window', hsv)
t3 = time.time()
for i, obstacles in enumerate(obs):
for obstacle in obstacles:
# if classifier.predict(obstacle, hsv, gd.goal_rects[i]):
if False:
replay_it = iter(buf)
break
if replay_it:
break
t4 = time.time()
cv2.waitKey(1) # need to wait for event loop and displaying...
t5 = time.time()
(grabbed, frame) = camera.read()
t6 = time.time()
# TODO speed up JPEG saving
if not replay_it:
buf.store_next_frame((frame))
t7 = time.time()
# print('{} grabbing, {} hsvconv, {} compute, {} displaying'
# .format(t4 - t3, t1 - t0, t2 - t1, t3 - t2))
t = (t0, t1, t2, t3, t4, t5, t6, t7)
print([t[i] - t[i-1] for i in range(1, len(t))])
t0 = time.time()
cv2.destroyAllWindows()
def __init__(self, len):
self.buffer = Ringbuffer(len)
self.differentiator = Differentiator()
class feature_extractor_wrapper:
def __init__(self, model, batch_size):
self.last_image_shown = time.time() - 1000
self.model = model
self.batch_size = batch_size
self.threading_queue = []
self.speaking_queue = collections.deque(maxlen=1)
self.sayhello = sayhello.Sayhello(1, 150)
self.last_person = -1
self.last_seen_person = time.time() - 10
self.avarage_batch_time = 0
self.batches_processed = 0
image_show_thread = threading.Thread(target=self.image_viewer)
text_speak_thread = threading.Thread(target=self.text_to_speech_t)
text_speak_thread.start()
image_show_thread.start()
def get_avarage_batch_time(self):
return self.avarage_batch_time
def load_reID(self):
logging.basicConfig(filename='feature_extractor_wrapper.log',
level=logging.DEBUG)
self.feature_extractor = feature_extraction('0', self.model, '1',
self.batch_size)
self.ringbuffer = Ringbuffer(200, 10000)
#return feature_extractor, ringbuffer
def start_reID(self, img_array):
t_batch_start = time.time_ns()
t_singleimg_start = time.time_ns()
feature_array = self.feature_extractor.extract_feature_numpy(img_array)
t_singleimg_end = time.time_ns()
logging.debug("Batch feature extraction took" +
str((t_singleimg_end - t_singleimg_start) / 1000000000) +
"seconds")
#print(feature)
count = 0
for feature in feature_array:
feature = [feature]
#print(feature)
smallest_index, smallest_distance = self.ringbuffer.nearestneighbors(
feature)
#print(smallest_distance)
logging.debug("Smallest distance: " + str(smallest_distance))
#print(len(self.ringbuffer.ringbuffer))
logging.debug("Length of ringbuffer: " +
str(len(self.ringbuffer.ringbuffer)))
if self.ringbuffer.ringbuffer:
logging.debug("Length of ringbuffer[0]" +
str(len(self.ringbuffer.ringbuffer[0])))
if smallest_distance <= THRESHHOLD_RE_ID:
#print("Erkannt")
last_seen, person_id = self.ringbuffer.lastseen(smallest_index)
#self.sayhello.sayagain_async(last_seen)
self.ringbuffer.addnewfeature(smallest_index, feature)
img_old = self.ringbuffer.getimage(smallest_index)
if person_id != self.last_person:
#print("Hallo ich habe sie das letzte mal", last_seen, "gesehen")
self.last_person = person_id
self.speaking_queue.append(last_seen)
elif (time.time() - self.last_seen_person) > 5:
#print("Hallo ich habe sie das letzte mal", last_seen, "gesehen")
self.last_person = person_id
self.speaking_queue.append(last_seen)
#else:
#print(time.time() - self.last_seen_person)
#self.last_person = person_id
self.update(img_old, person_id)
self.last_seen_person = time.time()
elif smallest_distance >= THRESHHOLD_NEW_ID:
self.ringbuffer.addnewperson(feature,
np.array(img_array[count]))
#print("Herzlich Willkommen!")
self.speaking_queue.append(1)
#self.sayhello.sayhello_async()
t_batch_end = time.time_ns()
t_avarage = (t_batch_end - t_batch_start) / 1000000000
t_time_all = self.avarage_batch_time * self.batches_processed + t_avarage
self.batches_processed += 1
self.avarage_batch_time = t_time_all / self.batches_processed
print("batch took", t_avarage, "seconds")
print(
"Avarage (batch):",
self.avarage_batch_time,
)
count += 1
def update(self, image, person_id):
self.last_image_shown = time.time()
self.threading_queue.append([image, person_id], )
def image_viewer(self):
img = cv2.cvtColor(np.array(Image.open("../../testdir/initial.png")),
cv2.COLOR_RGB2BGR)
while True:
if len(self.threading_queue) > 0:
img_info = self.threading_queue.pop(0)
img = img_info[0]
if self.last_person != img_info[1]:
cv2.destroyAllWindows()
cv2.imshow("image", img)
cv2.waitKey(30)
def text_to_speech_t(self):
#last_spoken = time.time() - 5
obj = None
#time.sleep(0.1)
while True:
time.sleep(0.000000000001)
#print(len(self.speaking_queue))
#print((time.time() - last_spoken))
if len(self.speaking_queue) > 0:
obj = self.speaking_queue.pop()
#self.last_person = -1
if obj is not None:
if obj == 1:
self.sayhello.sayhello()
obj = None
if len(self.speaking_queue) > 0:
self.speaking_queue.pop()
#last_spoken = time.time()
else:
self.sayhello.sayagain(obj)
obj = None
if len(self.speaking_queue) > 0:
self.speaking_queue.pop()
