"
]
},
- "execution_count": 6,
+ "execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
- "KEYPOINT_DATASET"
+ "KEYPOINT_DATASET[5603]"
]
},
{
"cell_type": "code",
- "execution_count": 7,
+ "execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
@@ -296,7 +324,7 @@
},
{
"cell_type": "code",
- "execution_count": 8,
+ "execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
@@ -374,7 +402,7 @@
},
{
"cell_type": "code",
- "execution_count": 9,
+ "execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
@@ -452,9 +480,31 @@
},
{
"cell_type": "code",
- "execution_count": 10,
+ "execution_count": 12,
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "E0704 11:08:11.573409 46301 pjrt_stream_executor_client.cc:3077] Execution of replica 0 failed: INTERNAL: jaxlib/gpu/solver_handle_pool.cc:37: operation gpusolverDnCreate(&handle) failed: cuSolver internal error\n"
+ ]
+ },
+ {
+ "ename": "XlaRuntimeError",
+ "evalue": "INTERNAL: jaxlib/gpu/solver_handle_pool.cc:37: operation gpusolverDnCreate(&handle) failed: cuSolver internal error",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+ "\u001b[31mXlaRuntimeError\u001b[39m Traceback (most recent call last)",
+ "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[12]\u001b[39m\u001b[32m, line 22\u001b[39m\n\u001b[32m 15\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m element_camera \u001b[38;5;129;01min\u001b[39;00m cameras:\n\u001b[32m 16\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m jnp.printoptions(precision=\u001b[32m4\u001b[39m, suppress=\u001b[38;5;28;01mTrue\u001b[39;00m):\n\u001b[32m 17\u001b[39m \u001b[38;5;66;03m# display(element_camera)\u001b[39;00m\n\u001b[32m 18\u001b[39m \u001b[38;5;66;03m# display(element_camera.params.Rt.reshape(-1))\u001b[39;00m\n\u001b[32m 19\u001b[39m \u001b[38;5;66;03m# display(element_camera.params.K.reshape(-1))\u001b[39;00m\n\u001b[32m 20\u001b[39m \n\u001b[32m 21\u001b[39m \u001b[38;5;66;03m# compute camera to object point distance\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m22\u001b[39m transistion = \u001b[43melement_camera\u001b[49m\u001b[43m.\u001b[49m\u001b[43mparams\u001b[49m\u001b[43m.\u001b[49m\u001b[43mpose_matrix\u001b[49m[:\u001b[32m3\u001b[39m, -\u001b[32m1\u001b[39m]\n\u001b[32m 23\u001b[39m \u001b[38;5;66;03m# display(transistion)\u001b[39;00m\n\u001b[32m 24\u001b[39m \u001b[38;5;66;03m# display(jnp.linalg.norm(transistion).item())\u001b[39;00m\n",
+ "\u001b[36mFile \u001b[39m\u001b[32m~/Code/CVTH3PE/app/camera/__init__.py:305\u001b[39m, in \u001b[36mCameraParams.pose_matrix\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 303\u001b[39m t = \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33m_pose\u001b[39m\u001b[33m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[32m 304\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m t \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m305\u001b[39m t = \u001b[43mjnp\u001b[49m\u001b[43m.\u001b[49m\u001b[43mlinalg\u001b[49m\u001b[43m.\u001b[49m\u001b[43minv\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mRt\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 306\u001b[39m \u001b[38;5;28mobject\u001b[39m.\u001b[34m__setattr__\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33m_pose\u001b[39m\u001b[33m\"\u001b[39m, t)\n\u001b[32m 307\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m t\n",
+ " \u001b[31m[... skipping hidden 5 frame]\u001b[39m\n",
+ "\u001b[36mFile \u001b[39m\u001b[32m~/Code/CVTH3PE/.venv/lib/python3.12/site-packages/jax/_src/interpreters/pxla.py:1297\u001b[39m, in \u001b[36mExecuteReplicated.__call__\u001b[39m\u001b[34m(self, *args)\u001b[39m\n\u001b[32m 1295\u001b[39m \u001b[38;5;28mself\u001b[39m._handle_token_bufs(result_token_bufs, sharded_runtime_token)\n\u001b[32m 1296\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m1297\u001b[39m results = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mxla_executable\u001b[49m\u001b[43m.\u001b[49m\u001b[43mexecute_sharded\u001b[49m\u001b[43m(\u001b[49m\u001b[43minput_bufs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1299\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m dispatch.needs_check_special():\n\u001b[32m 1300\u001b[39m out_arrays = results.disassemble_into_single_device_arrays()\n",
+ "\u001b[31mXlaRuntimeError\u001b[39m: INTERNAL: jaxlib/gpu/solver_handle_pool.cc:37: operation gpusolverDnCreate(&handle) failed: cuSolver internal error"
+ ]
+ }
+ ],
"source": [
"camera_list = [\n",
" 5601,\n",
@@ -484,7 +534,7 @@
},
{
"cell_type": "code",
- "execution_count": 11,
+ "execution_count": null,
"metadata": {},
"outputs": [],
"source": [
@@ -710,7 +760,7 @@
},
{
"cell_type": "code",
- "execution_count": 12,
+ "execution_count": null,
"metadata": {},
"outputs": [],
"source": [
@@ -729,7 +779,7 @@
},
{
"cell_type": "code",
- "execution_count": 13,
+ "execution_count": null,
"metadata": {},
"outputs": [
{
@@ -762,7 +812,7 @@
},
{
"cell_type": "code",
- "execution_count": 14,
+ "execution_count": null,
"metadata": {},
"outputs": [
{
@@ -786,7 +836,7 @@
},
{
"cell_type": "code",
- "execution_count": 15,
+ "execution_count": null,
"metadata": {},
"outputs": [],
"source": [
@@ -1104,7 +1154,7 @@
},
{
"cell_type": "code",
- "execution_count": 16,
+ "execution_count": null,
"metadata": {},
"outputs": [],
"source": [
@@ -1162,7 +1212,7 @@
},
{
"cell_type": "code",
- "execution_count": 17,
+ "execution_count": null,
"metadata": {},
"outputs": [
{
@@ -1185,7 +1235,7 @@
},
{
"cell_type": "code",
- "execution_count": 18,
+ "execution_count": null,
"metadata": {},
"outputs": [
{
@@ -1220,7 +1270,7 @@
},
{
"cell_type": "code",
- "execution_count": 19,
+ "execution_count": null,
"metadata": {},
"outputs": [
{
@@ -1242,7 +1292,7 @@
},
{
"cell_type": "code",
- "execution_count": 20,
+ "execution_count": null,
"metadata": {},
"outputs": [],
"source": [
@@ -1297,7 +1347,7 @@
},
{
"cell_type": "code",
- "execution_count": 21,
+ "execution_count": null,
"metadata": {},
"outputs": [
{
@@ -1316,7 +1366,7 @@
},
{
"cell_type": "code",
- "execution_count": 22,
+ "execution_count": null,
"metadata": {},
"outputs": [
{
@@ -2973,7 +3023,7 @@
},
{
"cell_type": "code",
- "execution_count": 23,
+ "execution_count": null,
"metadata": {},
"outputs": [
{
@@ -3004,7 +3054,7 @@
},
{
"cell_type": "code",
- "execution_count": 24,
+ "execution_count": null,
"metadata": {},
"outputs": [
{
@@ -3051,7 +3101,7 @@
},
{
"cell_type": "code",
- "execution_count": 25,
+ "execution_count": null,
"metadata": {},
"outputs": [
{
@@ -3071,7 +3121,7 @@
},
{
"cell_type": "code",
- "execution_count": 26,
+ "execution_count": null,
"metadata": {},
"outputs": [],
"source": [
@@ -3085,7 +3135,7 @@
},
{
"cell_type": "code",
- "execution_count": 27,
+ "execution_count": null,
"metadata": {},
"outputs": [],
"source": [
@@ -3107,7 +3157,7 @@
},
{
"cell_type": "code",
- "execution_count": 28,
+ "execution_count": null,
"metadata": {},
"outputs": [],
"source": [
@@ -3140,7 +3190,7 @@
},
{
"cell_type": "code",
- "execution_count": 29,
+ "execution_count": null,
"metadata": {},
"outputs": [],
"source": [
@@ -3158,7 +3208,7 @@
},
{
"cell_type": "code",
- "execution_count": 30,
+ "execution_count": null,
"metadata": {},
"outputs": [],
"source": [
@@ -3172,7 +3222,7 @@
},
{
"cell_type": "code",
- "execution_count": 31,
+ "execution_count": null,
"metadata": {},
"outputs": [],
"source": [
@@ -3196,7 +3246,7 @@
],
"metadata": {
"kernelspec": {
- "display_name": ".venv",
+ "display_name": "cvth3pe",
"language": "python",
"name": "python3"
},
diff --git a/single_people_detect_track.py b/single_people_detect_track.py
index 9468c39..2daaf69 100644
--- a/single_people_detect_track.py
+++ b/single_people_detect_track.py
@@ -6,6 +6,7 @@ import awkward as ak
from typing import (
Any,
Generator,
+ Iterable,
Optional,
Sequence,
TypeAlias,
@@ -121,7 +122,7 @@ def get_camera_detect(
for element_port in ak.to_numpy(camera_dataset["port"]):
if element_port in camera_port:
keypoint_data[int(element_port)] = ak.from_parquet(
- detect_path / f"{element_port}.parquet"
+ detect_path / f"{element_port}_detected.parquet"
)
return keypoint_data
@@ -258,7 +259,13 @@ def sync_batch_gen(
for i, gen in enumerate(gens):
try:
if finished[i] or paused[i]:
- continue
+ if all(finished):
+ if len(current_batch) > 0:
+ # All generators exhausted, flush remaining batch and exit
+ yield current_batch
+ return
+ else:
+ continue
val = next(gen)
if last_batch_timestamp is None:
last_batch_timestamp = val.timestamp
@@ -280,13 +287,7 @@ def sync_batch_gen(
else:
current_batch.append(val)
except StopIteration:
- finished[i] = True
- paused[i] = True
- if all(finished):
- if len(current_batch) > 0:
- # All generators exhausted, flush remaining batch and exit
- yield current_batch
- break
+ return
def get_batch_detect(
@@ -475,38 +476,36 @@ def triangulate_one_point_from_multiple_views_linear(
proj_matrices: Float[Array, "N 3 4"],
points: Num[Array, "N 2"],
confidences: Optional[Float[Array, "N"]] = None,
+ conf_threshold: float = 0.2,
) -> Float[Array, "3"]:
"""
Args:
proj_matrices: 形状为(N, 3, 4)的投影矩阵序列
points: 形状为(N, 2)的点坐标序列
confidences: 形状为(N,)的置信度序列，范围[0.0, 1.0]
-
+ conf_threshold: 置信度阈值，低于该值的观测不参与DLT
Returns:
point_3d: 形状为(3,)的三角测量得到的3D点
"""
assert len(proj_matrices) == len(points)
-
N = len(proj_matrices)
- confi: Float[Array, "N"]
-
if confidences is None:
- confi = jnp.ones(N, dtype=np.float32)
+ weights = jnp.ones(N, dtype=jnp.float32)
else:
- # Use square root of confidences for weighting - more balanced approach
- confi = jnp.sqrt(jnp.clip(confidences, 0, 1))
+ # 置信度低于阈值的点权重为0，其余为sqrt(conf)
+ valid_mask = confidences >= conf_threshold
+ weights = jnp.where(valid_mask, jnp.sqrt(jnp.clip(confidences, 0, 1)), 0.0)
+ # 归一化权重，避免某一帧权重过大
+ sum_weights = jnp.sum(weights)
+ weights = jnp.where(sum_weights > 0, weights / sum_weights, weights)
- # 将置信度小于0.1点的置信度均设置为0
- # valid_mask = confidences >= 0.1
- # confi = jnp.sqrt(jnp.clip(confidences * valid_mask, 0.0, 1.0))
-
- A = jnp.zeros((N * 2, 4), dtype=np.float32)
+ A = jnp.zeros((N * 2, 4), dtype=jnp.float32)
for i in range(N):
x, y = points[i]
A = A.at[2 * i].set(proj_matrices[i, 2] * x - proj_matrices[i, 0])
A = A.at[2 * i + 1].set(proj_matrices[i, 2] * y - proj_matrices[i, 1])
- A = A.at[2 * i].mul(confi[i])
- A = A.at[2 * i + 1].mul(confi[i])
+ A = A.at[2 * i].mul(weights[i])
+ A = A.at[2 * i + 1].mul(weights[i])
# https://docs.jax.dev/en/latest/_autosummary/jax.numpy.linalg.svd.html
_, _, vh = jnp.linalg.svd(A, full_matrices=False)
@@ -896,23 +895,68 @@ def update_tracking(
tracking.state = new_state
+# 对每一个3d目标进行滑动窗口平滑处理
+def smooth_3d_keypoints(
+ all_3d_kps: dict[str, list], window_size: int = 5
+) -> dict[str, list]:
+ # window_size = 5
+ kernel = np.ones(window_size) / window_size
+ smoothed_points = dict()
+ for item_object_index in all_3d_kps.keys():
+ item_object = np.array(all_3d_kps[item_object_index])
+ if item_object.shape[0] < window_size:
+ # 如果数据点少于窗口大小，则直接返回原始数据
+ smoothed_points[item_object_index] = item_object.tolist()
+ continue
+
+ # 对每个关键点的每个坐标轴分别做滑动平均
+ item_smoothed = np.zeros_like(item_object)
+ # 遍历133个关节
+ for kp_idx in range(item_object.shape[1]):
+ # 遍历每个关节的空间三维坐标点
+ for axis in range(3):
+ # 对第i帧的滑动平滑方式 smoothed[i] = (point[i-2] + point[i-1] + point[i] + point[i+1] + point[i+2]) / 5
+ item_smoothed[:, kp_idx, axis] = np.convolve(
+ item_object[:, kp_idx, axis], kernel, mode="same"
+ )
+ smoothed_points[item_object_index] = item_smoothed.tolist()
+ return smoothed_points
+
+
+# 通过平均置信度筛选2d检测数据
+def filter_keypoints_by_scores(detections: Iterable[Detection], threshold: float = 0.5):
+ """
+ Filter detections based on the average confidence score of their keypoints.
+ Only keep detections with an average score above the threshold.
+ """
+
+ def filter_detection(detection: Detection) -> bool:
+ avg_score = np.mean(detection.confidences)
+ return float(avg_score) >= threshold
+
+ return filter(filter_detection, detections)
+
+
+def filter_camera_port(detections: list[Detection]):
+ camera_port = set()
+ for detection in detections:
+ camera_port.add(detection.camera.id)
+ return list(camera_port)
+
+
# 相机内外参路径
-CAMERA_PATH = Path(
- "/home/admin/Documents/ActualTest_QuanCheng/camera_ex_params_1_2025_4_20/camera_params"
-)
+CAMERA_PATH = Path("/home/admin/Documents/ActualTest_WeiHua/camera_params")
# 所有机位的相机内外参
AK_CAMERA_DATASET: ak.Array = get_camera_params(CAMERA_PATH)
# 2d检测数据路径
-DATASET_PATH = Path(
- "/home/admin/Documents/ActualTest_QuanCheng/camera_ex_params_1_2025_4_20/detect_result/segement_1"
-)
+DATASET_PATH = Path("/home/admin/Documents/ActualTest_WeiHua/Test_Video")
# 指定机位的2d检测数据
-camera_port = [5603, 5605, 5608, 5609]
+camera_port = [5602, 5603, 5604, 5605]
KEYPOINT_DATASET = get_camera_detect(DATASET_PATH, camera_port, AK_CAMERA_DATASET)
# 获取一段完整的跳跃片段
-FRAME_INDEX = [i for i in range(0, 600)]
+FRAME_INDEX = [i for i in range(552, 1488)] # 552， 1488
KEYPOINT_DATASET = get_segment(camera_port, FRAME_INDEX, KEYPOINT_DATASET)
@@ -935,15 +979,14 @@ ALPHA_3D = 0.15
# 帧数计数器
count = 0
# 追踪相似度矩阵匹配阈值
-affinities_threshold = 70
+affinities_threshold = -20
# 跟踪目标集合
trackings: list[Tracking] = []
# 3d数据，键为追踪目标id，值为该目标的所有3d数据
all_3d_kps: dict[str, list] = {}
# 遍历2d数据，测试追踪状态
-while count < (max(FRAME_INDEX) - min(FRAME_INDEX)):
- count += 1
+while True:
# 获得当前追踪目标
trackings: list[Tracking] = sorted(
global_tracking_state.trackings.values(), key=lambda x: x.id
@@ -951,14 +994,21 @@ while count < (max(FRAME_INDEX) - min(FRAME_INDEX)):
try:
detections = next(sync_gen)
+ # 通过平均置信度筛选2d检测数据
+ # detections = list(filter_keypoints_by_scores(detections, threshold=0.5))
except StopIteration:
break
+
if len(detections) == 0:
+ print("no detections in this frame, continue")
continue
- # print("Detection len:", len(detections), "count:", count)
+
# 获得最新一帧的数据2d数据
# 判断追踪状态是否建立成功，若不成功则跳过这一帧数据，直到追踪建立
if not trackings:
+
+ """离机时使用，用于初始化第一帧"""
+ """
# 使用盒子筛选后的2d检测数据
filter_detections = get_filter_detections(detections)
# 当3个机位均有目标时才建立追踪状态
@@ -966,25 +1016,35 @@ while count < (max(FRAME_INDEX) - min(FRAME_INDEX)):
# continue
if len(filter_detections) < len(camera_port):
print(
- "init traincking error, filter detections len:",
+ "init traincking error, filter filter_detections len:",
len(filter_detections),
- "time:",
- detections[0].timestamp,
)
continue
- # 添加第一帧数据构建追踪目标
- global_tracking_state.add_tracking(filter_detections)
- # 获得当前追踪目标
- trackings: list[Tracking] = sorted(
- global_tracking_state.trackings.values(), key=lambda x: x.id
- )
- # 保留第一帧的3d姿态数据
- for element_tracking in trackings:
- if str(element_tracking.id) not in all_3d_kps.keys():
- all_3d_kps[str(element_tracking.id)] = [
- element_tracking.state.keypoints.tolist()
- ]
- print("initer tracking:", trackings)
+ """
+ # 通过平均置信度筛选2d检测数据
+ # detections = list(filter_keypoints_by_scores(detections, threshold=0.7))
+
+ # 当4个机位都识别到目标时才建立追踪状态
+ camera_port = filter_camera_port(detections)
+ if len(detections) < len(camera_port):
+ print(
+ "init traincking error, filter_detections len:",
+ len(detections),
+ )
+ else:
+ # 添加第一帧数据构建追踪目标
+ global_tracking_state.add_tracking(detections) # 离机时：filter_detections
+ # 获得当前追踪目标
+ trackings: list[Tracking] = sorted(
+ global_tracking_state.trackings.values(), key=lambda x: x.id
+ )
+ # 保留第一帧的3d姿态数据
+ for element_tracking in trackings:
+ if str(element_tracking.id) not in all_3d_kps.keys():
+ all_3d_kps[str(element_tracking.id)] = [
+ element_tracking.state.keypoints.tolist()
+ ]
+ print("initer tracking:", trackings)
else:
# 计算相似度矩阵匹配结果
affinities: dict[str, AffinityResult] = calculate_affinity_matrix(
@@ -1045,8 +1105,7 @@ while count < (max(FRAME_INDEX) - min(FRAME_INDEX)):
- element_tracking.state.last_active_timestamp
)
# 当时间间隔超过1s，删除保留的追踪状态
- if time_gap.seconds > 3:
- # trackings.remove(element_tracking)
+ if time_gap.seconds > 0.5:
global_tracking_state._trackings.pop(element_tracking.id)
print(
"remove trackings:",
@@ -1055,8 +1114,12 @@ while count < (max(FRAME_INDEX) - min(FRAME_INDEX)):
detections[0].timestamp,
)
+# 对每一个3d目标进行滑动窗口平滑处理
+smoothed_points = smooth_3d_keypoints(all_3d_kps, window_size=5)
-with open("samples/QuanCheng_res.json", "wb") as f:
- f.write(orjson.dumps(all_3d_kps))
-for element_3d_kps_id in all_3d_kps.keys():
+# 将结果保存到json文件中
+with open("samples/Test_WeiHua.json", "wb") as f:
+ f.write(orjson.dumps(smoothed_points))
+# 输出每个3d目标的维度
+for element_3d_kps_id in smoothed_points.keys():
print(f"{element_3d_kps_id} : {np.array(all_3d_kps[element_3d_kps_id]).shape}")
diff --git a/smooth_3d_kps.ipynb b/smooth_3d_kps.ipynb
new file mode 100644
index 0000000..4f12fe7
--- /dev/null
+++ b/smooth_3d_kps.ipynb
@@ -0,0 +1,122 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "id": "0d48b7eb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import json\n",
+ "from pathlib import Path\n",
+ "import numpy as np"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "id": "dfd27584",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "KPS_PATH = Path(\"samples/WeiHua_03.json\")\n",
+ "with open(KPS_PATH, \"r\") as file:\n",
+ " data = json.load(file)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "id": "360f9c50",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'index:1, shape: (33, 133, 3)'"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "'index:2, shape: (662, 133, 3)'"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "for item_object_index in data.keys():\n",
+ " item_object = np.array(data[item_object_index])\n",
+ " display(f'index:{item_object_index}, shape: {item_object.shape}')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# 对data['2']的662帧3d关键点数据进行滑动窗口平滑处理\n",
+ "object_points = np.array(data['2']) # shape: (662, 133, 3)\n",
+ "window_size = 5\n",
+ "kernel = np.ones(window_size) / window_size\n",
+ "# 对每个关键点的每个坐标轴分别做滑动平均\n",
+ "smoothed_points = np.zeros_like(object_points)\n",
+ "# 遍历133个关节\n",
+ "for kp_idx in range(object_points.shape[1]):\n",
+ " # 遍历每个关节的空间三维坐标点\n",
+ " for axis in range(3):\n",
+ " # 对第i帧的滑动平滑方式 smoothed[i] = (point[i-2] + point[i-1] + point[i] + point[i+1] + point[i+2]) / 5\n",
+ " smoothed_points[:, kp_idx, axis] = np.convolve(object_points[:, kp_idx, axis], kernel, mode='same')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "id": "24c6c0c9",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'smoothed_points shape: (662, 133, 3)'"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "display(f'smoothed_points shape: {smoothed_points.shape}')\n",
+ "with open(\"samples/smoothed_3d_kps.json\", \"w\") as file:\n",
+ " json.dump({'1':smoothed_points.tolist()}, file)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "cvth3pe",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.9"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/test_filter_object_by_box.ipynb b/test_filter_object_by_box.ipynb
index 5638c67..6d70b2c 100644
--- a/test_filter_object_by_box.ipynb
+++ b/test_filter_object_by_box.ipynb
@@ -2,7 +2,7 @@
"cells": [
{
"cell_type": "code",
- "execution_count": 311,
+ "execution_count": 3,
"id": "3265b2cc",
"metadata": {},
"outputs": [],
@@ -33,7 +33,7 @@
},
{
"cell_type": "code",
- "execution_count": 312,
+ "execution_count": 4,
"id": "e6589e07",
"metadata": {},
"outputs": [],
@@ -44,12 +44,12 @@
},
{
"cell_type": "code",
- "execution_count": 313,
+ "execution_count": 5,
"id": "b8898483",
"metadata": {},
"outputs": [],
"source": [
- "index = 5\n",
+ "index = 9\n",
"DETECT_INDEX = {\n",
" 1:\"5601\",\n",
" 2:\"5602\",\n",
@@ -67,7 +67,7 @@
},
{
"cell_type": "code",
- "execution_count": 314,
+ "execution_count": 6,
"id": "990361fb",
"metadata": {},
"outputs": [],
@@ -78,7 +78,7 @@
},
{
"cell_type": "code",
- "execution_count": 315,
+ "execution_count": 7,
"id": "0b07ef52",
"metadata": {},
"outputs": [
@@ -128,17 +128,17 @@
},
{
"cell_type": "code",
- "execution_count": 316,
+ "execution_count": 8,
"id": "c39a4e73",
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
- "{name: 'AF_05',\n",
- " port: 5605,\n",
- " intrinsic: {camera_matrix: [[2.64e+03, ...], ...], ...},\n",
- " extrinsic: {rvec: [1.25, 0.0803, -2.87], tvec: [-0.767, ...]},\n",
+ "{name: 'AE_08',\n",
+ " port: 5609,\n",
+ " intrinsic: {camera_matrix: [[2.79e+03, ...], ...], ...},\n",
+ " extrinsic: {rvec: [-3, -0.0889, 0.853], tvec: [-0.172, ...]},\n",
" resolution: {width: 2560, height: 1440}}\n",
"--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
"backend: cpu\n",
@@ -161,7 +161,7 @@
"}"
],
"text/plain": [
- ""
+ ""
]
},
"metadata": {},
@@ -175,7 +175,7 @@
},
{
"cell_type": "code",
- "execution_count": 317,
+ "execution_count": 9,
"id": "fc7e4711",
"metadata": {},
"outputs": [],
@@ -198,19 +198,20 @@
},
{
"cell_type": "code",
- "execution_count": 318,
+ "execution_count": 10,
"id": "ce35eae6",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
- "{'rvec': array([ 1.253436 , 0.08028614, -2.86865678]),\n",
- " 'tvec': array([-0.76656717, 0.42342791, 6.18892342]),\n",
- " 'camera_matrix': array([[2.64468145e+03, 0.00000000e+00, 1.28534889e+03],\n",
- " [0.00000000e+00, 2.64497010e+03, 6.27208086e+02],\n",
+ "{'rvec': array([-2.99837244, -0.0889235 , 0.85288411]),\n",
+ " 'tvec': array([-0.17150598, -0.01129812, 6.82362942]),\n",
+ " 'camera_matrix': array([[2.78543932e+03, 0.00000000e+00, 1.25498272e+03],\n",
+ " [0.00000000e+00, 2.78810438e+03, 7.38829853e+02],\n",
" [0.00000000e+00, 0.00000000e+00, 1.00000000e+00]]),\n",
- " 'dist': array([-0.5779251 , 0.43463787, 0.01810833, 0.00847768, -1.06242793]),\n",
+ " 'dist': array([-5.63745882e-01, 1.98909887e+00, -6.79488058e-04, -2.57257779e-03,\n",
+ " -3.34679032e+00]),\n",
" 'width': np.int64(2560),\n",
" 'height': np.int64(1440)}"
]
@@ -233,7 +234,7 @@
},
{
"cell_type": "code",
- "execution_count": 319,
+ "execution_count": 11,
"id": "0723986a",
"metadata": {},
"outputs": [
@@ -241,12 +242,12 @@
"data": {
"text/html": [
"{frame_index: 1650,\n",
- " boxes: [[918, 414, 1.24e+03, 965], [2.37e+03, 559, 2.51e+03, 979]],\n",
- " kps: [[[930, 514], [930, 500], ..., [1.03e+03, ...], [1.03e+03, 604]], ...],\n",
- " kps_scores: [[0.589, 0.625, 0.478, 0.636, ..., 0.242, 0.242, 0.221], ...]}\n",
+ " boxes: [[1.33e+03, 389, 1.58e+03, 830], [...], ..., [2.21e+03, 543, ..., 751]],\n",
+ " kps: [[[1.37e+03, 478], [1.38e+03, 469], ..., [...], [1.44e+03, 539]], ...],\n",
+ " kps_scores: [[0.813, 0.806, 0.868, 0.732, ..., 0.251, 0.242, 0.207], ...]}\n",
"-----------------------------------------------------------------------------------------------------------------------------------------\n",
"backend: cpu\n",
- "nbytes: 16.1 MB\n",
+ "nbytes: 47.6 MB\n",
"type: {\n",
" frame_index: int64,\n",
" boxes: var * var * float64,\n",
@@ -270,14 +271,14 @@
},
{
"cell_type": "code",
- "execution_count": 320,
+ "execution_count": 12,
"id": "809ede80",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
- "(2, 133, 2)"
+ "(6, 133, 2)"
]
},
"metadata": {},
@@ -297,7 +298,7 @@
},
{
"cell_type": "code",
- "execution_count": 321,
+ "execution_count": 13,
"id": "7b358faf",
"metadata": {},
"outputs": [],
@@ -324,14 +325,14 @@
},
{
"cell_type": "code",
- "execution_count": 322,
+ "execution_count": 14,
"id": "1cc53101",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
- ""
+ ""
]
},
"metadata": {},
@@ -339,7 +340,7 @@
},
{
"data": {
- "image/png": "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",
+ "image/png": "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",
"text/plain": [
""
]
@@ -354,7 +355,7 @@
},
{
"cell_type": "code",
- "execution_count": 323,
+ "execution_count": 15,
"id": "f2096d54",
"metadata": {},
"outputs": [],
@@ -375,7 +376,7 @@
},
{
"cell_type": "code",
- "execution_count": 324,
+ "execution_count": 16,
"id": "f6e9abe6",
"metadata": {},
"outputs": [],
@@ -402,7 +403,7 @@
},
{
"cell_type": "code",
- "execution_count": 325,
+ "execution_count": 17,
"id": "375fbdb0",
"metadata": {},
"outputs": [
@@ -437,21 +438,21 @@
},
{
"cell_type": "code",
- "execution_count": 326,
+ "execution_count": 18,
"id": "6943c11b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
- "{'0': [1295, 961],\n",
- " '1': [1060, 995],\n",
- " '2': [1092, 43],\n",
- " '3': [1321, 86],\n",
- " '4': [977, 899],\n",
- " '5': [753, 922],\n",
- " '6': [786, 102],\n",
- " '7': [1004, 129]}"
+ "{'0': [1431, 803],\n",
+ " '1': [1642, 820],\n",
+ " '2': [1670, 160],\n",
+ " '3': [1460, 167],\n",
+ " '4': [1242, 814],\n",
+ " '5': [1474, 834],\n",
+ " '6': [1506, 86],\n",
+ " '7': [1276, 100]}"
]
},
"metadata": {},
@@ -468,7 +469,7 @@
},
{
"cell_type": "code",
- "execution_count": 327,
+ "execution_count": 19,
"id": "fe63d521",
"metadata": {},
"outputs": [],
@@ -492,25 +493,25 @@
},
{
"cell_type": "code",
- "execution_count": 328,
+ "execution_count": 20,
"id": "18e09dae",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
- "[[[977, 899], [786, 102], [1004, 129]],\n",
- " [[977, 899], [753, 922], [786, 102]],\n",
- " [[1092, 43], [753, 922], [786, 102]],\n",
- " [[1060, 995], [1092, 43], [753, 922]],\n",
- " [[1060, 995], [1092, 43], [1321, 86]],\n",
- " [[1295, 961], [1060, 995], [1321, 86]],\n",
- " [[1295, 961], [1321, 86], [1004, 129]],\n",
- " [[1295, 961], [977, 899], [1004, 129]],\n",
- " [[1092, 43], [786, 102], [1004, 129]],\n",
- " [[1092, 43], [1321, 86], [1004, 129]],\n",
- " [[1295, 961], [977, 899], [753, 922]],\n",
- " [[1295, 961], [1060, 995], [753, 922]]]"
+ "[[[1242, 814], [1506, 86], [1276, 100]],\n",
+ " [[1242, 814], [1474, 834], [1506, 86]],\n",
+ " [[1670, 160], [1474, 834], [1506, 86]],\n",
+ " [[1642, 820], [1670, 160], [1474, 834]],\n",
+ " [[1642, 820], [1670, 160], [1460, 167]],\n",
+ " [[1431, 803], [1642, 820], [1460, 167]],\n",
+ " [[1431, 803], [1460, 167], [1276, 100]],\n",
+ " [[1431, 803], [1242, 814], [1276, 100]],\n",
+ " [[1670, 160], [1506, 86], [1276, 100]],\n",
+ " [[1670, 160], [1460, 167], [1276, 100]],\n",
+ " [[1431, 803], [1242, 814], [1474, 834]],\n",
+ " [[1431, 803], [1642, 820], [1474, 834]]]"
]
},
"metadata": {},
@@ -532,7 +533,7 @@
},
{
"cell_type": "code",
- "execution_count": 329,
+ "execution_count": 21,
"id": "e456f46e",
"metadata": {},
"outputs": [],
@@ -564,14 +565,14 @@
},
{
"cell_type": "code",
- "execution_count": 330,
+ "execution_count": 22,
"id": "003f8fcb",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
- "483849.0"
+ "286724.0"
]
},
"metadata": {},
@@ -580,10 +581,10 @@
{
"data": {
"image/svg+xml": [
- ""
+ ""
],
"text/plain": [
- ""
+ ""
]
},
"metadata": {},
@@ -599,7 +600,7 @@
},
{
"cell_type": "code",
- "execution_count": 331,
+ "execution_count": 23,
"id": "104a250d",
"metadata": {},
"outputs": [],
@@ -643,13 +644,13 @@
},
{
"cell_type": "code",
- "execution_count": 332,
+ "execution_count": 24,
"id": "0d1af87c",
"metadata": {},
"outputs": [
{
"data": {
- "image/png": "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",
+ "image/png": "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",
"text/plain": [
""
]
@@ -665,7 +666,7 @@
},
{
"cell_type": "code",
- "execution_count": 333,
+ "execution_count": 25,
"id": "d51c5b86",
"metadata": {},
"outputs": [],
@@ -707,7 +708,7 @@
},
{
"cell_type": "code",
- "execution_count": 334,
+ "execution_count": 26,
"id": "a55035af",
"metadata": {},
"outputs": [],
@@ -725,7 +726,7 @@
},
{
"cell_type": "code",
- "execution_count": 335,
+ "execution_count": 27,
"id": "a5590507",
"metadata": {},
"outputs": [],
@@ -736,7 +737,7 @@
},
{
"cell_type": "code",
- "execution_count": 336,
+ "execution_count": 28,
"id": "6c8f700b",
"metadata": {},
"outputs": [],
@@ -770,13 +771,13 @@
},
{
"cell_type": "code",
- "execution_count": 337,
+ "execution_count": 29,
"id": "b4bf2fc4",
"metadata": {},
"outputs": [
{
"data": {
- "image/png": "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",
+ "image/png": "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",
"text/plain": [
""
]
@@ -793,7 +794,7 @@
},
{
"cell_type": "code",
- "execution_count": 338,
+ "execution_count": 30,
"id": "faab365e",
"metadata": {},
"outputs": [],
@@ -804,7 +805,7 @@
},
{
"cell_type": "code",
- "execution_count": 339,
+ "execution_count": 31,
"id": "3f52fdf7",
"metadata": {},
"outputs": [
@@ -1339,6 +1340,24 @@
"metadata": {},
"output_type": "display_data"
},
+ {
+ "data": {
+ "text/plain": [
+ "'超过1人'"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "'超过1人'"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
{
"data": {
"text/plain": [
@@ -1387,7 +1406,7 @@
},
{
"cell_type": "code",
- "execution_count": 340,
+ "execution_count": 32,
"id": "cedc1d7f",
"metadata": {},
"outputs": [],
@@ -1398,7 +1417,7 @@
},
{
"cell_type": "code",
- "execution_count": 341,
+ "execution_count": 33,
"id": "a9d1e5da",
"metadata": {},
"outputs": [],