pygame时间序列的三维预览

分享一个基于pygame的3D预览脚本，用于之前需要及时评估3D效果的数字人项目。基本的代码、原理都很简单，只是记录一下在使用pygame时用到的一些操作，以及关于三维物体到二维图形的映射方面的一些理解。

原理讲解

要想实现3D画面预览，就需要将三维空间中的物体进行投影变换，使其最终呈现在二维的屏幕上（也就是对于每个点 P(x, y, z)-->投影坐标 P'(x', y')）。一般我们使用透视投影来将三维空间中的点映射到屏幕上的二维坐标系中，从而呈现出符合人眼观察效果的立体感和深度感。当然在一些三维软件中还会提供平行视野，比如blender中的透视/正交(Perspective/Orthographic)，unity中的persp/ISO等等。平行视野虽然不符合直觉，但是对于判断比例和距离来说更有优势。

在透视投影中，视点（摄像机位置）和投影平面之间的距离被称为视距（viewing distance），通常用 d 表示。对于点 P(x, y, z)，它的投影坐标 P' (x', y') 可以通过以下公式计算得到：

x' = d * x / z y' = - d * y / z

其中，z 不应该等于 0，否则投影无效。

这里的实现步骤大致如下：

1. 根据视野角度和屏幕宽度来确定视距。
2. 定义需要投影的点的空间坐标的集合。
3. 对于每个点，首先将其从世界坐标系转换到相机坐标系。这可以通过将相机位置减去点的位置来实现。
4. 接着根据透视投影公式将点 P' 投影到屏幕上，得到最终的二维坐标 (x'', y'')：

x'' = x' + center_x y'' = y' + center_y

其中，center_x 和 center_y 是屏幕中心的坐标。（注意一下，pygame中的坐标原点(0, 0)在左上角，x轴水平方向向右，y轴垂直方向向 下，一般在DIP中默认的图像坐标都是这样的。）绘制点的投影就只需要使用 draw.circle() 函数就可以绘制圆形。

在这个过程中，还需要对摄像机位置和视角进行控制。通过控制摄像机位置，可以改变整个场景的观察角度和位置。通过控制视角，可以调整镜头的焦距和广角，进而影响到投影效果。由于我们使用的是透视投影，因此视角越大，投影距离就越近，物体看起来就越大。

代码介绍

网上这块代码也挺多的，我这里就贴一下我参考的代码《pygame教程实例（八）不用3D引擎也可以写3D画面》。作者是以一个静态的正方体（其边由若干离散的球体拼接而成）以及几个位置随机生成的球体为三维场景进行预览的，代码并不复杂，功能和对应的注释基本都有，还是挺直观的。

import pygame,os
from pygame.locals import *
from pygame.math import *
from math import *
from random import randint

# 窗口大小
SCREEN_SIZE = (840, 680)
# 正方体边长
CUBE_SIZE = 300

# pygame 初始化
pygame.init()
os.environ['SDL_VIDEO_WINDOW_POS'] = "%d,%d" % (10,10)
screen = pygame.display.set_mode(SCREEN_SIZE, 0)
font = pygame.font.SysFont('simhei', 24)
clock = pygame.time.Clock()

# 让pygame完全控制鼠标
pygame.mouse.set_visible(False)
pygame.event.set_grab(True)
# 3D points（所有的小球都在这）
points = []
fov = 90.  # 视野
rov = 5
mov = 90
FPS = 60
is_grab = True

def calculate_viewing_distance(fov, screen_width):
    d = (screen_width / 2.0) / tan(fov / 2.0)
    return d

def set_points():
    # 边沿的一系列点
    for x in range(0-20*5, CUBE_SIZE + 1 + 20*5, 20):
        edge_x = x == 0 or x == CUBE_SIZE

        for y in range(0-20*5, CUBE_SIZE + 1 + 20*5, 20):
            edge_y = y == 0 or y == CUBE_SIZE

            for z in range(0-20*5, CUBE_SIZE + 1 + 20*5, 20):
                edge_z = z == 0 or z == CUBE_SIZE

                if sum((edge_x, edge_y, edge_z)) >= 2:
                    point_x = float(x) - CUBE_SIZE / 2
                    point_y = float(y) - CUBE_SIZE / 2
                    point_z = float(z) - CUBE_SIZE / 2

                    points.append(Vector3(point_x, point_y, point_z))
    # 随机给一些点
    for i in range(10):
        point_x = randint(0-CUBE_SIZE, CUBE_SIZE + 1 + CUBE_SIZE)
        point_y = randint(0-CUBE_SIZE, CUBE_SIZE + 1 + CUBE_SIZE)
        point_z = randint(0-CUBE_SIZE, CUBE_SIZE + 1 + CUBE_SIZE)
        points.append(Vector3(point_x, point_y, point_z))
    points.sort(key=lambda p:p.z, reverse=True)

def move_points(dv):
    for p in points:
        p.update(p + dv)
    points.sort(key=lambda p:p.z, reverse=True)

def rotate_points(p_float,v):
    for p in points:
        p.update(p.rotate(p_float,v))
    points.sort(key=lambda p:p.z, reverse=True)

def run():
    global fov, is_grab
    # 视距
    viewing_distance = calculate_viewing_distance(radians(fov), SCREEN_SIZE[0])

    set_points()

    center_x, center_y = SCREEN_SIZE
    center_x /= 2
    center_y /= 2

    ball_w, ball_h = 50, 50
    ball_center_x = ball_w / 2
    ball_center_y = ball_h / 2

    camera_position = Vector3(0.0, 0.0, 0.0)  # 摄像机位置
    # camera_speed = Vector3(30.0, 30.0, 30.0)  # 摄像机速度

    while True:
        for event in pygame.event.get():
            if event.type == QUIT:
                return
            # 按Esc则退出游戏
            if event.type == KEYDOWN:
                if event.key == K_ESCAPE:
                    exit()
        screen.fill((0, 0, 0))
        pressed_keys = pygame.key.get_pressed()
        # pressed_mouse = pygame.mouse.get_pressed()
        # movement_direction = 0.  # 鼠标偏移量
        if is_grab:
            mouse_rel = pygame.mouse.get_rel()
            drx = mouse_rel[0] * 2 * rov
            dry = mouse_rel[1] * 2 * rov
        else:
            drx, dry = 0, 0
        dx, dy, dz = 0.0,0.0,0.0

        # 旋转
        ## 绕y轴旋转
        rotate_points(drx * 1/FPS,Vector3(0.0,-1.0,0.0))
        ## 绕x轴旋转
        rotate_points(dry * 1/FPS,Vector3(-1.0,0.0,0.0))

        if pressed_keys[K_a]:
            dx = +mov * 1/FPS
        elif pressed_keys[K_d]:
            dx = -mov * 1/FPS

        if pressed_keys[K_w]:
            dz = -mov * 1/FPS
        elif pressed_keys[K_s]:
            dz = +mov * 1/FPS

        if pressed_keys[K_SPACE]:
            dy = -mov * 1/FPS
        elif pressed_keys[K_LCTRL]:
            dy = +mov * 1/FPS

        if pressed_keys[K_BACKQUOTE] and is_grab:
            pygame.mouse.set_visible(True)
            pygame.event.set_grab(False)
            is_grab = False
        elif pressed_keys[K_BACKQUOTE]:
            pygame.mouse.set_visible(False)
            pygame.event.set_grab(True)
            is_grab = True


        if pressed_keys[K_o]:
            fov = min(179., fov + 1.)
            w = SCREEN_SIZE[0]
            viewing_distance = calculate_viewing_distance(radians(fov), w)
        elif pressed_keys[K_l]:
            fov = max(1., fov - 1.)
            w = SCREEN_SIZE[0]
            viewing_distance = calculate_viewing_distance(radians(fov), w)

        move_points(Vector3(dx,dy,dz))

        # 绘制点
        for point in points:
            x, y, z = point - camera_position
            if z > 0:
                x = x * viewing_distance / z
                y = -y * viewing_distance / z
                x += center_x
                y += center_y
                bw = min(100/point.magnitude()*ball_w,center_x)
                # screen.blit(ball, (x - ball_center_x, y - ball_center_y))
                pygame.draw.circle(
                    screen,
                    (255, 0, 0),
                    (int(x - ball_center_x), int(y - ball_center_y)),
                    int(bw)
                )

        # 绘制表
        diagram_width = SCREEN_SIZE[0] / 4
        col = (50, 255, 50)
        diagram_points = []
        diagram_points.append((diagram_width / 2, 100 + viewing_distance / 4))
        diagram_points.append((0, 100))
        diagram_points.append((diagram_width, 100))
        diagram_points.append((diagram_width / 2, 100 + viewing_distance / 4))
        diagram_points.append((diagram_width / 2, 100))
        pygame.draw.lines(screen, col, False, diagram_points, 2)

        # 绘制文字
        white = (255, 255, 255)
        cam_text = font.render("摄像机 = " + str(camera_position), True, white)
        screen.blit(cam_text, (5, 5))
        fov_text = font.render("视野 = %i" % int(fov), True, white)
        screen.blit(fov_text, (5, 35))
        txt = "视距 = %.3f" % viewing_distance
        d_text = font.render(txt, True, white)
        screen.blit(d_text, (5, 65))

        pygame.display.update()
        time_passed = clock.tick(FPS)

if __name__ == "__main__":
    run()

这段代码在三维预览上的主要逻辑就是确定视距-->输入相机移动和视角变化-->更新点-->依次绘制。

首先通过calculate_viewing_distance函数，根据视野角度和屏幕宽度计算视距，用于将3D点转换为2D屏幕坐标。随后，利用pygame.key.get_pressed监听键盘输入，控制相机的空间移动和视距变化，利用pygame.mouse.get_rel()监听鼠标在x轴和y轴上的移动，控制视角移动，并分别在move_points函数和rotate_points函数中对储存的点的坐标位置进行更新。最后遍历所有的点，根据摄像机位置和视距将3D点转换为屏幕坐标。根据点的z值决定绘制的球体的大小，并在屏幕上绘制球体。

为了方便观察，作者将鼠标设置为不可见，并且将鼠标事件设置为捕获模式，以便完全控制鼠标。同时还在视图左上角绘制出了摄像机的位置、视野角度和视距数值的信息。

时间序列的三维预览

不过上面的代码离我期望的效果还有点距离，最大的问题就在于原代码中使用的都是静态物体，而我需要对移动的物体进行展示。由于我不是动画那种关键帧的方式进行连续的移动，而是将30帧记录的若干空间数据在重新在每一帧中“展现”，所以实际上这是对离散的物体进行连续的投影变换。

分析到这其实就已经知道需要修改的地方在哪里了，也就是鼠标旋转和相机移动需要从原先每帧分别计算一次改为累计数值再计算。 在代码中记录旋转分量的drx和dry后加上一个drx_a+=drx dry_a+=dry，并以drx_a和dry_a替换原先的值；相机移动的三轴分量也进行相同的操作，用dxa+=dx, dya+=dy, dza+=dz进行替换就可以了。

这里还要注意一下，原代码中的rotate_points和move_points函数是会根据z轴大小重新排序的。这在原本的物体中是没什么问题的，但是在我的项目中，点之间是有一定的连接顺序，那么排序后就会影响原先的排列位置，虽然也可以在坐标中加入次序，再在检索顺序后绘制图像，但是感觉有点太麻烦了我就直接把函数的排序去了（如果需要更好的视觉效果那还是需要改一下的，不然点之间可能会有不正确的遮挡，我这里点的颜色都是一致的就不管了）。

不过为了方便看出数字人骨骼在空间位置的变换，我还写了一个基准坐标轴，用的还是原先的数值和函数，并且采用了上面说的方法，在每点坐标里加入了次序。不过似乎由于坐标轴和人体的中心点不同，导致其移动的同时进行旋转操作会出现严重错位的现象，明明都是按照世界坐标来的，没太弄清楚是怎么回事就先注释了。

另外，我加入了一个循环播放和鼠标左键点击暂停的功能，其实就是读完文件中的数据后重新读取，暂停就是不读取下一行数据、重复读取当前行数据就可以了。其他地方就是数字人骨骼及连线绘制与主题没啥关系就不讲了。

import copy
import pygame,os
from pygame.locals import *
from pygame.math import *
from math import *
import csv
import numpy as np
from random import randint

# 窗口大小
width=1080
height=720
SCREEN_SIZE = (width, height)
# 正方体边长
CUBE_SIZE = 300

# pygame 初始化
pygame.init()
os.environ['SDL_VIDEO_WINDOW_POS'] = "%d,%d" % (10,10)
screen = pygame.display.set_mode(SCREEN_SIZE, 0)
surface1 = pygame.Surface((width,height), pygame.SRCALPHA)
surface2 = pygame.Surface((width,height), pygame.SRCALPHA)
font = pygame.font.SysFont('simhei', 24)
clock = pygame.time.Clock()

# 让pygame完全控制鼠标
pygame.mouse.set_visible(False)
pygame.event.set_grab(True)
# 3D points（所有的小球都在这）
points = []
fov = 90.  # 视野
rov = 5
mov = 90
FPS = 30
is_grab = True
rot_coef_x = 0.2
rot_coef_y = 0.2

WHITE = (255, 255, 255)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
BLACK = (0, 0, 0)

# filename = "./data/average_skeleton_data.csv"  # 替换为你的CSV文件路径
# filename = "./data/average_realign.csv"
filename = "./Align/average.csv"
bone_connections = [
    (3, 2),
    (2, 20),
    (20, 1),
    (1, 0),
    (20, 8),
    (20, 4),
    (8, 9),
    (9, 10),
    (10, 11),
    (10, 24),
    (11, 23),
    (23, 24),
    (4, 5),
    (5, 6),
    (6, 7),
    (6, 22),
    (7, 21),
    (21, 22),
    (0, 16),
    (0, 12),
    (16, 17),
    (17, 18),
    (18, 19),
    (12, 13),
    (13, 14),
    (14, 15)
]

def get_last_body(row):
    joint_positions = []

    data = row.split(',')[1:]
    body_joint_positions = {}
    lenforData = len(data)/3
    for i in range(lenforData):
        x, y, z = data[i],data[lenforData+i],data[lenforData*2+i]
        body_joint_positions[i] = (x, y, z)
    joint_positions.append(body_joint_positions)

    return joint_positions


def calculate_viewing_distance(fov, screen_width):
    d = (screen_width / 2.0) / tan(fov / 2.0)
    return d

def move_points(dv):
    for p in points:
        p[0].update(p[0] + dv)
    points.sort(key=lambda p:p[0].z, reverse=True)

def rotate_points(angle, axis):
    for p in points:
        p[0].update(p[0].rotate(angle, axis))
    points.sort(key=lambda p:p[0].z, reverse=True)

def move_points_nosort(dv,arr):
    for p in arr:
        p.update(p + dv)

def rotate_points_nosort(angle, axis,arr):
    for p in arr:
        p.update(p.rotate(angle, axis))

def point_3d(x,y,z,viewing_distance,center_x,center_y,point,camera_position):
    x = x * viewing_distance / z
    y = -y * viewing_distance / z
    x += center_x
    y += center_y
    bw = min(8 / (point - camera_position).magnitude() * 4, center_x)
    return x-4, y-4, bw

def run():
    global fov, is_grab,joints
    # 视距
    viewing_distance = calculate_viewing_distance(radians(fov), SCREEN_SIZE[0])

    # set_points()
    points.append([Vector3(0, -2, 0),0])
    points.append([Vector3(5, -2, 0),1])
    points.append([Vector3(0, 3, 0),2])
    points.append([Vector3(0, -2, 5),3])

    center_x, center_y = SCREEN_SIZE
    center_x /= 2
    center_y /= 2

    ball_w, ball_h = 4, 4
    ball_center_x = ball_w / 2
    ball_center_y = ball_h / 2

    cal_arr = [Vector3(-1,0,-1),Vector3(-1,0,1),Vector3(1,0,1),Vector3(1,0,-1)]

    ifStop = False
    drx_a,dry_a = 0,0
    dxa,dya,dza = 0,0,0
    camera_position = Vector3(0.0, 0.0, -5.0)  # 摄像机位置
    # camera_speed = Vector3(30.0, 30.0, 30.0)  # 摄像机速度
    with open(filename, 'r') as file:
        reader = csv.reader(file)
        next_row = next(reader)
        offset = 0
        times = 5
        row = next_row

        while True:
            try:
                if not ifStop:
                    row = next(reader)
                    joint = [float(x) for x in row[:]]
            except:
                reader = csv.reader(open(filename, "r"))
                row = next(reader)
                ifStop = True
                continue

            for event in pygame.event.get():
                if event.type == QUIT:
                    return
                # 按Esc则退出游戏
                if event.type == KEYDOWN:
                    if event.key == K_ESCAPE:
                        exit()
                if event.type == pygame.MOUSEBUTTONDOWN:
                    ifStop = not ifStop

            screen.fill((10, 10, 10))
            surface1.fill((10, 10, 10, 120))
            surface2.fill((10, 10, 10, 120))

            pressed_keys = pygame.key.get_pressed()
            # pressed_mouse = pygame.mouse.get_pressed()
            # movement_direction = 0.  # 鼠标偏移量
            drx, dry = 0, 0
            if is_grab:
                mouse_rel = pygame.mouse.get_rel()
                drx = mouse_rel[0] * rot_coef_x * rov
                dry = mouse_rel[1] * rot_coef_y * rov
            drx_a+=drx
            dry_a+=dry
            dx, dy, dz = 0.0,0.0,0.0

            length = len(joint)
            joints = []
            for i in range(0, length, 3):
                x=(joint[i] * times + offset)
                y=(joint[i + 1] * times + offset)
                z= (joint[i + 2] * times + offset) - 8

                pos = Vector3(x,y,z)
                pos.rotate(drx * 1 / FPS, Vector3(0.0, -1.0, 0.0))
                pos.rotate(dry * 1 / FPS, Vector3(-1.0, 0.0, 0.0))
                pos+=Vector3(dx/20,dy/20,dz/20)

                joints.append(pos)

            ground1 = []
            ground2 = []
            for r in cal_arr:
                ground1.append(joints[19]+r)
                ground2.append(joints[15]+r)
            # 绕y轴旋转
            rotate_points(drx * 1 / FPS, Vector3(0.0, -1.0, 0.0))
            # 绕x轴旋转
            rotate_points(dry * 1 / FPS, Vector3(-1.0, 0.0, 0.0))

            rotate_points_nosort(drx_a * 1 / FPS, Vector3(0.0, -1.0, 0.0), joints)
            rotate_points_nosort(dry_a * 1 / FPS, Vector3(-1.0, 0.0, 0.0), joints)
            rotate_points_nosort(drx_a * 1 / FPS, Vector3(0.0, -1.0, 0.0), ground1)
            rotate_points_nosort(dry_a * 1 / FPS, Vector3(-1.0, 0.0, 0.0), ground1)
            rotate_points_nosort(drx_a * 1 / FPS, Vector3(0.0, -1.0, 0.0), ground2)
            rotate_points_nosort(dry_a * 1 / FPS, Vector3(-1.0, 0.0, 0.0), ground2)

            if pressed_keys[K_a]:
                dx = +mov * 1/FPS
            elif pressed_keys[K_d]:
                dx = -mov * 1/FPS

            if pressed_keys[K_w]:
                dz = -mov * 1/FPS
            elif pressed_keys[K_s]:
                dz = +mov * 1/FPS

            if pressed_keys[K_SPACE]:
                dy = -mov * 1/FPS
            elif pressed_keys[K_LCTRL]:
                dy = +mov * 1/FPS

            if pressed_keys[K_BACKQUOTE] and is_grab:
                pygame.mouse.set_visible(True)
                pygame.event.set_grab(False)
                is_grab = False
            elif pressed_keys[K_BACKQUOTE]:
                pygame.mouse.set_visible(False)
                pygame.event.set_grab(True)
                is_grab = True

            # if pressed_keys[K_o]:
            #     fov = min(179., fov + 1.)
            #     w = SCREEN_SIZE[0]
            #     viewing_distance = calculate_viewing_distance(radians(fov), w)
            # elif pressed_keys[K_l]:
            #     fov = max(1., fov - 1.)
            #     w = SCREEN_SIZE[0]
            #     viewing_distance = calculate_viewing_distance(radians(fov), w)
            dxa+=dx
            dya+=dy
            dza+=dz

            move_points(Vector3(dx/20,dy/20,dz/20))

            move_points_nosort(Vector3(dxa / 20, dya / 20, dza / 20), joints)
            move_points_nosort(Vector3(dxa / 20, dya / 20, dza / 20), ground1)
            move_points_nosort(Vector3(dxa / 20, dya / 20, dza / 20), ground2)

            # 基准坐标轴
            # tmp=[]
            # for point in points:
            #     x, y, z = point[0] - camera_position
            #     x = x * viewing_distance / z
            #     y = -y * viewing_distance / z
            #     x += center_x
            #     y += center_y
            #     bw = min(8 / (point[0] - camera_position).magnitude() * ball_w, center_x)
            #     if z > 0:
            #         pygame.draw.circle(
            #             screen,
            #             (255, 0, 0),
            #             (int(x - ball_center_x), int(y - ball_center_y)),
            #             int(bw)
            #         )
            #     tmp.append([point[1],(x,y,z)])
            #
            # tmp = sorted(tmp, key=lambda x: x[0])
            # origin = int(tmp[0][1][0]- ball_center_x),int(tmp[0][1][1] - ball_center_y)
            # pygame.draw.line(screen, (255, 0, 0), origin,
            #                  (int(tmp[1][1][0]- ball_center_x),int(tmp[1][1][1] - ball_center_y)), 2)
            # pygame.draw.line(screen, (0, 255, 0), origin,
            #                  (int(tmp[2][1][0] - ball_center_x), int(tmp[2][1][1] - ball_center_y)), 2)
            # pygame.draw.line(screen, (0, 0, 255), origin,
            #                  (int(tmp[3][1][0] - ball_center_x), int(tmp[3][1][1] - ball_center_y)), 2)

            g1 = []
            for g in ground1:
                x,y,z = g-camera_position
                x = x * viewing_distance / z
                y = -y * viewing_distance / z
                x += center_x
                y += center_y
                g1.append([x,y])
            pygame.draw.polygon(surface1, (240, 220, 240, 180), g1)

            g2 = []
            for g in ground2:
                x,y,z = g-camera_position
                x = x * viewing_distance / z
                y = -y * viewing_distance / z
                x += center_x
                y += center_y
                g2.append([x,y])
            pygame.draw.polygon(surface2, (220, 240, 220, 180), g2)

            screen.blit(surface1, (0, 0))
            screen.blit(surface2, (0, 0))

            for j in joints:
                x, y, z = j - camera_position
                if z > 0:
                    x = x * viewing_distance / z
                    y = -y * viewing_distance / z
                    x += center_x
                    y += center_y
                    bw = min(8 / (j - camera_position).magnitude() * ball_w, center_x)
                    pygame.draw.circle(
                        screen,
                        GREEN,
                        (int(x - ball_center_x), int(y - ball_center_y)),
                        int(bw)
                    )

            for connection in bone_connections:
                joint1=(joints[connection[0]])
                joint2=(joints[connection[1]])
                x1,y1,z1 = joint1- camera_position
                x2,y2,z2 = joint2- camera_position
                x1 = x1 * viewing_distance / z1
                y1 = -y1 * viewing_distance / z1
                x2 = x2 * viewing_distance / z2
                y2 = -y2 * viewing_distance / z2
                x1 += center_x
                y1 += center_y
                x2 += center_x
                y2 += center_y
                pygame.draw.line(screen, GREEN, (int(x1- ball_center_x),int(y1- ball_center_y)), (int(x2- ball_center_x),int(y2- ball_center_y)), 2)

            pygame.display.update()
            time_passed = clock.tick(FPS)

if __name__ == "__main__":
    run()

最后结果大概是这样的：

还算可以吧，比起需要导入blender或者ue再看骨架来说简单太多，能够及时评判数据的有效性就足够了（现在数据还有一大堆毛病，数据融合角度变换等等等等就不谈了，之后得找时间重新多录几次更完整复杂的数据才行）。