Skip to content

Polyscope学习笔记

1 polyscope常用可视化

1.1 可视化mesh

import igl
import polyscope as ps
import numpy as np

v,f = igl.read_triangle_mesh("assets/bunny.obj")

ps.init()
ps.register_surface_mesh("mesh", v,f,
                         color=np.array([0, 91, 255]) / 255,
                         edge_width=0.3,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

# ps.set_build_gui(False)  
ps.set_window_size(1200,800)
ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 设置地平面高度
ps.set_shadow_blur_iters(3)  # 设置地平面阴影模糊程度
ps.set_shadow_darkness(0.5)  # 设置地平面阴影明暗程度
ps.set_up_dir("y_up")  # 设置y轴正方向向上(这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉)
ps.set_front_dir('z_front')  # 设置z轴正方向向前
ps.set_SSAA_factor(4) # 在截图时,设置为4时,截图会更清晰
ps.show()

1.2 可视化点云

import polyscope as ps
import numpy as np

points = np.loadtxt("assets/bunny.txt")

ps.init()
ps.register_point_cloud("points", points,
                        color=np.array([0, 91, 255]) / 255,
                        radius=0.003)

# ps.set_build_gui(False)  
ps.set_window_size(1200,800)
ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 设置地平面高度
ps.set_shadow_blur_iters(3)  # 设置地平面阴影模糊程度
ps.set_shadow_darkness(0.5)  # 设置地平面阴影明暗程度
ps.set_up_dir("y_up")  # 设置y轴正方向向上(这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉)
ps.set_front_dir('z_front')  # 设置z轴正方向向前
ps.set_SSAA_factor(4) # 在截图时,设置为4时,截图会更清晰
ps.show()

1.3 可视化线框

import igl
import polyscope as ps
import numpy as np

v,f = igl.read_triangle_mesh("assets/bunny.obj")

e = igl.edges(f)

# 获得节点 和 连接关系
nodes = v[e].reshape(-1, 3)
edges = np.arange(nodes.shape[0]).reshape(-1, 2)

ps.init()
ps.register_surface_mesh("mesh", v,f,
                         color=np.array([0, 91, 255]) / 255,
                         edge_width=0.0003,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

ps.register_curve_network("wireframe", nodes, edges,
                          color=[1, 1, 1],
                          radius=0.001
                          )

# ps.set_build_gui(False)  
ps.set_window_size(1200,800)
ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 设置地平面高度
ps.set_shadow_blur_iters(3)  # 设置地平面阴影模糊程度
ps.set_shadow_darkness(0.5)  # 设置地平面阴影明暗程度
ps.set_up_dir("y_up")  # 设置y轴正方向向上(这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉)
ps.set_front_dir('z_front')  # 设置z轴正方向向前
ps.set_SSAA_factor(4) # 在截图时,设置为4时,截图会更清晰
ps.show()
mesh+wireframe wireframe

2 polyscope颜色设置

2.1 调亮颜色

蓝色[0, 91/255, 255/ 255]   
黄色[255/ 255, 164/ 255, 0]   
粉红色[255/ 255, 0, 218/ 255]   
青色[0, 255/ 255, 37/ 255]  
紫色[100/ 255, 0, 255/ 255] 
草黄[155/ 255, 255/ 255, 0] 
红色[255/ 255, 0, 27/ 255] 
玉色[0, 255/ 255, 228/ 255] 
深蓝[5/ 255, 0, 255/ 255]
亮黄[255/ 255, 255/ 255, 0] 

2.2 默认10种颜色

如果不设置颜色,使用的就是默认颜色,默认的颜色有一点暗

import igl
import numpy as np
import polyscope as ps

v, f = igl.read_triangle_mesh("assets/dress2.obj")

ps.init()
ps.register_surface_mesh("mesh1", v, f,
                         # color=np.array([0, 91, 255]) / 255,
                         smooth_shade=True)
ps.register_surface_mesh("mesh2", v + np.array([1000, 0, 0]), f,
                         # color=np.array([255,164,0] ) /255,
                         smooth_shade=True)
ps.register_surface_mesh("mesh3", v + np.array([2000, 0, 0]), f,
                         # color=np.array([255, 0, 218]) / 255,
                         smooth_shade=True)
ps.register_surface_mesh("mesh4", v + np.array([3000, 0, 0]), f,
                         # color=np.array([0, 255, 37]) / 255,
                         smooth_shade=True)
ps.register_surface_mesh("mesh5", v + np.array([4000, 0, 0]), f,
                         # color=np.array([100, 0, 255]) / 255,
                         smooth_shade=True)
ps.register_surface_mesh("mesh6", v + np.array([5000, 0, 0]), f,
                         # color=np.array([155, 255, 0]) / 255,
                         smooth_shade=True)
ps.register_surface_mesh("mesh7", v + np.array([6000, 0, 0]), f,
                         # color=np.array([255, 0, 27]) / 255,
                         smooth_shade=True)
ps.register_surface_mesh("mesh8", v + np.array([7000, 0, 0]), f,
                         # color=np.array([0, 255, 228]) / 255,
                         smooth_shade=True)
ps.register_surface_mesh("mesh9", v + np.array([8000, 0, 0]), f,
                         # color=np.array([5, 0, 255]) / 255,
                         smooth_shade=True)
ps.register_surface_mesh("mesh10", v + np.array([9000, 0, 0]), f,
                         # color=np.array([255, 255, 0]) / 255,
                         smooth_shade=True)

ps.set_ground_plane_mode("shadow_only")
# ps.set_navigation_style("planar")
ps.set_up_dir("y_up")
ps.set_view_projection_mode("orthographic")  # orthographic 正交投影   perspective 透视投影
ps.set_SSAA_factor(4)
ps.show()

2.3 调亮10种颜色

import igl
import numpy as np
import polyscope as ps

v, f = igl.read_triangle_mesh("assets/dress2.obj")

# 调亮
# 蓝色 [0,91,255] / 255# 黄色 [255,164,0] / 255# 粉红色 [255,0, 218 ] / 255# 青色 [0,255,37] / 255# 紫色 [100, 0, 255]/ 255# 草黄 [155,255,0] / 255# 红色 [255,0,27] / 255# 玉色 [0,255,228] / 255# 深蓝 [5,0,255] / 255# 亮黄 [255,255,0] / 255

ps.init()
ps.register_surface_mesh("mesh1", v, f,
                         color=np.array([0, 91, 255]) / 255,
                         smooth_shade=True)
ps.register_surface_mesh("mesh2", v + np.array([1000, 0, 0]), f,
                         color=np.array([255, 164, 0]) / 255,
                         smooth_shade=True)
ps.register_surface_mesh("mesh3", v + np.array([2000, 0, 0]), f,
                         color=np.array([255, 0, 218]) / 255,
                         smooth_shade=True)
ps.register_surface_mesh("mesh4", v + np.array([3000, 0, 0]), f,
                         color=np.array([0, 255, 37]) / 255,
                         smooth_shade=True)
ps.register_surface_mesh("mesh5", v + np.array([4000, 0, 0]), f,
                         color=np.array([100, 0, 255]) / 255,
                         smooth_shade=True)
ps.register_surface_mesh("mesh6", v + np.array([5000, 0, 0]), f,
                         color=np.array([155, 255, 0]) / 255,
                         smooth_shade=True)
ps.register_surface_mesh("mesh7", v + np.array([6000, 0, 0]), f,
                         color=np.array([255, 0, 27]) / 255,
                         smooth_shade=True)
ps.register_surface_mesh("mesh8", v + np.array([7000, 0, 0]), f,
                         color=np.array([0, 255, 228]) / 255,
                         smooth_shade=True)
ps.register_surface_mesh("mesh9", v + np.array([8000, 0, 0]), f,
                         color=np.array([5, 0, 255]) / 255,
                         smooth_shade=True)
ps.register_surface_mesh("mesh10", v + np.array([9000, 0, 0]), f,
                         color=np.array([255, 255, 0]) / 255,
                         smooth_shade=True)

ps.set_ground_plane_mode("shadow_only")
# ps.set_navigation_style("planar")
ps.set_up_dir("y_up")
ps.set_view_projection_mode("orthographic")  # orthographic 正交投影   perspective 透视投影
ps.set_SSAA_factor(4)
ps.show()

3 读写mesh

3.1 python读写mesh

import polyscope as ps
import numpy as np
import os

def read_obj(file_path):
    vertices = []
    faces = []

    with open(file_path, 'r') as f:
        for line in f:
            line = line.strip()
            if line.startswith('v '):  # 顶点
                parts = line.split()
                vertices.append([float(x) for x in parts[1:4]])
            elif line.startswith('f '):  # 面
                parts = line.split()
                face = []
                for item in parts[1:]:
                    # 取第一个数字(顶点索引),并转换为0-based索引
                    idx = int(item.split('/')[0])
                    # OBJ文件索引从1开始,转换为0-based
                    if idx > 0:
                        face.append(idx - 1)  # 正索引减1
                    else:
                        # 处理负数索引(相对于末尾)
                        face.append(len(vertices) + idx)
                faces.append(face)

    return np.array(vertices),np.array(faces)


def save_obj(filename, vertices, faces):
    os.makedirs(os.path.dirname(filename), exist_ok=True)

    with open(filename, 'w') as fp:
        for v in vertices:
            fp.write('v %f %f %f\n' % (v[0], v[1], v[2]))

        for f in (faces + 1):  # Faces are 1-based, not 0-based in obj files
            fp.write('f %d %d %d\n' % (f[0], f[1], f[2]))

    print("Saved:", filename)


# 读取mesh
v,f = read_obj("assets/bunny.obj")

# 可视化mesh
ps.init()
ps.register_surface_mesh("mesh", v,f,
                         color=np.array([0, 91, 255]) / 255,
                         edge_width=0.3,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 设置地平面高度
ps.set_shadow_blur_iters(3)  # 设置地平面阴影模糊程度
ps.set_shadow_darkness(0.5)  # 设置地平面阴影明暗程度
ps.set_up_dir("y_up")  # 设置y轴正方向向上(这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉)
ps.set_front_dir('z_front')  # 设置z轴正方向向前
ps.set_SSAA_factor(4) # 在截图时,设置为4时,截图会更清晰
ps.show()

# 写入mesh
save_obj("assets/new_bunny_python.obj",v,f)

3.2 libigl读写mesh

import igl
import polyscope as ps
import numpy as np

# 读取mesh
v, f = igl.read_triangle_mesh("assets/bunny.obj")

# 可视化mesh
ps.init()
ps.register_surface_mesh("mesh", v, f,
                         color=np.array([0, 91, 255]) / 255,
                         edge_width=0.3,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 设置地平面高度
ps.set_shadow_blur_iters(3)  # 设置地平面阴影模糊程度
ps.set_shadow_darkness(0.5)  # 设置地平面阴影明暗程度
ps.set_up_dir("y_up")  # 设置y轴正方向向上(这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉)
ps.set_front_dir('z_front')  # 设置z轴正方向向前
ps.set_SSAA_factor(4) # 在截图时,设置为4时,截图会更清晰
ps.show()

# 写入mesh
igl.write_triangle_mesh("assets/new_bunny_igl.obj", v, f)

3.3 trimesh读写mesh

import trimesh
import polyscope as ps
import numpy as np

# 读取mesh
mesh = trimesh.load("assets/bunny.obj")
v = mesh.vertices
f = mesh.faces

# 可视化mesh
ps.init()
ps.register_surface_mesh("mesh", v,f,
                         color=np.array([0, 91, 255]) / 255,
                         edge_width=0.3,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 设置地平面高度
ps.set_shadow_blur_iters(3)  # 设置地平面阴影模糊程度
ps.set_shadow_darkness(0.5)  # 设置地平面阴影明暗程度
ps.set_up_dir("y_up")  # 设置y轴正方向向上(这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉)
ps.set_front_dir('z_front')  # 设置z轴正方向向前
ps.set_SSAA_factor(4) # 在截图时,设置为4时,截图会更清晰
ps.show()

# 写入mesh
mesh.export("assets/new_bunny_trimesh.obj")

3.4 openmesh读写mesh

import openmesh as om
import polyscope as ps
import numpy as np

# 读取mesh
mesh = om.read_trimesh('assets/bunny.obj')
v = mesh.points()
f = mesh.face_vertex_indices()

# 可视化mesh
ps.init()
ps.register_surface_mesh("mesh", v,f,
                         color=np.array([0, 91, 255]) / 255,
                         edge_width=0.3,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 设置地平面高度
ps.set_shadow_blur_iters(3)  # 设置地平面阴影模糊程度
ps.set_shadow_darkness(0.5)  # 设置地平面阴影明暗程度
ps.set_up_dir("y_up")  # 设置y轴正方向向上(这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉)
ps.set_front_dir('z_front')  # 设置z轴正方向向前
ps.set_SSAA_factor(4) # 在截图时,设置为4时,截图会更清晰
ps.show()

# 写入mesh
om.write_mesh("assets/new_bunny_openmesh.obj", mesh)

3.5 pymeshlab读写mesh

import pymeshlab
import polyscope as ps
import numpy as np

# 读取mesh
ms = pymeshlab.MeshSet()
ms.load_new_mesh("assets/bunny.obj")

# 可视化方法1(pymeshlab已经集成了polyscope)
# ms.show_polyscope()


# 可视化方法2
mesh = ms.current_mesh()
v = mesh.vertex_matrix()
f = mesh.face_matrix()

ps.init()
ps.register_surface_mesh("mesh", v, f,
                         color=np.array([0, 91, 255]) / 255,
                         edge_width=0.3,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 设置地平面高度
ps.set_shadow_blur_iters(3)  # 设置地平面阴影模糊程度
ps.set_shadow_darkness(0.5)  # 设置地平面阴影明暗程度
ps.set_up_dir("y_up")  # 设置y轴正方向向上(这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉)
ps.set_front_dir('z_front')  # 设置z轴正方向向前
ps.set_SSAA_factor(4) # 在截图时,设置为4时,截图会更清晰
ps.show()

# 写入mesh
ms.save_current_mesh("assets/new_bunny_pymeshlab.obj") # 不知道为什么会报错

3.6 gpytoolbox读写mesh

import gpytoolbox as gpy
import polyscope as ps
import numpy as np

# 读取mesh
v,f = gpy.read_mesh("assets/bunny.obj")

# 可视化mesh
ps.init()
ps.register_surface_mesh("mesh", v,f,
                         color=np.array([0, 91, 255]) / 255,
                         edge_width=0.3,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 设置地平面高度
ps.set_shadow_blur_iters(3)  # 设置地平面阴影模糊程度
ps.set_shadow_darkness(0.5)  # 设置地平面阴影明暗程度
ps.set_up_dir("y_up")  # 设置y轴正方向向上(这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉)
ps.set_front_dir('z_front')  # 设置z轴正方向向前
ps.set_SSAA_factor(4) # 在截图时,设置为4时,截图会更清晰
ps.show()

# 写入mesh
gpy.write_mesh("assets/new_bunny_gpytoolbox.obj",v,f)

4 平移、缩放、旋转

4.1 平移

import igl
import polyscope as ps
import numpy as np

v, f = igl.read_triangle_mesh("assets/bunny.obj")

v1 = v + np.array([0.1, 0, 0])

ps.init()
ps.register_surface_mesh("mesh", v, f,
                         color=np.array([0, 91, 255]) / 255,
                         edge_width=0.03,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

ps.register_surface_mesh("mesh1", v1, f,
                         color=np.array([255, 164, 0]) / 255,
                         edge_width=0.03,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

# ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 这两行有用
ps.set_shadow_blur_iters(3)  # 模糊的程度,这个数值可以设置很大
ps.set_shadow_darkness(0.5)  # 这个数值也可以设置很大
ps.set_up_dir("y_up")  # 这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉
ps.set_front_dir('z_front')  # 这两行有用
ps.set_SSAA_factor(4)
ps.set_open_imgui_window_for_user_callback(False)  # 用于将原始imgui的界面关掉
ps.show()

4.2 缩放

import igl
import polyscope as ps
import numpy as np

v, f = igl.read_triangle_mesh("assets/bunny.obj")

v1 = v * 2

ps.init()
ps.register_surface_mesh("mesh", v, f,
                         color=np.array([0, 91, 255]) / 255,
                         edge_width=0.03,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

ps.register_surface_mesh("mesh1", v1, f,
                         color=np.array([255, 164, 0]) / 255,
                         edge_width=0.03,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 这两行有用
ps.set_shadow_blur_iters(3)  # 模糊的程度,这个数值可以设置很大
ps.set_shadow_darkness(0.5)  # 这个数值也可以设置很大
ps.set_up_dir("y_up")  # 这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉
ps.set_front_dir('z_front')  # 这两行有用
ps.set_SSAA_factor(4)
ps.set_open_imgui_window_for_user_callback(False)  # 用于将原始imgui的界面关掉
ps.show()

4.3 矩阵旋转

import igl
import polyscope as ps
import numpy as np

v, f = igl.read_triangle_mesh("assets/bunny.obj")

# 绕轴旋转90度
angle = 90 / 180 * np.pi
Tx = np.array([
    [1, 0, 0],
    [0, np.cos(angle), np.sin(angle)],
    [0, -np.sin(angle), np.cos(angle)],
])

Ty = np.array([
    [np.cos(angle), 0, -np.sin(angle)],
    [0, 1, 0],
    [np.sin(angle), 0, np.cos(angle)],
])

Tz = np.array([
    [np.cos(angle), np.sin(angle), 0],
    [-np.sin(angle), np.cos(angle), 0],
    [0, 0, 1],
])

# 将mesh中心点移动到原点
new_v = v - v.mean(axis=0)

# 旋转
new_v_x = np.dot(new_v, Tx)
new_v_y = np.dot(new_v, Ty)
new_v_z = np.dot(new_v, Tz)

# 旋转后,再加上中心点v.mean(axis=0)
new_v_x = new_v_x + v.mean(axis=0)
new_v_y = new_v_y + v.mean(axis=0)
new_v_z = new_v_z + v.mean(axis=0)

ps.init()
ps.register_surface_mesh("mesh", v, f,
                         color=np.array([0, 91, 255]) / 255,
                         edge_width=0.03,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

ps.register_surface_mesh("mesh_x", new_v_x, f,
                         color=np.array([255, 164, 0]) / 255,
                         edge_width=0.03,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

ps.register_surface_mesh("mesh_y", new_v_y, f,
                         color=np.array([255, 0, 218]) / 255,
                         edge_width=0.03,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )
ps.register_surface_mesh("mesh_z", new_v_z, f,
                         color=np.array([0, 255, 37]) / 255,
                         edge_width=0.03,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )
ps.set_view_projection_mode("orthographic")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 这两行有用
ps.set_shadow_blur_iters(3)  # 模糊的程度,这个数值可以设置很大
ps.set_shadow_darkness(0.5)  # 这个数值也可以设置很大
ps.set_up_dir("y_up")  # 这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉
ps.set_front_dir('z_front')  # 这两行有用
ps.set_SSAA_factor(4)
ps.set_open_imgui_window_for_user_callback(False)  # 用于将原始imgui的界面关掉
ps.show()

mesh是y轴正方向向上,z轴正方向指向屏幕外,x轴正方向向右

绕x轴旋转 绕y轴旋转 绕z轴旋转

4.4 轴角旋转

# 绕单一轴旋转
new_v_x = R.from_euler('x', 90, degrees=True).apply(new_v)
new_v_y = R.from_euler('y', 90, degrees=True).apply(new_v)
new_v_z = R.from_euler('z', 90, degrees=True).apply(new_v)

# 多轴旋转
new_v = R.from_euler('xyz', [90,45,0], degrees=True).apply(new_v)
import igl
import polyscope as ps
import numpy as np
from scipy.spatial.transform import Rotation as R

v, f = igl.read_triangle_mesh("assets/bunny.obj")

# 将mesh中心点移动到原点
new_v = v - v.mean(axis=0)

# 使用旋转轴+旋转角度,对mesh进行旋转
new_v_x = R.from_euler('x', 90, degrees=True).apply(new_v)
new_v_y = R.from_euler('y', 90, degrees=True).apply(new_v)
new_v_z = R.from_euler('z', 90, degrees=True).apply(new_v)

# 旋转后,再加上中心点v.mean(axis=0)
new_v_x = new_v_x + v.mean(axis=0)
new_v_y = new_v_y + v.mean(axis=0)
new_v_z = new_v_z + v.mean(axis=0)

ps.init()
ps.register_surface_mesh("mesh", v, f,
                         color=np.array([0, 91, 255]) / 255,
                         edge_width=0.03,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

ps.register_surface_mesh("mesh_x", new_v_x, f,
                         color=np.array([255, 164, 0]) / 255,
                         edge_width=0.03,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

ps.register_surface_mesh("mesh_y", new_v_y, f,
                         color=np.array([255, 0, 218]) / 255,
                         edge_width=0.03,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )
ps.register_surface_mesh("mesh_z", new_v_z, f,
                         color=np.array([0, 255, 37]) / 255,
                         edge_width=0.03,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )
ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 这两行有用
ps.set_shadow_blur_iters(3)  # 模糊的程度,这个数值可以设置很大
ps.set_shadow_darkness(0.5)  # 这个数值也可以设置很大
ps.set_up_dir("y_up")  # 这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉
ps.set_front_dir('z_front')  # 这两行有用
ps.set_SSAA_factor(4)
ps.set_open_imgui_window_for_user_callback(False)  # 用于将原始imgui的界面关掉
ps.show()

5 法线

5.1 顶点法线

import numpy as np
import igl
import polyscope as ps

# igl读取模型
v, f = igl.read_triangle_mesh("assets/bunny.obj")

# 计算顶点的法向量
vn = igl.per_vertex_normals(v, f)

# 可视化mesh
ps.init()
ps_mesh = ps.register_surface_mesh("mesh", v, f,
                                   color=np.array([0, 91, 255]) / 255,
                                   edge_width=0.3,
                                   edge_color=[1, 1, 1],
                                   smooth_shade=True,
                                   # material="flat"
                                   )

ps_mesh.add_vector_quantity("vertex_normal", vn,
                            defined_on="vertices",  # 在顶点上添加法线
                            color=(1, 0, 0),
                            radius=0.002,
                            length=0.03,
                            enabled=True)

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 这两行有用
ps.set_shadow_blur_iters(3)  # 模糊的程度,这个数值可以设置很大
ps.set_shadow_darkness(0.5)  # 这个数值也可以设置很大
ps.set_up_dir("y_up")  # 这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉
ps.set_front_dir('z_front')  # z轴正方向向前
ps.set_SSAA_factor(4)
ps.set_open_imgui_window_for_user_callback(False)  # 用于将原始imgui的界面关掉
ps.show()

5.2 面法线

import numpy as np
import igl
import polyscope as ps

# igl读取模型
v, f = igl.read_triangle_mesh("assets/bunny.obj")

# 计算面的法向量
fn = igl.per_face_normals(v, f, np.ones(3))

ps.init()
ps_mesh = ps.register_surface_mesh("mesh", v, f,
                                   color=np.array([0, 91, 255]) / 255,
                                   edge_width=0.3,
                                   edge_color=[1, 1, 1],
                                   smooth_shade=True,
                                   # material="flat"
                                   )

ps_mesh.add_vector_quantity("face_normal", fn,
                            defined_on="faces",  # 在面上添加法线
                            color=(1, 0, 0),
                            radius=0.002,
                            length=0.03,
                            enabled=True)

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 这两行有用
ps.set_shadow_blur_iters(3)  # 模糊的程度,这个数值可以设置很大
ps.set_shadow_darkness(0.5)  # 这个数值也可以设置很大
ps.set_up_dir("y_up")  # 这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉
ps.set_front_dir('z_front')  # z轴正方向向前
ps.set_SSAA_factor(4)
ps.set_open_imgui_window_for_user_callback(False)  # 用于将原始imgui的界面关掉
ps.show()

6 polyscope项目选项

7 polyscope场景选项

7.1 设置场景背景颜色

默认背景颜色是白色 [1, 1, 1]

ps.set_background_color([234/255,234/255,242/255]) ps.set_background_color([0, 148/255, 133/255])

8 切平面

8.1 添加切平面方法

添加切平面

ps_plane = ps.add_scene_slice_plane()  
ps_plane.set_pose([0, 0, 0], [1, 0, 0])  

参数说明

ps_plane.set_pose(plane_position, plane_normal)
第1个参数是位置(控制切平面的位置)
第2个参数是法线(控制切割后保留的部分)

添加两个切平面

plane1 = ps.add_scene_slice_plane()  
plane1.set_pose((0, 0, 0), (0, -1, 0))  # 通过法线控制切割保留的部分
plane1.set_draw_plane(True)  
plane1.set_draw_widget(True)  


plane2 = ps.add_scene_slice_plane()  
plane2.set_pose((0, -0.2, 0), (0, 1, 0))  
plane2.set_draw_plane(True)  
plane2.set_draw_widget(True)  
plane2.set_enabled(False) # 不勾选切面


# 如果两个切面的法线都一样,例如都为(0, 1, 0),都为上,则只保留一个平面的切割效果

# 如果两个切平面的法线不一样,例如(0, -1, 0),(0, 1, 0),下,上,两个方向相交,保留相交的区域

from star.pytorch.star import STAR
import numpy as np
import torch
import polyscope as ps

np.set_printoptions(suppress=True)

batch_size = 1
num_betas = 300  # 设置使用多少个主成分10 20 300
poses = torch.cuda.FloatTensor(np.zeros((batch_size, 72)))
betas = torch.cuda.FloatTensor(np.zeros((batch_size, num_betas)))
trans = torch.cuda.FloatTensor(np.zeros((batch_size, 3)))

star = STAR(gender='female', num_betas=num_betas)
model = star.forward(poses, betas, trans)
v = model[0].cpu().numpy()
f = model.f.astype("int32")

ps.init()
ps.register_surface_mesh("mesh", v, f,
                         color=np.array([0, 91, 255]) / 255,
                         edge_width=0.3,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

plane1 = ps.add_scene_slice_plane()
plane1.set_pose((0, 0, 0), (0, -1, 0))  # 通过法线控制切割保留的部分
plane1.set_draw_plane(True)
plane1.set_draw_widget(True)
plane1.set_enabled(False)

plane2 = ps.add_scene_slice_plane()
plane2.set_pose((0, -0.2, 0), (0, 1, 0))
plane2.set_draw_plane(True)
plane2.set_draw_widget(True)
plane2.set_enabled(True)
plane2.set_color([1,0,0])
plane2.set_transparency(1) # 默认是0.5半透明,1是不透明


# ps.set_build_gui(False)
ps.set_window_size(1200, 800)
ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("tile_reflection")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 设置地平面高度
ps.set_shadow_blur_iters(3)  # 设置地平面阴影模糊程度
ps.set_shadow_darkness(0.5)  # 设置地平面阴影明暗程度
ps.set_up_dir("y_up")  # 设置y轴正方向向上(这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉)
ps.set_front_dir('z_front')  # 设置z轴正方向向前
ps.set_SSAA_factor(4)  # 在截图时,设置为4时,截图会更清晰
ps.show()
切平面1
切平面2
切平面1+2

8.2 切平面参数设置

ps_plane.set_draw_plane(True)  # render the semi-transparent gridded plane  
ps_plane.set_draw_widget(True)
ps_plane.set_enabled(False) # 不勾选切面
ps_plane.set_color([1,0,0]) # 设置平面颜色
ps_plane.set_transparency(1) # 默认是0.5半透明,1是不透明
plane2.set_enabled(True) # 设置可见性
plane2.set_color([1,0,0]) # 设置颜色
plane2.set_transparency(1) # 1是不透明

9 polyscope管理视角

9.1 初始可视化

import igl
import polyscope as ps
import numpy as np
import json

V, F = igl.read_triangle_mesh("assets/bunny.obj")
print(V.shape,F.shape)

ps.init()
ps.register_surface_mesh("mesh", V, F,
                         color=np.array([0, 91, 255]) / 255,
                         edge_width=0.3,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 设置地平面高度
ps.set_shadow_blur_iters(3)  # 设置地平面阴影模糊程度
ps.set_shadow_darkness(0.5)  # 设置地平面阴影明暗程度
ps.set_up_dir("y_up")  # 设置y轴正方向向上(这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉)
ps.set_front_dir('z_front')  # 设置z轴正方向向前
ps.set_SSAA_factor(4) # 在截图时,设置为4时,截图会更清晰
ps.show()

9.2 获取视角参数

在可视化时,可以旋转mesh到合适的视角,然后将该视角参数保存为json文件,下次可视化时加载json参数设置视角即可

import igl
import polyscope as ps
import numpy as np
import json

V, F = igl.read_triangle_mesh("assets/bunny.obj")
print(V.shape,F.shape)

ps.init()
ps.register_surface_mesh("mesh", V, F,
                         color=np.array([0, 91, 255]) / 255,
                         edge_width=0.3,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 设置地平面高度
ps.set_shadow_blur_iters(3)  # 设置地平面阴影模糊程度
ps.set_shadow_darkness(0.5)  # 设置地平面阴影明暗程度
ps.set_up_dir("y_up")  # 设置y轴正方向向上(这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉)
ps.set_front_dir('z_front')  # 设置z轴正方向向前
ps.set_SSAA_factor(4) # 在截图时,设置为4时,截图会更清晰
ps.show()


# 获得视图参数,并写入json
my_view = ps.get_view_as_json()
with open('my_view.json', "w") as fp:
    json.dump(my_view, fp, indent=4, ensure_ascii=False)

9.3 加载保存的视角参数

import igl
import polyscope as ps
import numpy as np
import json

V, F = igl.read_triangle_mesh("assets/bunny.obj")
print(V.shape,F.shape)

# 读取视图json文件
with open('my_view.json') as fin:
    my_view = json.load(fin)

ps.init()
ps.set_view_from_json(my_view)
ps.register_surface_mesh("mesh", V, F,
                         color=np.array([0, 91, 255]) / 255,
                         edge_width=0.3,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 设置地平面高度
ps.set_shadow_blur_iters(3)  # 设置地平面阴影模糊程度
ps.set_shadow_darkness(0.5)  # 设置地平面阴影明暗程度
ps.set_up_dir("y_up")  # 设置y轴正方向向上(这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉)
ps.set_front_dir('z_front')  # 设置z轴正方向向前
ps.set_SSAA_factor(4) # 在截图时,设置为4时,截图会更清晰
ps.show()

9.4 直接设置视角参数

在代码内部直接设置视角参数,无需加载json文件

import igl
import polyscope as ps
import numpy as np

V, F = igl.read_triangle_mesh("assets/bunny.obj")
print(V.shape, F.shape)

my_view = ("{\"farClipRatio\":20.0,\"fov\":45.0,\"nearClipRatio\":0.005,"
           "\"projectionMode\":\"Perspective\","
           "\"viewMat\":[0.628925979137421,-0.0,0.777465164661407,0.0164333805441856,"
           "0.477299362421036,0.78937029838562,-0.386108577251434,-0.0585889630019665,"
           "-0.613707959651947,0.613917350769043,0.496455520391464,-0.391957879066467,"
           "0.0,0.0,0.0,1.0],"
           "\"windowHeight\":720,\"windowWidth\":1280}")

ps.init()
ps.set_view_from_json(my_view)
ps.register_surface_mesh("mesh", V, F,
                         color=np.array([0, 91, 255]) / 255,
                         edge_width=0.3,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 设置地平面高度
ps.set_shadow_blur_iters(3)  # 设置地平面阴影模糊程度
ps.set_shadow_darkness(0.5)  # 设置地平面阴影明暗程度
ps.set_up_dir("y_up")  # 设置y轴正方向向上(这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉)
ps.set_front_dir('z_front')  # 设置z轴正方向向前
ps.set_SSAA_factor(4) # 在截图时,设置为4时,截图会更清晰
ps.show()

9.5 常用视角

常用的视角有:常用窗口、方形窗口、全屏窗口

注意:直接设置视角参数时,因为在 my_view视角参数里面已经设置了“透视投影”或“正交投影“,所以在代码里面就不要再设置了,ps.set_view_projection_mode("perspective")这一行要注释掉!

# 常用窗口
my_view = ("{\"farClipRatio\":20.0,"
           "\"fov\":39.9119839509077,"
           "\"nearClipRatio\":0.005,"
           "\"projectionMode\":\"Orthographic\","
           "\"viewMat\":[0.905055642127991,-4.65661287307739e-10,0.425295770168304,0.0160223785787821,"
           "0.148309409618378,0.937226414680481,-0.315611660480499,-0.0960772186517715,"
           "-0.398598343133926,0.348720252513885,0.848241686820984,-0.358562052249908,"
           "0.0,0.0,0.0,1.0],"
           "\"windowHeight\":801,"
           "\"windowWidth\":1293}")

# 方形窗口
my_view = ("{\"farClipRatio\":20.0,"
           "\"fov\":35.0,"
           "\"nearClipRatio\":0.005,"
           "\"projectionMode\":\"Orthographic\","
           "\"viewMat\":[1.0,-0.0,0.0,0.0168603006750345,"
           "0.0,0.997785151004791,-0.066519021987915,-0.110035300254822,"
           "-0.0,0.066519021987915,0.997785151004791,-0.320515900850296,"
           "0.0,0.0,0.0,1.0],"
           "\"windowHeight\":600,"
           "\"windowWidth\":600}")

# 全屏窗口
my_view = ("{\"farClipRatio\":20.0,"
           "\"fov\":38.7801126847704,"
           "\"nearClipRatio\":0.005,"
           "\"projectionMode\":\"Orthographic\","
           "\"viewMat\":[0.992455244064331,2.91038304567337e-11,0.122607305645943,0.0192149728536606,"
           "0.0536937303841114,0.899007201194763,-0.434628546237946,-0.0625064224004745,"
           "-0.110224828124046,0.437932759523392,0.892224311828613,-0.363460153341293,"
           "0.0,0.0,0.0,1.0],"
           "\"windowHeight\":1055,"
           "\"windowWidth\":1920}")
常用窗口
方形窗口
全屏窗口
# ps.set_view_projection_mode("perspective") 这一行要 注释掉

10 polyscope管理相机

11 polyscope添加量

11.1 标量add_scalar_quantity

11.1.1 每个顶点添加标量量

import polyscope as ps
import numpy as np
import trimesh

mesh = trimesh.load_mesh("assets/bunny.obj")
V = mesh.vertices
F = mesh.faces

ps.init()
ps_mesh = ps.register_surface_mesh("mesh", V, F,
                                   color=np.array([0, 91, 255]) / 255,
                                   edge_width=0.0003,
                                   edge_color=[1, 1, 1],
                                   smooth_shade=True,
                                   # material="flat"
                                   )

ps_mesh.add_scalar_quantity("scalar", V[:, 1],
                            defined_on="vertices",
                            cmap="jet",
                            enabled=True)

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 这两行有用
ps.set_shadow_blur_iters(3)  # 模糊的程度,这个数值可以设置很大
ps.set_shadow_darkness(0.5)  # 这个数值也可以设置很大
ps.set_up_dir("y_up")  # 这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉
ps.set_front_dir('z_front')  # 这两行有用
ps.set_SSAA_factor(4)
ps.show()

11.1.2 每个面添加标量量

import polyscope as ps
import numpy as np
import trimesh
import igl

# igl读取模型
V, F = igl.read_triangle_mesh("assets/bunny.obj")

# 求每个面的重心坐标
barycenter = igl.barycenter(V, F)  # (6966, 3) (6966, 3

ps.init()
ps_mesh = ps.register_surface_mesh("mesh", V, F,
                                   color=np.array([0, 91, 255]) / 255,
                                   edge_width=0.0003,
                                   edge_color=[1, 1, 1],
                                   smooth_shade=True,
                                   # material="flat"
                                   )

ps_mesh.add_scalar_quantity("scalar", barycenter[:, 1],
                            defined_on="faces",
                            enabled=True, cmap="jet")

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 这两行有用
ps.set_shadow_blur_iters(3)  # 模糊的程度,这个数值可以设置很大
ps.set_shadow_darkness(0.5)  # 这个数值也可以设置很大
ps.set_up_dir("y_up")  # 这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉
ps.set_front_dir('z_front')  # 这两行有用
ps.set_SSAA_factor(4)
ps.show()

11.2 颜色add_color_quantity

11.2.1 每个顶点添加颜色量

import igl
import polyscope as ps
import numpy as np


def visu(vertices):
    # 将所有的顶点坐标转换成颜色值,颜色值的范围在0-1之间,归一化
    min_coord, max_coord = np.min(vertices, axis=0, keepdims=True), np.max(vertices, axis=0, keepdims=True)
    cmap = (vertices - min_coord) / (max_coord - min_coord)
    return cmap


# igl读取模型
V, F = igl.read_triangle_mesh("assets/cat-00.off")

colors = visu(V)

ps.init()
ps_mesh = ps.register_surface_mesh("mesh", V, F,
                                   color=np.array([0, 91, 255]) / 255,
                                   edge_width=0.0003,
                                   edge_color=[1, 1, 1],
                                   smooth_shade=True,
                                   # material="flat"
                                   )

# add_color_quantity 这个函数没有cmap这个参数,因为它添加的就是颜色值,不需要再设置cmap
ps_mesh.add_color_quantity("color", colors,
                           defined_on="vertices",
                           enabled=True)

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 这两行有用
ps.set_shadow_blur_iters(3)  # 模糊的程度,这个数值可以设置很大
ps.set_shadow_darkness(0.5)  # 这个数值也可以设置很大
ps.set_up_dir("y_up")  # 这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉
ps.set_front_dir('z_front')  # 这两行有用
ps.set_SSAA_factor(4)
ps.show()

11.2.2 每个面添加颜色量

import polyscope as ps
import numpy as np
import igl


def visu(vertices):
    # 将所有的顶点坐标转换成颜色值,颜色值的范围在0-1之间,归一化
    min_coord, max_coord = np.min(vertices, axis=0, keepdims=True), np.max(vertices, axis=0, keepdims=True)
    cmap = (vertices - min_coord) / (max_coord - min_coord)
    return cmap


V, F = igl.read_triangle_mesh("assets/cat-00.off")

barycenter = igl.barycenter(V, F)
colors = visu(barycenter)

# ===== 2. 注册 mesh =====
ps.init()
ps_mesh = ps.register_surface_mesh("mesh", V, F,
                                   color=np.array([0, 91, 255]) / 255,
                                   edge_width=0.0003,
                                   edge_color=[1, 1, 1],
                                   smooth_shade=True,
                                   # material="flat"
                                   )
ps_mesh.add_color_quantity("color", colors, defined_on="faces", enabled=True)

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 这两行有用
ps.set_shadow_blur_iters(3)  # 模糊的程度,这个数值可以设置很大
ps.set_shadow_darkness(0.5)  # 这个数值也可以设置很大
ps.set_up_dir("y_up")  # 这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉
ps.set_front_dir('z_front')  # 这两行有用
ps.set_SSAA_factor(4)
ps.show()

11.3 向量add_vector_quantity

11.3.1 每个顶点上添加向量量

import numpy as np
import igl
import polyscope as ps

# igl读取模型
v, f = igl.read_triangle_mesh("assets/bunny.obj")

# 计算顶点的法向量
vn = igl.per_vertex_normals(v, f)

# 可视化mesh
ps.init()
ps_mesh = ps.register_surface_mesh("mesh", v, f,
                                   color=np.array([0, 91, 255]) / 255,
                                   edge_width=0.3,
                                   edge_color=[1, 1, 1],
                                   smooth_shade=True,
                                   # material="flat"
                                   )

ps_mesh.add_vector_quantity("vertex_normal", vn,
                            defined_on="vertices",  # 在顶点上添加法线
                            color=(1, 0, 0),
                            radius=0.002,
                            length=0.03,
                            enabled=True)

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 这两行有用
ps.set_shadow_blur_iters(3)  # 模糊的程度,这个数值可以设置很大
ps.set_shadow_darkness(0.5)  # 这个数值也可以设置很大
ps.set_up_dir("y_up")  # 这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉
ps.set_front_dir('z_front')  # z轴正方向向前
ps.set_SSAA_factor(4)
ps.set_open_imgui_window_for_user_callback(False)  # 用于将原始imgui的界面关掉
ps.show()

11.3.2 每个面上添加向量量

import numpy as np
import igl
import polyscope as ps

# igl读取模型
v, f = igl.read_triangle_mesh("assets/bunny.obj")

# 计算面的法向量
fn = igl.per_face_normals(v, f, np.ones(3))

ps.init()
ps_mesh = ps.register_surface_mesh("mesh", v, f,
                                   color=np.array([0, 91, 255]) / 255,
                                   edge_width=0.3,
                                   edge_color=[1, 1, 1],
                                   smooth_shade=True,
                                   # material="flat"
                                   )

ps_mesh.add_vector_quantity("face_normal", fn,
                            defined_on="faces",  # 在面上添加法线
                            color=(1, 0, 0),
                            radius=0.002,
                            length=0.03,
                            enabled=True)

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 这两行有用
ps.set_shadow_blur_iters(3)  # 模糊的程度,这个数值可以设置很大
ps.set_shadow_darkness(0.5)  # 这个数值也可以设置很大
ps.set_up_dir("y_up")  # 这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉
ps.set_front_dir('z_front')  # z轴正方向向前
ps.set_SSAA_factor(4)
ps.set_open_imgui_window_for_user_callback(False)  # 用于将原始imgui的界面关掉
ps.show()

11.4 参数化add_parameterization_quantity

11.4.1 给3D服装添加参数化量

import numpy as np
import polyscope as ps
import igl


def visu(vertices):
    # 将所有的顶点坐标转换成颜色值,颜色值的范围在0-1之间,归一化
    min_coord, max_coord = np.min(vertices, axis=0, keepdims=True), np.max(vertices, axis=0, keepdims=True)
    cmap = (vertices - min_coord) / (max_coord - min_coord)
    return cmap


V, F = igl.read_triangle_mesh("2_source_g.obj")
v_2D, f_2D = igl.read_triangle_mesh("2_source_p.obj")

# 对于服装来说,uv就是样板文件
# uv的值需要在0-1的范围内,如果不在这个范围内,可视化有问题
param_v = visu(v_2D[:, :2])

ps.init()
mesh_3D = ps.register_surface_mesh("mesh_3D", V, F)
mesh_3D.add_parameterization_quantity("3D_para", param_v,
                                      enabled=True,
                                      viz_style="checker",
                                      coords_type='unit',
                                      checker_size=0.05,
                                      # checker_colors=((1.0, 0, 0), (0, 0, 1.0)),
                                      # grid_colors=((1.0, 0, 0), (0, 0, 1.0)),
                                      )

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 设置地平面高度
ps.set_shadow_blur_iters(3)  # 设置地平面阴影模糊程度
ps.set_shadow_darkness(0.5)  # 设置地平面阴影明暗程度
ps.set_up_dir("y_up")  # 设置y轴正方向向上(这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉)
ps.set_front_dir('z_front')  # 设置z轴正方向向前
ps.set_SSAA_factor(4)  # 在截图时,设置为4时,截图会更清晰
ps.show()

11.4.2 给2D样板添加参数化量

import numpy as np
import polyscope as ps
import igl


def visu(vertices):
    # 将所有的顶点坐标转换成颜色值,颜色值的范围在0-1之间,归一化
    min_coord, max_coord = np.min(vertices, axis=0, keepdims=True), np.max(vertices, axis=0, keepdims=True)
    cmap = (vertices - min_coord) / (max_coord - min_coord)
    return cmap


V, F = igl.read_triangle_mesh("2_source_g.obj")
v_2D, f_2D = igl.read_triangle_mesh("2_source_p.obj")

# 对于服装来说,uv就是样板文件
# uv的值需要在0-1的范围内,如果不在这个范围内,可视化有问题
param_v = visu(v_2D[:, :2])

ps.init()
mesh_2D = ps.register_surface_mesh("mesh_2D", v_2D, f_2D)
mesh_2D.add_parameterization_quantity("2D_para", param_v, enabled=True, checker_size=0.05)

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 设置地平面高度
ps.set_shadow_blur_iters(3)  # 设置地平面阴影模糊程度
ps.set_shadow_darkness(0.5)  # 设置地平面阴影明暗程度
ps.set_up_dir("y_up")  # 设置y轴正方向向上(这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉)
ps.set_front_dir('z_front')  # 设置z轴正方向向前
ps.set_SSAA_factor(4)  # 在截图时,设置为4时,截图会更清晰
ps.show()
在3D服装上添加参数化量 在2D样板上添加参数化量

11.4.3 参数量可视化设置

add_parameterization_quantity("3D_para", param_v,
                                      enabled=True,
                                      viz_style="checker",
                                      coords_type='unit',
                                      checker_size=0.05,
                                      # checker_colors=((1.0, 0, 0), (0, 0, 1.0)),
                                      # grid_colors=((1.0, 0, 0), (0, 0, 1.0)),
                                      )

viz_style参数有四种选择

checker grid
local grid local dist

create_curve_network_from_seam这个函数有什么用?

11.5 纹理贴图

add_scalar_quantity + defined_on='texture' 图像数据是标量(每个像素一个值),可视化时通过 colormap 映射成颜色。适合展示密度、温度、高度等标量场。

add_color_quantity + defined_on='texture' 图像数据是RGB颜色(每个像素三个值),直接显示原始颜色。适合加载真实的彩色纹理贴图。

add_color_quantity的texture是一张rgb图,形状为(height,width,3)

11.5.1 使用vertices法为smpl添加纹理

smpl_uv.obj和f_02_alb.002.png是在SMPL官方网站上下载的

https://smpl.is.tue.mpg.de/index.html
import numpy as np
import polyscope as ps
import trimesh
from PIL import Image

# 使用vertices方法,为smpl人体添加uv纹理贴图
mesh = trimesh.load("smpl_uv.obj", process=False, force='mesh')
v, f = mesh.vertices, mesh.faces

ps.init()
# 1、可视mesh
ps_mesh = ps.register_surface_mesh("mesh", v, f,
                                   color=[0, 91 / 255, 255 / 255],
                                   edge_width=0.001,
                                   edge_color=[1, 1, 1],
                                   smooth_shade=True,
                                   # material="flat"
                                   )

# 2、添加参数化 (aka UV map)
uv = mesh.visual.uv
print(np.min(uv), np.max(uv))  # vt的值需要在0-1的范围内,如果不在这个范围内,可视化有问题
ps_mesh.add_parameterization_quantity("uv", uv, defined_on='vertices', enabled=True)

# 3、加载纹理贴图,将纹理贴图转化为颜色量
uv_img = Image.open('f_02_alb.002.png')
texture = np.asarray(uv_img)

texture_color = texture[:, :, :3] / 255
# 要加这一行,mesh材质颜色才能正常显示
# 将sRGB颜色转换为线性空间 (Polyscope默认期望线性颜色)
texture_color = np.power(texture_color, 2.2)  # gamma校正的逆运算

# 4、在mesh上添加颜色量
ps_mesh.add_color_quantity("texture", texture_color,
                           defined_on='texture',
                           param_name="uv",
                           filter_mode='nearest',
                           enabled=True)

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 设置地平面高度
ps.set_shadow_blur_iters(3)  # 设置地平面阴影模糊程度
ps.set_shadow_darkness(0.5)  # 设置地平面阴影明暗程度
ps.set_up_dir("y_up")  # 设置y轴正方向向上(这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉)
ps.set_front_dir('z_front')  # 设置z轴正方向向前
ps.set_SSAA_factor(4)  # 在截图时,设置为4时,截图会更清晰
ps.show()

打印:

0.0073 0.995324

纹理图 法线图

11.5.2 使用corners法为smpl添加纹理

add_color_quantity()

import igl
import numpy as np
import polyscope as ps
from PIL import Image

# 使用corners方法,为smpl人体添加uv纹理贴图

v, vt, _, f, ft, _ = igl.readOBJ("smpl_uv.obj")

ps.init()

# 1、可视化mesh
ps_mesh = ps.register_surface_mesh("mesh", v, f,
                                   color=[0, 91/255, 255/ 255],
                                   edge_width=0.001,
                                   edge_color=[1, 1, 1],
                                   smooth_shade=True,
                                   # material="flat"
                                   )

# 2、添加参数化 (aka UV map)
uv = vt[ft.reshape(-1)]
print(np.min(uv), np.max(uv))  # uv的值需要在0-1的范围内,如果不在这个范围内,可视化有问题
ps_mesh.add_parameterization_quantity("uv", uv, defined_on='corners', enabled=True)

# 3、加载纹理贴图,将纹理贴图转化为颜色量
uv_img = Image.open('f_02_alb.002.png')
uv_img = np.asarray(uv_img)
texture_map = uv_img[:, :, :3] / 255
# 易错的点,有些rgba图包含透明度这个通道
# 直接使用uv_img会出错,使用uv_img[:, :, :3]更合适

# 要加这一行,mesh材质颜色才能正常显示
# 将sRGB纹理转换到线性空间(去除gamma编码)
texture_map = np.power(texture_map, 2.2)

# 4、在mesh上添加颜色量
ps_mesh.add_color_quantity("spot_texture", texture_map,
                           defined_on='texture',
                           param_name="uv",
                           filter_mode='nearest',
                           enabled=True)

ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 设置地平面高度
ps.set_shadow_blur_iters(3)  # 设置地平面阴影模糊程度
ps.set_shadow_darkness(0.5)  # 设置地平面阴影明暗程度
ps.set_up_dir("y_up")  # 设置y轴正方向向上(这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉)
ps.set_front_dir('z_front')  # 设置z轴正方向向前
ps.set_SSAA_factor(4)  # 在截图时,设置为4时,截图会更清晰
ps.show()

12 polyscope的Color Maps

13 polyscope可视化uv

14 polyscope动画

14.1 循环动画

14.2 frame_trick动画

14.3 Callback交互式动画

15 polyscope交互式GUI

16 有用mesh操作

16.1 归一化mesh

import igl
import polyscope as ps
import numpy as np
import trimesh


def normalize_meshes(mesh):
    # https://github.com/1zb/GeomDist/blob/master/normalize.py
    mesh.vertices -= (mesh.vertices.max(axis=0) + mesh.vertices.min(axis=0)) / 2

    scale = (1 / np.abs(mesh.vertices).max()) * 0.99

    mesh.vertices *= scale

    points, _ = trimesh.sample.sample_surface(mesh, 10000000)

    mesh.vertices -= points.mean()
    mesh.vertices /= points.std()

    return mesh


mesh = trimesh.load_mesh("assets/bunny.obj")
org_v, org_f = mesh.vertices.copy(), mesh.faces.copy()

org_v = org_v + np.array([3, 0, 0])  # 方便可视化

# 将mesh归一化
mesh = normalize_meshes(mesh)
v, f = mesh.vertices, mesh.faces

ps.init()
ps.register_surface_mesh("org_mesh", org_v, org_f,
                         color=np.array([0, 91, 255]) / 255,
                         edge_width=0.03,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

ps.register_surface_mesh("mesh", v, f,
                         color=np.array([255, 164, 0]) / 255,
                         edge_width=0.03,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )
# ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 这两行有用
ps.set_shadow_blur_iters(3)  # 模糊的程度,这个数值可以设置很大
ps.set_shadow_darkness(0.5)  # 这个数值也可以设置很大
ps.set_up_dir("y_up")  # 这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉
ps.set_front_dir('z_front')
ps.set_SSAA_factor(4)
ps.show()

16.2 将mesh采样为点云

import igl
import polyscope as ps
import numpy as np
import trimesh

mesh = trimesh.load_mesh("assets/bunny.obj")
v, f = mesh.vertices, mesh.faces

v = v - np.array([0.2, 0, 0])  # 方便可视化

# 在mesh上采样点,从而生成点云
points, _ = trimesh.sample.sample_surface(mesh, 100000)

ps.init()
ps.register_surface_mesh("mesh", v, f,
                         color=np.array([0, 91, 255]) / 255,
                         edge_width=0.03,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )

ps.register_point_cloud("points", points, radius=0.0015)

ps.set_view_projection_mode("orthographic")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 这两行有用
ps.set_shadow_blur_iters(3)  # 模糊的程度,这个数值可以设置很大
ps.set_shadow_darkness(0.5)  # 这个数值也可以设置很大
ps.set_up_dir("y_up")  # 这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉
ps.set_front_dir('z_front')
ps.set_SSAA_factor(4)
ps.show()

16.3 将mesh沿顶点偏移一段距离

import polyscope as ps
import trimesh
import numpy as np


def offset_mesh_along_normals(input_mesh, offset_distance):
    # 获取原始顶点和面
    original_vertices = input_mesh.vertices.copy()
    faces = input_mesh.faces.copy()

    # 获取顶点法线(确保归一化)
    vertex_normals = input_mesh.vertex_normals.copy()

    # 沿法线方向移动顶点
    new_vertices = original_vertices + vertex_normals * offset_distance

    # 创建新网格
    new_mesh = trimesh.Trimesh(
        vertices=new_vertices,
        faces=faces,
        process=False  # 避免自动重新处理(如合并顶点)
    )

    return new_mesh


mesh = trimesh.load_mesh("assets/torso.obj")

new_mesh = offset_mesh_along_normals(mesh, -0.1)
new_v, new_f = new_mesh.vertices, new_mesh.faces
# new_mesh.export("new_torso.obj")

ps.init()
ps.register_surface_mesh("mesh", mesh.vertices, mesh.faces,
                         color=np.array([0, 91, 255]) / 255,
                         edge_width=0.3,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )
ps.register_surface_mesh("new_mesh", new_v, new_f,
                         color=np.array([255, 164, 0]) / 255,
                         edge_width=0.3,
                         edge_color=[1, 1, 1],
                         smooth_shade=True,
                         # material="flat"
                         )
ps.set_view_projection_mode("perspective")  # orthographic 正交投影   perspective 透视投影
# ps.set_navigation_style("planar")  # ['turntable','free','planar','none','first_person']
ps.set_ground_plane_mode("shadow_only")  # ['none','tile','tile_reflection','shadow_only']
# ps.set_ground_plane_height(-0.001)  # 这两行有用
ps.set_shadow_blur_iters(3)  # 模糊的程度,这个数值可以设置很大
ps.set_shadow_darkness(0.5)  # 这个数值也可以设置很大
ps.set_up_dir("y_up")  # 这个和设置视角会冲突,因此在添加视角参数时,这一行要注释掉
ps.set_front_dir('z_front')  # 这两行有用
ps.set_SSAA_factor(4)
ps.set_open_imgui_window_for_user_callback(False)  # 用于将原始imgui的界面关掉
ps.show()