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 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 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
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 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, 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, 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 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()
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()