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')