alfred-py 可以通过终端命令 alfred 调用，作为深度学习工具使用。它还提供了大量实用的 API，帮助你提升日常效率：比如绘制带有置信度和标签的边界框、在 Python 应用中进行日志记录、将模型转换为 TensorRT 引擎等。只需 import alfred，即可轻松实现所需功能。更多用法请参阅下方说明。

功能概览

由于许多新用户可能对 alfred 不太熟悉，这里简要总结其功能，详细内容请关注后续更新：

• 可视化：绘制边界框、掩码、关键点非常简单，甚至支持点云上的 3D 边界框；
• 命令行工具：例如查看任意格式（YOLO、VOC、COCO 等）的标注数据；
• 部署：可以使用 alfred 部署你的 TensorRT 模型；
• 深度学习常用工具：如 torch.device() 等；
• 渲染：渲染你的 3D 模型。

一张由 alfred 可视化的图片：

安装

安装 alfred 非常简单：

依赖项：

lxml [可选]
pycocotools [可选]
opencv-python [可选]

然后执行以下命令：

sudo pip3 install alfred-py

alfred 既是一个库，也是一个工具，你可以导入它的 API 使用，也可以直接在终端中调用。

安装完上述包后，你会得到一个名为 alfred 的命令行工具，以下是部分功能示例：

• data 模块：

  # 查看 VOC 标注
  alfred data vocview -i JPEGImages/ -l Annotations/
  # 查看 COCO 标注
  alfred data cocoview -j annotations/instance_2017.json -i images/
  # 查看 YOLO 标注
  alfred data yoloview -i images -l labels
  # 查看文本格式的目标检测标签
  alfred data txtview -i images/ -l txts/
  # 更多数据相关功能
  alfred data -h
  
  # 评估工具
  alfred data evalvoc -h
  

• cab 模块：

  # 统计某一类型文件的数量
  alfred cab count -d ./images -t jpg
  # 将文本文件按比例拆分为训练集和测试集
  alfred cab split -f all.txt -r 0.9,0.1 -n train,val
  

• vision 模块：

  # 将视频提取为图像
  alfred vision extract -v video.mp4
  # 将图像合成为视频
  alfred vision 2video -d images/
  

• -h 查看更多选项：

  usage: alfred [-h] [--version] {vision,text,scrap,cab,data} ...
  
  positional arguments:
    {vision,text,scrap,cab,data}
      vision              视觉相关命令。
      text                文本相关命令。
      scrap               抓取相关命令。
      cab                 文件柜相关命令。
      data                数据相关命令。
  
  optional arguments:
    -h, --help            显示帮助信息并退出
    --version, -v         显示版本信息。
  

  在每个子模块中，同样可以使用 -h 查看该模块的帮助信息：alfred text -h。

如果你在 Windows 上，可以通过以下命令安装 pycocotools：pip install "git+https://github.com/philferriere/cocoapi.git#egg=pycocotools&subdirectory=PythonAPI"。我们已将 pycocotools 设置为依赖项，因为我们需要使用 COCO API。

更新

alfred-py 已经更新了三年，并且还会继续更新下去！

• 2050-xxx: 待续；

• 2023.04.28: 更新了 3D 关键点可视化工具，现在可以实时可视化 Human3DM 的关键点： 更多细节请参考 examples/demo_o3d_server.py。结果是由 MotionBert 生成的。

• 2022.01.18: 现在 alfred 支持基于 Open3D 的 Mesh3D 可视化服务器：

  from alfred.vis.mesh3d.o3dsocket import VisOpen3DSocket
  
  def main():
      server = VisOpen3DSocket()
      while True:
          server.update()
  
  
  if __name__ == "__main__":
      main()
  

  接下来，你只需要设置一个客户端，将 keypoints3d 发送到服务器，它就会自动进行可视化。效果如下：

• 2021.12.22: 现在 alfred 支持关键点可视化，mmpose 中几乎所有的数据集也都被 alfred 支持：

  from alfred.vis.image.pose import vis_pose_result
  
  # preds 是姿态，对于 COCO 身体来说是 (Bs, 17, 3)
  vis_pose_result(ori_image, preds, radius=5, thickness=2, show=True)
  

• 2021.12.05: 现在可以使用 alfred.deploy.tensorrt 进行 TensorRT 推理：

  from alfred.deploy.tensorrt.common import do_inference_v2, allocate_buffers_v2, build_engine_onnx_v3
  
  def engine_infer(engine, context, inputs, outputs, bindings, stream, test_image):
  
    # image_input, img_raw, _ = preprocess_np(test_image)
    image_input, img_raw, _ = preprocess_img((test_image))
    print('input shape: ', image_input.shape)
    inputs[0].host = image_input.astype(np.float32).ravel()
  
    start = time.time()
    dets, labels, masks = do_inference_v2(context, bindings=bindings, inputs=inputs,
                                          outputs=outputs, stream=stream, input_tensor=image_input)
  img_f = 'demo/demo.jpg'
  with build_engine_onnx_v3(onnx_file_path=onnx_f) as engine:
      inputs, outputs, bindings, stream = allocate_buffers_v2(engine)
      # Contexts are used to perform inference.
      with engine.create_execution_context() as context:
          print(engine.get_binding_shape(0))
          print(engine.get_binding_shape(1))
          print(engine.get_binding_shape(2))
          INPUT_SHAPE = engine.get_binding_shape(0)[-2:]
  
          print(context.get_binding_shape(0))
          print(context.get_binding_shape(1))
          dets, labels, masks, img_raw = engine_infer(
              engine, context, inputs, outputs, bindings, stream, img_f)
  

• 2021.11.13: 现在我添加了 Siren SDK 的支持！

  from functools import wraps
  from alfred.siren.handler import SirenClient
  from alfred.siren.models import ChatMessage, InvitationMessage
  
  siren = SirenClient('daybreak_account', 'password')
  
  
  @siren.on_received_invitation
  def on_received_invitation(msg: InvitationMessage):
      print('received invitation: ', msg.invitation)
      # directly agree this invitation for robots
  
  
  @siren.on_received_chat_message
  def on_received_chat_msg(msg: ChatMessage):
      print('got new msg: ', msg.text)
      siren.publish_txt_msg('I got your message O(∩_∩)O哈哈~', msg.roomId)
  
  
  if __name__ == '__main__':
      siren.loop()
  

  使用这个，你可以轻松地搭建一个聊天机器人。通过使用 Siren 客户端。

• 2021.06.24: 添加了一个实用的命令行工具，轻松更改你的 PyPI 源！！：

  alfred cab changesource
  

  然后你的 PyPI 默认就会使用阿里云源了！

• 2021.05.07: 升级 Open3D 的说明： Open3D>0.9.0 不再兼容之前的 alfred-py。请升级 Open3D，你可以从源码编译 Open3D：

    git clone --recursive https://github.com/intel-isl/Open3D.git
    cd Open3D && mkdir build && cd build
    sudo apt install libc++abi-8-dev
    sudo apt install libc++-8-dev
    cmake .. -DPYTHON_EXECUTABLE=/usr/bin/python3
  

  我在 Ubuntu 16.04 及以下版本上尝试过所有方法，都无法从源码编译成功。因此，请为 alfred-py 使用 open3d==0.9.0。

• 2021.04.01: 添加了一个统一的评估器。众所周知，对于许多用户来说，编写评估代码可能会与项目深度耦合。但在 Alfred 的帮助下，你可以在任何项目中只需编写 8 行代码即可完成评估。例如，如果你的数据集格式是 Yolo，那么可以这样做：

    def infer_func(img_f):
    image = cv2.imread(img_f)
    results = config_dict['model'].predict_for_single_image(
        image, aug_pipeline=simple_widerface_val_pipeline, classification_threshold=0.89, nms_threshold=0.6, class_agnostic=True)
    if len(results) > 0:
        results = np.array(results)[:, [2, 3, 4, 5, 0, 1]]
        # xywh to xyxy
        results[:, 2] += results[:, 0]
        results[:, 3] += results[:, 1]
    return results
  
    if __name__ == '__main__':
        conf_thr = 0.4
        iou_thr = 0.5
  
        imgs_root = 'data/hand/images'
        labels_root = 'data/hand/labels'
  
        yolo_parser = YoloEvaluator(imgs_root=imgs_root, labels_root=labels_root, infer_func=infer_func)
        yolo_parser.eval_precisely()
  

  然后你就可以自动获得评估结果。所有的召回率、精确率、mAP 都会被打印出来。更多数据集格式正在开发中。

• 2021.03.10: 新增了 ImageSourceIter 类，当你想要编写一个需要处理任意输入（如图像文件、文件夹、视频文件等）的项目演示时，可以使用 ImageSourceIter：

  from alfred.utils.file_io import ImageSourceIter
  
  # data_f 可以是图像文件或图像文件夹或视频
  iter = ImageSourceIter(ops.test_path)
  while True:
      itm = next(iter)
      if isinstance(itm, str):
          itm = cv2.imread(itm)
      # cv2.imshow('raw', itm)
      res = detect_for_pose(itm, det_model)
      cv2.imshow('res', itm)
      if iter.video_mode:
          cv2.waitKey(1)
      else:
          cv2.waitKey(0)
  

  这样你就可以避免再去写处理文件通配符或用 cv 读取视频的代码了。注意，itm 返回的可以是 cv 数组或文件路径。

• 2021.01.25: alfred 现在支持对 COCO 格式标注进行自定义可视化（不使用 pycoco 工具）：

  

  如果你的数据集是 COCO 格式但可视化不正确，请向我提交 issue，谢谢！

• 2020.09.27: 现在，YOLO 和 VOC 可以互相转换，因此使用 Alfred 你可以：

  • 将 YOLO 转换为 VOC；
  • 将 VOC 转换为 YOLO；
  • 将 VOC 转换为 COCO；
  • 将 COCO 转换为 VOC；

  通过这种方式，你可以相互转换任何标注格式。

• 2020.09.08: 经过一段时间的沉寂，alfred 终于迎来了一些更新： 我们在其内部提供了 coco2yolo 功能。用户可以运行以下命令将数据转换为 YOLO 格式：

  alfred data coco2yolo -i images/ -j annotations/val_split_2020.json
  

  你只需要提供图像根目录和 JSON 文件，所有结果都会生成到 yolo 文件夹中，或者直接放在图像父目录下。

  转换完成后（得到 yolo 文件夹），你可以可视化转换结果，看看是否正确：

  alfred data yolovview -i images/ -l labels/
  

  

• 2020.07.27: 经过一段时间的沉寂，alfred 终于迎来了一些更新：

  

  现在，你可以使用 alfred 在图像上绘制中文字符，而不会出现 xxxx 未定义编码的问题。

  from alfred.utils.cv_wrapper import put_cn_txt_on_img
  
  img = put_cn_txt_on_img(img, spt[-1], [points[0][0], points[0][1]-25], 1.0, (255, 255, 255))
  

  此外，你现在还可以 合并 两个 VOC 数据集！这在你有两个数据集并希望将它们合并成一个时非常有用。

  alfred data mergevoc -h
  

  你可以查看更多介绍。

• 2020.03.08：在 alfred 中新增了几项功能：

  alfred.utils.file_io: 提供通用的文件 I/O 工具
  alfred.dl.torch.env: 提供 PyTorch 中的种子或环境设置（API 与 Detectron2 相同）
  alfred.dl.torch.distribute: 用于 PyTorch 分布式训练的工具
  

• 2020.03.04: 我们增加了一些 评估工具，用于计算目标检测模型性能评估中的 mAP，这些工具非常实用，并且可以可视化结果：

  使用方法也非常简单：

  alfred data evalvoc -g ground-truth -d detection-results -im images
  

  其中 -g 是你的真实标签目录（包含 XML 或 TXT 文件），-d 是你的检测结果文件目录，-im 是你的图像文件夹。你只需要将所有检测结果保存为 TXT 文件，每张图片一个 TXT 文件，格式如下：

  bottle 0.14981 80 1 295 500  
  bus 0.12601 36 13 404 316  
  horse 0.12526 430 117 500 307  
  pottedplant 0.14585 212 78 292 118  
  tvmonitor 0.070565 388 89 500 196 
  

• 2020.02.27: 我们刚刚在 alfred 内部更新了一个 license 模块，比如你想为你的项目申请许可证或更新许可证，很简单：

   alfred cab license -o 'MANA' -n 'YoloV3' -u 'manaai.cn'
  

  你可以通过 alfred cab license -h 查看更详细的用法。

• 2020-02-11: open3d 的 API 发生了变化。我们已经在 alfred 中更新了新的 open3d，你可以简单使用最新的 open3d 并运行 python3 examples/draw_3d_pointcloud.py，你将会看到这样的效果：

  

• 2020-02-10: alfred 现在支持 Windows（实验性）；

• 2020-02-01: 武汉加油！alfred 修复了与编码 'gbk' 相关的 Windows pip 安装问题；

• 2020-01-14: 添加了 cabinet 模块，并在 data 模块下增加了一些工具；

• 2019-07-18: 添加了 1000 类的 ImageNet labelmap。可以通过以下方式调用：

  from alfred.vis.image.get_dataset_label_map import imagenet_labelmap
  
  # 同时，coco、voc、cityscapes 的 labelmap 也已添加
  from alfred.vis.image.get_dataset_label_map import coco_labelmap
  from alfred.vis.image.get_dataset_label_map import voc_labelmap
  from alfred.vis.image.get_dataset_label_map import cityscapes_labelmap
  

• 2019-07-13: 我们在命令行中添加了一个 VOC 检查模块，现在你可以像这样可视化你的 VOC 格式检测数据：

  alfred data voc_view -i ./images -l labels/
  

• 2019-05-17: 我们将 open3d 作为库加入到 Python 中，用于可视化 3D 点云。现在你可以做一些简单的准备，直接在激光雷达点云上可视化 3D 框，并像使用 OpenCV 一样显示出来！！

  

  你只需要使用 alfred-py 和 open3d 就可以实现这一点！

  示例代码可以在 examples/draw_3d_pointcloud.py 中找到。代码已更新为最新的 open3d API！

• 2019-05-10: 一个小更新，但 非常实用，我们称之为 mute_tf，你想禁用 TensorFlow 的忽略日志吗？很简单，这样做就行了！！

  from alfred.dl.tf.common import mute_tf
  mute_tf()
  import tensorflow as tf
  

  这样，日志信息就消失了……

• 2019-05-07: 添加了一些 proto 文件，现在你可以使用 alfred 解析 TensorFlow 的 COCO labelmap：

  from alfred.protos.labelmap_pb2 import LabelMap
  from google.protobuf import text_format
  
  with open('coco.prototxt', 'r') as f:
      lm = LabelMap()
      lm = text_format.Merge(str(f.read()), lm)
      names_list = [i.display_name for i in lm.item]
      print(names_list)
  

• 2019-04-25: 添加了 KITTI 融合功能，现在你可以将 3D 标签投影到图像上，就像这样： 我们还将添加更多融合工具，比如针对 nuScene 数据集的工具。

  我们提供 KITTI 融合功能，可以将 相机链接的 3D 点 转换为图像像素，也可以将 激光雷达链接的 3D 点 转换为图像像素。API 大致如下：

  # 将激光雷达预测转换为图像像素
  from alfred.fusion.kitti_fusion import LidarCamCalibData, \
      load_pc_from_file, lidar_pts_to_cam0_frame, lidar_pt_to_cam0_frame
  from alfred.fusion.common import draw_3d_box, compute_3d_box_lidar_coords
  
  # 包含激光雷达预测
  # 即 x,y,z,h,w,l,rotation_y
  res = [[4.481686, 5.147319, -1.0229858, 1.5728549, 3.646751, 1.5121397, 1.5486346],
         [-2.5172017, 5.0262384, -1.0679419, 1.6241353, 4.0445814, 1.4938312, 1.620804],
         [1.1783253, -2.9209857, -0.9852259, 1.5852798, 3.7360613, 1.4671413, 1.5811548]]
  
  for p in res:
      xyz = np.array([p[: 3]])
      c2d = lidar_pt_to_cam0_frame(xyz, frame_calib)
      if c2d is not None:
          cv2.circle(img, (int(c2d[0]), int(c2d[1])), 3, (0, 255, 255), -1)
      hwl = np.array([p[3: 6]])
      r_y = [p[6]]
      pts3d = compute_3d_box_lidar_coords(xyz, hwl, angles=r_y, origin=(0.5, 0.5, 0.5), axis=2)
  
      pts2d = []
      for pt in pts3d[0]:
          coords = lidar_pt_to_cam0_frame(pt, frame_calib)
          if coords is not None:
              pts2d.append(coords[:2])
      pts2d = np.array(pts2d)
      draw_3d_box(pts2d, img)
  

  你会看到类似这样的效果：

  注意：

  compute_3d_box_lidar_coords 用于激光雷达预测，而 compute_3d_box_cam_coords 则用于 KITTI 标签，因为 KITTI 标签是基于相机坐标的！。

  

  由于很多用户问我如何重现这个结果，你可以在 examples/draw_3d_box.py 中查看示例文件；

• 2019-01-25: 我们刚刚为 PyTorch 添加了一个网络可视化工具！！它看起来怎么样呢？只需打印出 每一层网络及其输出形状，我相信这对人们可视化自己的模型非常有帮助！

  ➜  mask_yolo3 git:(master) ✗ python3 tests.py
  ----------------------------------------------------------------
          Layer (type)               Output Shape         Param #
  ================================================================
              Conv2d-1         [-1, 64, 224, 224]           1,792
                ReLU-2         [-1, 64, 224, 224]               0
                .........
             Linear-35                 [-1, 4096]      16,781,312
               ReLU-36                 [-1, 4096]               0
            Dropout-37                 [-1, 4096]               0
             Linear-38                 [-1, 1000]       4,097,000
  ================================================================
  Total params: 138,357,544
  Trainable params: 138,357,544
  Non-trainable params: 0
  ----------------------------------------------------------------
  Input size (MB): 0.19
  Forward/backward pass size (MB): 218.59
  Params size (MB): 527.79
  Estimated Total Size (MB): 746.57
  ----------------------------------------------------------------
  

  好了，这就是全部内容。你只需要做的是：

  from alfred.dl.torch.model_summary import summary
  from alfred.dl.torch.common import device
  
  from torchvision.models import vgg16
  
  vgg = vgg16(pretrained=True)
  vgg.to(device)
  summary(vgg, input_size=[224, 224])
  

  支持输入 (224, 224) 的图像，你将会得到这样的输出，或者你可以改变其他尺寸来观察输出的变化。（目前不支持 1 通道图像）

• 2018-12-7: 现在，我们添加了一个可扩展的类，用于快速编写图像检测或分割的演示程序。

  如果你想编写一个演示程序，对一张图像、一段视频或直接从摄像头进行推理，现在你可以按照标准的 alfred 方式来做：

  class ENetDemo(ImageInferEngine):
  
      def __init__(self, f, model_path):
          super(ENetDemo, self).__init__(f=f)
  
          self.target_size = (512, 1024)
          self.model_path = model_path
          self.num_classes = 20
  
          self.image_transform = transforms.Compose(
              [transforms.Resize(self.target_size),
               transforms.ToTensor()])
  
          self._init_model()
  
      def _init_model(self):
          self.model = ENet(self.num_classes).to(device)
          checkpoint = torch.load(self.model_path)
          self.model.load_state_dict(checkpoint['state_dict'])
          print('Model loaded!')
  
      def solve_a_image(self, img):
          images = Variable(self.image_transform(Image.fromarray(img)).to(device).unsqueeze(0))
          predictions = self.model(images)
          _, predictions = torch.max(predictions.data, 1)
          prediction = predictions.cpu().numpy()[0] - 1
          return prediction
  
      def vis_result(self, img, net_out):
          mask_color = np.asarray(label_to_color_image(net_out, 'cityscapes'), dtype=np.uint8)
          frame = cv2.resize(img, (self.target_size[1], self.target_size[0]))
          # mask_color = cv2.resize(mask_color, (frame.shape[1], frame.shape[0]))
          res = cv2.addWeighted(frame, 0.5, mask_color, 0.7, 1)
          return res
  
  
  if __name__ == '__main__':
      v_f = ''
      enet_seg = ENetDemo(f=v_f, model_path='save/ENet_cityscapes_mine.pth')
      enet_seg.run()
  

  之后，你还可以直接从视频中进行推理。这种用法可以在 Git 仓库中找到：

  

  使用 **alfred** 的仓库：http://github.com/jinfagang/pt_enet

• 2018-11-6: 我很高兴地宣布 alfred 2.0 发布了！😄⛽️👏👏 让我们快速看一下有哪些更新：

  # 2 个新模块，fusio 和 vis
  from alred.fusion import fusion_utils
  

  其中 fusion 模块包含了许多有用的传感器融合辅助函数，比如可以将激光雷达点云投影到图像上。

• 2018-08-01: 修复了视频合并功能在处理序列时不够完善的问题。添加了一种排序算法，以确保视频序列正确。 同时还向软件包中添加了一些绘制边界框的函数。 可以这样调用：

• 2018-03-16: 对 alfred 进行了小幅更新，现在我们可以使用这个工具将一段视频序列重新组合成原始视频！ 只需简单操作：

  # alfred 二进制可执行程序
  alfred vision 2video -d ./video_images
  

功能强大

alfred 既是一个库，也是一个命令行工具。它可以完成以下任务：

# 从视频中提取图片
alfred vision extract -v video.mp4
# 将图像序列合并成视频
alfred vision 2video -d /path/to/images
# 从图片中提取人脸
alfred vision getface -d /path/contains/images/

快去试试吧！！

版权声明

Alfred 由 Lucas Jin 用 ❤️ 打造，欢迎点赞和提交 Pull Request。如有任何问题，可通过微信联系我：jintianiloveu。本项目采用 GPL-3 许可证发布。

Alfred-py 快速上手指南

Alfred-py 是一款专为深度学习设计的命令行工具与 Python 库。它提供了强大的可视化功能（支持 2D/3D 框、掩码、关键点）、数据集格式转换（YOLO/VOC/COCO 互转）、TensorRT 模型部署辅助以及日常开发效率工具。

环境准备

• 操作系统：推荐 Linux (Ubuntu)，Windows 用户需注意部分依赖的安装方式。
• Python 版本：Python 3.x
• 前置依赖（可选，按需安装）：
  • lxml
  • pycocotools (用于 COCO 格式处理)
  • opencv-python (用于图像视频处理)
  • Open3D (用于 3D 可视化，建议版本 >= 0.9.0)

注意：在 Windows 上安装 pycocotools 可能需要使用以下命令：

pip install "git+https://github.com/philferriere/cocoapi.git#egg=pycocotools&subdirectory=PythonAPI"

安装步骤

推荐使用国内镜像源加速安装（如阿里云）。

# 使用 pip 直接安装
sudo pip3 install alfred-py -i https://mirrors.aliyun.com/pypi/simple/

# 或者配置永久镜像源后安装
alfred cab changesource
sudo pip3 install alfred-py

安装完成后，你可以在终端直接使用 alfred 命令，或在 Python 代码中 import alfred。

基本使用

Alfred 既可作为命令行工具调用，也可作为 Python 库导入。

1. 命令行工具 (CLI)

查看帮助信息以了解所有可用模块：

alfred -h

常用场景示例：

• 查看标注数据 (支持 VOC, COCO, YOLO 等格式)：

  # 查看 VOC 格式标注
  alfred data vocview -i JPEGImages/ -l Annotations/
  
  # 查看 COCO 格式标注
  alfred data cocoview -j annotations/instance_2017.json -i images/
  
  # 查看 YOLO 格式标注
  alfred data yoloview -i images -l labels
  

• 数据集工具：

  # 统计特定类型文件数量
  alfred cab count -d ./images -t jpg
  
  # 将 txt 列表划分为训练集和验证集 (9:1)
  alfred cab split -f all.txt -r 0.9,0.1 -n train,val
  

• 视频处理：

  # 视频抽帧
  alfred vision extract -v video.mp4
  
  # 图片合成视频
  alfred vision 2video -d images/
  

2. Python API 调用

可视化关键点 (Pose Visualization)：

from alfred.vis.image.pose import vis_pose_result

# preds 为姿态预测结果，例如 COCO 格式 (Bs, 17, 3)
vis_pose_result(ori_image, preds, radius=5, thickness=2, show=True)

统一评估器 (Evaluation)：

from alfred.eval.yolo import YoloEvaluator

def infer_func(img_f):
    # 此处填写你的模型推理逻辑，返回检测结果
    # ...
    return results

if __name__ == '__main__':
    imgs_root = 'data/hand/images'
    labels_root = 'data/hand/labels'
    
    # 初始化评估器并运行
    yolo_parser = YoloEvaluator(imgs_root=imgs_root, labels_root=labels_root, infer_func=infer_func)
    yolo_parser.eval_precisely()

3D 可视化服务器 (基于 Open3D)：

from alfred.vis.mesh3d.o3dsocket import VisOpen3DSocket

def main():
    server = VisOpen3DSocket()
    while True:
        server.update()

if __name__ == "__main__":
    main()

(启动上述脚本后，可通过客户端发送 3D 关键点数据进行实时渲染)