def on_function(self, data):
# 目前该function仅用于TD201/202
# 阵列和盒子等代理使用function batch和function cam，其中function cam应该废弃变成function
logging.info("function setting: {}".format(data))
msg_id = data.pop("msg_id", "")
func_name = data.pop("func_name")
if device.is_edge_ipc():
cam = device.get_edge_ipc_cam()
elif "device_id" in data:
cam = camctl.get_one(data["device_id"])
else:
logging.info("unexpected function setting got: %s", data)
self.report_function(msg_id)
return
cam_function = cam.function
if cam_function and func_name in cam_function:
for k, v in data.items():
cam_function[func_name][k] = v
logging.info("change cam {} function: {}".format(
cam.uuid, cam_function))
camctl.update(cam.uuid, {"function": cam_function})
self.report_function(msg_id, data.pop("device_id", None))
def on_cam_setting(self, data):
"""
普通摄像头更新设置
"""
logging.info("change cam setting: {}".format(data))
msg_id = data.pop("msg_id")
cam_uuid = data.pop("cam_uuid")
camctl.update(cam_uuid, data)
self.report_cam_setting(cam_uuid=cam_uuid, msg_id=msg_id)
def do_put(self, data):
""" overwrite all function settings of a specific camera """
device_id = data.get("device_id")
new_setting = data.get("function")
try:
if not isinstance(new_setting, dict):
raise RuntimeError("invalid parameters")
camctl.update(device_id, {"function": new_setting})
cam = camctl.get_one(device_id)
except Exception as err:
logging.exception(err)
return self.failed(500, "{}".format(err))
return self.success(cam.function)
def on_function_batch(self, data):
"""
批量更新边侧摄像头某种类型的告警设置
"""
logging.info("function batch setting: {}".format(data))
msg_id = data["msg_id"]
func_name = data["func_name"]
enable = data["enable"]
aggreagate = data["aggreagate"]
device_ids = data["device_ids"]
update_server = data["update_server"]
desc = "success"
if update_server:
# 修改function表的设置
function = functl.get(func_name)
if function:
function["enable"] = enable
function["aggreagate"] = aggreagate
functl.update_all({func_name: function})
else:
desc = "func_name {} not support".format(func_name)
# 依次处理每个设备
for device_id in device_ids:
cam_info = camctl.get_one(device_id)
function = cam_info.function
one_function = function.get(func_name)
if one_function:
one_function["enable"] = enable
one_function["aggreagate"] = aggreagate
function[func_name] = one_function
camctl.update(device_id, {"function": function})
else:
if desc == "success":
desc = ""
desc += "device {} not support func_name {}".format(
device_id, func_name)
resp_data = {
"msg_id": msg_id, # 带着上面的msgId
"desc": desc # success表示成功，失败传原因
}
self.publish(Cloud.topic_pub_function_batch, resp_data)
def on_function_cam(self, data):
"""
全量更新摄像头的告警设置
"""
logging.info("function cam setting: {}".format(data))
msg_id = data["msg_id"]
function = data["function"]
device_ids = data["device_ids"]
for device_id in device_ids:
cam_function = camctl.get_one(device_id).function
for func_name in cam_function:
if func_name in function:
cam_function[func_name] = function[func_name]
logging.info("change cam {} function: {}".format(
device_id, cam_function))
camctl.update(device_id, {"function": cam_function})
self.report_function_cam(device_ids, msg_id)
def do_post(self, data):
""" modify part of function settings of a specific camera """
device_id = data.get("device_id")
func_name = data.get("func_name")
enable = data.get("enable", False)
zones = data.get("zones", [[]])
reverse = data.get("reverse", False)
threshold = data.get("threshold", 0.2)
detection_cycle = data.get(
"detection_cycle", {
"detection_starttime": 0,
"detection_endtime": 64800,
"detection_period": [0, 1, 2, 3, 4, 5, 6],
})
_, _, ts = clock.now()
detected_time = [ts] * len(zones)
try:
cam = camctl.get_one(device_id)
if func_name not in functl.get(""):
raise RuntimeError("invalid function id")
if not isinstance(zones, list):
raise RuntimeError("invalid parameters")
all_function = cam.function
function_spec = all_function.get(func_name, {})
function_spec["enable"] = enable
function_spec["zone"] = zones
function_spec["reverse"] = reverse
function_spec["threshold"] = threshold
function_spec["detection_cycle"] = detection_cycle
function_spec["detected_time"] = detected_time
all_function[func_name] = function_spec
camctl.update(device_id, {"function": all_function})
cam = camctl.get_one(device_id)
except Exception as err:
logging.exception(err)
return self.failed(500, "{}".format(err))
return self.success(cam.function)
def __call__(self, raw_results, cam):
# leave filter
cam_function = cam.function
cam_info = cam_function.get(self.func_name, {})
cam_reverse = cam_info.get("reverse", False)
aggreagate_time = functl.get(self.func_name).get("aggreagate", 300)
filter_results = []
if cam_info.get("enable", False):
logging.info("_apply_{}_filter:: filtering...".format(
self.func_name))
cam_zones = cam_info.get("zones", [])
cam_detected_times = cam.detected_times
_, _, ts = clock.now()
if cam_zones == []:
logging.info("apply_{}_filter:: zones: whole img".format(
self.func_name))
logging.info(
"last detected time is:: {}, current time is:: {}".format(
clock._get_csttz_dt(cam_detected_times[0]),
clock._get_csttz_dt(ts)))
detected_flag = False
for result in raw_results:
if result[0] == 'person_body':
detected_flag = True
if detected_flag:
cam_detected_times = [ts]
camctl.update(cam.uuid,
{"detected_times": cam_detected_times})
else:
if (ts - cam_detected_times[0]) > aggreagate_time:
return_result = ["leave", 0.666, "0", "0", "1", "1"]
filter_results.append(return_result)
else:
logging.info("_apply_{}_filter:: zones: {}".format(
self.func_name, cam_zones))
if len(cam_detected_times) != len(cam_zones):
cam_detected_times = [ts] * len(cam_zones)
for result in raw_results:
in_flag = False
in_index = -1
if result[0] == "person_body":
left_leg_x = int(result[2])
right_leg_x = int(result[4])
leg_y = int(result[5])
check_point = {
"x": int((left_leg_x + right_leg_x) / 2),
"y": leg_y
}
for i, zone in enumerate(cam_zones):
check_point_inside = _isInsidePolygon(
check_point, zone)
if check_point_inside:
in_flag = True
in_index = i
if in_flag:
cam_detected_times[in_index] = ts
camctl.update(cam.uuid, {"detected_times": cam_detected_times})
for i, zone in enumerate(cam_zones):
detected_time = cam_detected_times[i]
logging.info(
"zone {} @ last detected time is:: {}, current time is:: {}"
.format(i, clock._get_csttz_dt(detected_time),
clock._get_csttz_dt(ts)))
if (ts - detected_time) > aggreagate_time:
xmin = str(zone[0]["x"])
ymin = str(zone[0]["y"])
xmax = str(zone[2]["x"])
ymax = str(zone[2]["y"])
return_result = [
"leave", 0.666, xmin, ymin, xmax, ymax
]
filter_results.append(return_result)
"""
if cam_reverse:
if not in_flag:
filter_results.append(result)
else:
if in_flag:
filter_results.append(result)
"""
logging.info("_apply_{}_filter:: results: {}".format(
self.func_name, filter_results))
parse_results = reslove_result(filter_results, self.func_name)
return parse_results