blender 相机参数

AI算法网奇

已于 2025-03-06 05:58:58 修改

阅读量1.4k

点赞数 2

CC 4.0 BY-SA版权

分类专栏： 3d渲染文章标签：数码相机 blender

于 2025-02-03 00:35:22 首次发布

本文链接：https://blog.csdn.net/jacke121/article/details/145425072

3d渲染专栏收录该内容

72 篇文章

订阅专栏

获取相机朝向：

import bpy
import mathutils

# 获取当前场景中的相机
camera = bpy.context.scene.camera

# 获取相机的旋转矩阵
camera_matrix = camera.matrix_world

# 获取相机的局部Z轴方向（朝向）
camera_forward = camera_matrix @ mathutils.Vector((0, 0, -1))

# 输出相机的朝向（即相机的Z轴方向）
print("Camera Forward Direction:", camera_forward)

设置相机参数：

3. 设置相机参数示例

假设你有一个相机，并希望设置它的焦距和位置，可以通过 Python 脚本来设置这些参数：

python

import bpy # 获取当前场景中的相机 
camera = bpy.context.scene.camera # 设置相机的位置 (外参) 
camera.location = (0, 0, 10) # 设置相机的旋转 (外参) 
camera.rotation_euler = (1.5708, 0, 0) # 使用欧拉角旋转 
# 设置相机的焦距 (内参) 
camera.data.lens = 50 # 焦距为 50mm 
# 设置传感器的尺寸 (内参) 
camera.data.sensor_width = 32 # 传感器宽度为 32mm 
camera.data.sensor_height = 18 # 传感器高度为 18mm

4. 相机透视与正交

如果需要调整相机的视图类型，可以选择 透视视图 或 正交视图。对于渲染的视图设置，可以通过 camera.data.type 属性来设置：
- camera.data.type = 'PERSP'：透视相机
- camera.data.type = 'ORTHO'：正交相机

5. 额外的高级设置

深度裁剪（Clipping）：控制相机的可视范围，决定从相机视点出发，哪些物体会被渲染。你可以通过 clip_start 和 clip_end 控制这些裁剪距离。

camera.data.clip_start = 0.1

camera.data.clip_end = 1000

设置相机参数：

intrs_path = scene_dir + '/pred_intrinsics.txt'
intrs = np.loadtxt(intrs_path)
intrs = np.array(intrs, np.float32)
intrinsic = [intrs[0][0], intrs[0][0], intrs[0][2], intrs[0][5]]
print(intrinsic)
fx, fy, cx, cy = intrinsic[0], intrinsic[1], intrinsic[2], intrinsic[3]

width = float(args.image_width)
width_r = width / 512.0 * cx * 2
height_r = width / 512.0 * cy * 2
fx_r = width / 512.0 * fx


load_object(object_file)

# Set up cameras
cam = scene.objects["Camera"]
# cam.data.lens = 35
cam.data.sensor_width = 32

res_x = render.resolution_x
if render.resolution_y > render.resolution_x:
    res_x = render.resolution_y
cam.data.lens = cam.data.sensor_width * fx / res_x

设置渲染器：

import bpy

# 设置 Cycles 渲染器为 GPU 渲染
scene = bpy.context.scene
scene.cycles.device = "GPU"  # 使用 GPU 渲染

# 设置 Cycles 渲染样本数量，影响渲染质量和时间
scene.cycles.samples = 128  # 渲染时使用的样本数量

# 控制材质的反射和折射反弹次数
scene.cycles.diffuse_bounces = 1  # 漫反射反弹次数
scene.cycles.glossy_bounces = 1   # 镜面反射反弹次数
scene.cycles.transparent_max_bounces = 3  # 透明材质最大反弹次数
scene.cycles.transmission_bounces = 3  # 透光材质的最大反弹次数

# 设置噪声过滤的宽度
scene.cycles.filter_width = 0.01  # 噪声过滤宽度

# 启用去噪功能
scene.cycles.use_denoising = True  # 开启去噪功能

# 启用透明背景渲染（常用于合成）
scene.render.film_transparent = True  # 启用透明背景

# 刷新 GPU 设备设置
bpy.context.preferences.addons["cycles"].preferences.get_devices()  # 获取可用的设备

# 设置 GPU 渲染使用 CUDA 还是 OpenCL（取决于你的 GPU）
bpy.context.preferences.addons["cycles"].preferences.compute_device_type = "CUDA"  # 或者 "OPENCL"

外参转换函数

def set_camera(c2w: np.ndarray) -> bpy.types.Object:
    """设置Blender相机的位置和姿态
    Args:
        c2w: 4x4相机到世界变换矩阵，通常来自其他系统（如NeRF），可能使用不同的坐标系
    Returns:
        bpy.types.Object: 配置后的相机对象
    """
    # 获取Blender中的相机对象
    camera = bpy.data.objects["Camera"]

    # 应用坐标系变换：
    # 1. 先翻转输入坐标系的Y和Z轴方向
    # 2. 再调整坐标轴方向以适配Blender的相机坐标系
    transformed_matrix = BLENDER_AXIS_TRANSFORM @ (c2w @ COORDINATE_FLIP)

    # 将变换后的矩阵转置后赋给Blender相机
    # 注：Blender的matrix_world使用行主序，而numpy默认行存储，转置确保矩阵正确应用
    camera.matrix_world = transformed_matrix.T

    return camera

转换测试代码：



import numpy as np
BLENDER_AXIS_TRANSFORM = np.array([[1, 0, 0, 0], [0, 0, 1, 0], [0, -1, 0, 0], [0, 0, 0, 1]], dtype=np.float32)

# 该矩阵翻转Y和Z轴，用于调整坐标系的旋向性（例如从右手系到左手系）
COORDINATE_FLIP = np.array([[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0], [0, 0, 0, 1]], dtype=np.float32)


data=[i+1 for i in range(16)]
c2w=np.array(data).reshape(-1,4)

print(c2w)
print(COORDINATE_FLIP)
data=(c2w @ COORDINATE_FLIP)
print(BLENDER_AXIS_TRANSFORM)
print(data)
transformed_matrix = BLENDER_AXIS_TRANSFORM @ data

print(transformed_matrix)

获取blender渲染外参：

Diffusion4D/rendering/blender_cpu.py at f6aab73453976b9d0636cdf434be8c916bc5e60d · XuweiyiChen/Diffusion4D · GitHub

def get_3x4_RT_matrix_from_blender(cam: bpy.types.Object) -> Matrix:
    """Returns the 3x4 RT matrix from the given camera.
    Taken from Zero123, which in turn was taken from
    https://github.com/panmari/stanford-shapenet-renderer/blob/master/render_blender.py

    Args:
        cam (bpy.types.Object): The camera object.

    Returns:
        Matrix: The 3x4 RT matrix from the given camera.
    """
    # Use matrix_world instead to account for all constraints
    location, rotation = cam.matrix_world.decompose()[0:2]
    R_world2bcam = rotation.to_matrix().transposed()

    # Use location from matrix_world to account for constraints:
    T_world2bcam = -1 * R_world2bcam @ location

    # put into 3x4 matrix
    RT = Matrix((R_world2bcam[0][:] + (T_world2bcam[0],), R_world2bcam[1][:] + (T_world2bcam[1],), R_world2bcam[2][:] + (T_world2bcam[2],),))
    return RT

相机朝向设置：

def set_camera(radius: float = 2.2, ) -> bpy.types.Object:
    x = np.cos(-0.5 * np.pi) * radius  # 0
    y = np.sin(-0.5 * np.pi) * radius  # -radius
    z = 0
    x=0

    cam = bpy.data.objects["Camera"]
    cam.location = Vector(np.array([0, y*1.2, z]))# 越大人越小

    direction = -cam.location

    rot_quat = direction.to_track_quat("-Z", "Y")  # [[1, 0, 0], [0, 0, -1], [0, 1, 0]]

    left_offset_angle = math.radians(3)

    cam.rotation_euler = rot_quat.to_euler()
    current_rotation = cam.rotation_euler
    # current_rotation.x -= left_offset_angle #朝上
    current_rotation.z += left_offset_angle #朝左看，人向右移动

    # xxx
    focal_length = 775.0
    camera_center = [448.0, 448.0]

    # 将焦距设置为镜头的焦距
    cam.data.lens = focal_length

    # 设置相机传感器尺寸以匹配相机中心
    # 假设传感器宽度和高度与图像分辨率相同
    sensor_width = 2 * camera_center[0]
    sensor_height = 2 * camera_center[1]
    cam.data.sensor_width = sensor_width
    cam.data.sensor_height = sensor_height

    # 设置相机的剪切面
    cam.data.clip_start = 0.1
    cam.data.clip_end = 110