def __init__(self, client_name, server_addr, buffer_size): ''' Args: - clien_name: identifier of the camera (same as the one in topo) - server_addr: ip:port in str - buffer_size: size of request_queue, and response queue ''' channel = grpc.insecure_channel(server_addr) self.stub = cas_pb2_grpc.UploaderStub(channel) self.client_name = client_name self.request_queue = Q(buffer_size) self.response_queue = Q(buffer_size) self.log('init, connect to %s' % server_addr)
def main(running): server = NetServer(name='tracker', address=const.LOCAL_ADDR, port=const.LOCAL_PORT, buffer_size=const.QUEUE_SIZE) server_proc = Process(target=server.run) server_proc.start() client = NetClient(client_name='tracker', server_addr=const.SERVER_ADDR, buffer_size=const.QUEUE_SIZE) if const.UPLOAD_DATA: client_proc = Process(target=client.run) client_proc.start() feature_queue = Q(const.QUEUE_SIZE) feature_extractor = FExtractor(in_queue=server.data_queue, out_queue=feature_queue, model_path=const.TRACK_MODEL_PATH) tm_proc = Process(target=feature_extractor.run) tm_proc.start() reid = REID(topo_path=const.TOPO_PATH, img_shape=const.IMG_SHAPE) trackers = {} data_savers = {} print('Tracker init done!') cur_time = time() while running[0]: pkt = feature_queue.read() if pkt is None: sleep(0.01) continue cid = pkt.cam_id if cid not in trackers: trackers[cid] = DeepSort(track_labels=const.TRACK_LABELS, attach_labels=const.ATTACH_LABELS) data_savers[cid] = DataWriter(file_path=RES_FOLDER + '{}.npy'.format(cid)) print('create tracker for video {}'.format(cid)) pkt = trackers[cid].update(pkt) pkt = reid.update(pkt) if const.UPLOAD_DATA: client.send_data(pkt) if const.SAVE_DATA: data_savers[cid].save_data(frame_id=pkt.frame_id, meta=pkt.meta) if const.SAVE_DATA: for cid in data_savers: data_savers[cid].save_to_file() server.stop() print('tracker finished')
def __init__(self, client_name, server_addr, buffer_size): self.client_name = client_name self.server_ip = server_addr.split(':')[0] self.server_port = int(server_addr.split(':')[1]) self.request_queue = Q(buffer_size) self.frame_cnt = 0 self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.running = True self.log('init')
def __init__(self, name, address, port, buffer_size): Thread.__init__(self) self.name = name self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.socket.bind((address, port)) self.data_queue = Q(buffer_size) self.threads = [] self.running = True self.log('Start running.')
def __init__(self, web_address, queue_size, video_names, video_wid, video_hei): ''' Args: - web_address: ipv4:port - queue_size: size of img queue for each display - video_names: a full list of video names (client names) - video_wid, video_hei: size you want to display image Return: NA ''' self.web_address = web_address code_generator = Generator(video_names, (video_wid, video_hei)) code_generator.run() self.new_act_queue = Q(2) # new actions from webpage self.display_queues = {} # image queues for v in video_names: self.display_queues[v] = Q(queue_size) self.log('init, video names %s' % str(video_names))
def __init__(self, name, address, port, buffer_size): ''' Args: - name: the name of local machine - port: int port number - buffer_size: size of input data queue ''' self.data_queue = Q(buffer_size) self.control_queues = {} self.name = name self.server = grpc.server(futures.ThreadPoolExecutor(max_workers=10)) cas_pb2_grpc.add_UploaderServicer_to_server( Uploader(data_queue=self.data_queue, control_queues=self.control_queues, buffer_size=buffer_size), self.server) self.server.add_insecure_port('[::]:%d' % port) self.server.start() self.log('init')
def Upload(self, request, context): ''' Args: - request: the data from the client ''' pkt = DataPkt() pkt.load_from_string(request.data) cam_id = pkt.cam_id if cam_id not in self.control_queues: print('receive data from %s' % cam_id) self.control_queues[cam_id] = Q(self.buffer_size) self.data_queue.write(pkt) if self.data_queue.full(): print('rpc server queue full!') msg = str(pkt.frame_id) if not self.control_queues[cam_id].empty(): msg = self.control_queues[cam_id].read() return cas_pb2.UploadReply(message=msg)
def main(running): server = NetServer( name='act', address=const.LOCAL_ADDR, port=const.LOCAL_PORT, buffer_size=const.QUEUE_SIZE, ) server_proc = Process(target=server.run) server_proc.start() client = NetClient( client_name='act', server_addr=const.SERVER_ADDR, buffer_size=const.QUEUE_SIZE, ) if const.UPLOAD_DATA: client_proc = Process(target=client.run) client_proc.start() data_savers = {} tube_queue = Q(const.QUEUE_SIZE) act_spatial_queue = Q(const.QUEUE_SIZE) act_nn_queue = Q(const.QUEUE_SIZE) act_comp_queue = Q(const.QUEUE_SIZE) filter_queue = Q(const.QUEUE_SIZE) tm = ServerPktManager( in_queue=server.data_queue, out_queue=tube_queue, track_list=const.TRACK_LABELS, overlap_list=const.ATTACH_LABELS, ) tm_proc = Thread(target=tm.run) tm_proc.deamon = True tm_proc.start() spatial_act = SpatialActDetector( in_queue=tube_queue, out_queue=act_spatial_queue, ) spatial_proc = Process(target=spatial_act.run) spatial_proc.deamon = True spatial_proc.start() nn_act = NNActDetector( in_queue=act_spatial_queue, out_queue=act_nn_queue, model_path=const.NN_ACT_MODEL_PATH, batch_size=const.NN_BATCH, tube_size=const.TUBE_SIZE, filter_queue=filter_queue, ) nn_act_proc = Process(target=nn_act.run) nn_act_proc.deamon = True nn_act_proc.start() comp_act = CompActDetector( in_queue=act_nn_queue, out_queue=act_comp_queue, filter_queue=filter_queue, ) comp_act_proc = Process(target=comp_act.run) comp_act_proc.deamon = True comp_act_proc.start() out_queue = act_comp_queue print('server starts') while running[0]: server_pkt = out_queue.read() if server_pkt is None: sleep(0.01) continue cid = server_pkt.cam_id if cid not in data_savers: data_savers[cid] = DataWriter(file_path=RES_FOLDER + '{}.npy'.format(cid)) print('creat data_saver for video {}'.format(cid)) logging.info("Cam-{}, Frame-{}, Acts-{}".format( server_pkt.cam_id, server_pkt.get_first_frame_id(), server_pkt.get_action_info())) logging.info("--------------------------------") data_pkts = server_pkt.to_data_pkts() for p in data_pkts: if const.UPLOAD_DATA: client.send_data(p) if const.SAVE_DATA: data_savers[cid].save_data(frame_id=p.frame_id, meta=p.meta) if const.SAVE_DATA: for cid in data_savers: data_savers[cid].save_to_file() server.stop() print("server finished!")
def main(running): server = NetServer( name='web', address=const.LOCAL_ADDR, port=const.LOCAL_PORT, buffer_size=const.QUEUE_SIZE, ) server_proc = Process(target=server.run) server_proc.start() vis = Visualizer() code_generator = Generator( names=const.CLIENT_NAMES, img_dim=const.IMG_SHAPE, ) code_generator.run() web_msg_queue = Q(2) display_queues = {v: Q(const.QUEUE_SIZE) for v in const.CLIENT_NAMES} from web.web_server import WebServer ip, port = const.WEB_ADDR.split(':') wserver = WebServer( data_queues=display_queues, msg_queue=web_msg_queue, ip=ip, port=int(port), display_fps=const.WEB_DISPLAY_FPS, ) wserver_thread = Thread(target=wserver.run) wserver_thread.setDaemon(True) wserver_thread.start() video_writers = {} if const.SAVE_VIDEO: video_writers = { v: VideoWriter( fname=RES_FOLDER + '%s.avi' % v, fps=const.VIDEO_WRITE_FPS, resolution=const.IMG_SHAPE, ) for v in const.CLIENT_NAMES } while running: d = server.read_data() if d is None: sleep(0.01) continue img = d.img vname = d.cam_id if const.SAVE_VIDEO: assert vname in video_writers, "this src not registered!" video_writers[vname].save_frame(img) for m in d.meta: if 'act_fid' in m: vis.reg_act(cam_id=vname, data=m) else: vis.draw_track(img=img, data=m, cam_id=vname, show=const.SHOW_TRACK) vis.draw_act(img=img, cam_id=vname) display_queues[vname].write(img) if const.SAVE_VIDEO: for v in video_writers: video_writers[v].close() server.stop() print('web finished')