opengl绘制出多目相机配置场景

标定工具得到的Rt参数都表示原点在相机坐标系下的变换，因此后面绘制时需要将其转化到相机相对于原点的变换。
转化也很简单:
R’ --> R.T
T’ --> -R.T @ T

ok,下面就是简单的绘制了，直接看代码(shader资源链接):

import time
from OpenGL.GL import *
import numpy as np
from GEngine.shader import ShaderProgram
from GEngine.model import Model, ModelFromExport, generate_grid_mesh
import glm
from GEngine.camera3D import Camera3D
from GEngine.window import GWindow

SCR_WIDTH = 800
SCR_HEIGHT = 800

# camera = Camera3D(glm.vec3(0.0, 5.0, 30.0))
camera = Camera3D(glm.vec3(-82.702095, 552.18964, 5557.3535), movement_speed=3500)
window = GWindow("demo", SCR_WIDTH, SCR_HEIGHT, camera, keep_mouse_stay=True)

light_color = (1.0, 1.0, 1.0)
hand_color = (0.7, 0.7, 0.7)
light_position = (-10, 6, 10)

grid_position = [
    glm.vec3(1.0, 1.0, 1.0),
    [glm.radians(90), glm.vec3(1.0, 0.0, 0.0)],
    glm.vec3(0, 0.0, 0)
]
##相机配置 R 3x3 t 3x1
camera_config1 = [
    [[[-0.9115695, 0.41064942, 0.02020282], [0.06090775, 0.18347366, -0.9811359], [-0.4066096, -0.893143, -0.19226073]],
     [[-82.702095], [552.18964], [5557.3535]]],
    [[[0.93101627, 0.3647627, 0.01252435], [0.08939715, -0.19463754, -0.97679293],
      [-0.3538599, 0.91052973, -0.21381946]], [[-209.06287], [375.06915], [5818.277]]],
    [[[-0.92090756, -0.38473552, -0.06251254], [-0.02568138, 0.21992028, -0.97517973],
      [0.38893405, -0.89644504, -0.21240678]], [[623.0986], [290.9053], [5534.379]]],
    [[[0.9276671, -0.36360627, 0.08499598], [-0.01666269, -0.26770413, -0.9633571],
      [0.37303644, 0.89225835, -0.25439897]], [[-178.367], [423.46698], [4421.645]]]
]

camera_config2 = [
    [[[-0.9153617, 0.40180838, 0.02574755], [0.05154812, 0.18037356, -0.9822465],
      [-0.39931902, -0.89778364, -0.18581952]], [[-346.0509], [546.98083], [5474.481]]],
    [[[0.92816836, 0.37215385, 0.00224838], [0.08166409, -0.1977723, -0.9768404], [-0.36309022, 0.9068559, -0.2139576]],
     [[251.4252], [420.94223], [5588.196]]],
    [[[-0.91415495, -0.40277803, -0.04572295], [-0.04562341, 0.2143085, -0.97569996],
      [0.4027893, -0.8898549, -0.21428728]], [[480.4826], [253.83238], [5704.2075]]],
    [[[0.91415626, -0.40060705, 0.06190599], [-0.05641001, -0.2769532, -0.9592262],
      [0.40141782, 0.8733905, -0.27577674]], [[51.883537], [378.4209], [4406.1494]]]
]
rorate_x_90 = np.array([[1, 0, 0, 0],
                        [0, 0, 1, 0],
                        [0, -1, 0, 0],
                        [0, 0, 0, 1]], dtype=np.float32)


def init():
    grid_vertices, grid_mesh = generate_grid_mesh(-10, 10, step=0.5)

    global shader_program
    shader_program = ShaderProgram("resources/shaders/shader.vs", "resources/shaders/shader.fg")
    shader_program.init()

    global grid_model
    grid_model = Model([grid_vertices], indices=[grid_mesh])

    global camera_shader_program
    camera_shader_program = ShaderProgram("resources/shaders/camera_shader.vs", "resources/shaders/camera_shader.fg")
    camera_shader_program.init()

    global camera_model
    camera_vertices = np.array([0, 0, 0, 0, 0, -1, -1, 2, 0, 0,
                                0, 0, 0, 0, 0, 1, 1, 2, 0, 0,
                                0, 0, 0, 0, 0, 1, -1, 2, 0, 0,
                                0, 0, 0, 0, 0, -1, 1, 2, 0, 0,
                                -1, 1, 2, 0, 0, -1, -1, 2, 0, 0,
                                -1, -1, 2, 0, 0, 1, -1, 2, 0, 0,
                                1, -1, 2, 0, 0, 1, 1, 2, 0, 0,
                                1, 1, 2, 0, 0, -1, 1, 2, 0, 0], dtype=np.float32)

    camera_model = Model([camera_vertices]) 

    glEnable(GL_DEPTH_TEST)


def render():
    glClearColor(0, 0, 0, 0.0)
    glClearDepth(1.0)
    glPointSize(5)
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

    projection = glm.perspective(glm.radians(camera.zoom), window.window_width * 1.0 / window.window_height, 0.1,
                                 100000)
    view = camera.get_view_matrix()

    #
    # draw grid
    shader_program.use()
    shader_program.set_matrix("projection", glm.value_ptr(projection))
    shader_program.set_matrix("view", glm.value_ptr(view))

    m = glm.mat4(1.0)
    m = glm.translate(m, grid_position[2])
    m = glm.rotate(m, glm.radians(90), grid_position[1][1])
    m = glm.scale(m, glm.vec3(650))
    shader_program.set_matrix("model", glm.value_ptr(m))

    shader_program.un_use()
    grid_model.draw(shader_program, draw_type=GL_LINES)

    for conf in camera_config1:
        #
        # draw cameras
        camera_shader_program.use()
        camera_shader_program.set_matrix("projection", glm.value_ptr(projection))
        camera_shader_program.set_matrix("view", glm.value_ptr(view))
        camera_shader_program.set_uniform_3f("camera_color", [1., 0., 0.])

        m_rt = np.eye(4, dtype=np.float32)
        r = np.array(conf[0], dtype=np.float32).T
        m_rt[:-1, -1] = -r @ np.array(conf[1], dtype=np.float32).squeeze()
        m_rt[:-1, :-1] = r

        m_s = np.eye(4, dtype=np.float32) * 250
        m_s[3, 3] = 1

        camera_shader_program.set_matrix("model", (rorate_x_90 @ m_rt @ m_s).T)

        camera_shader_program.un_use()
        camera_model.draw(camera_shader_program, draw_type=GL_LINES)

    for conf in camera_config2:
        #
        # draw cameras
        camera_shader_program.use()
        camera_shader_program.set_matrix("projection", glm.value_ptr(projection))
        camera_shader_program.set_matrix("view", glm.value_ptr(view))
        camera_shader_program.set_uniform_3f("camera_color", [0., 1., 0.])

        m_rt = np.eye(4, dtype=np.float32)
        r = np.array(conf[0], dtype=np.float32).T
        m_rt[:-1, -1] = -r @ np.array(conf[1], dtype=np.float32).squeeze()
        m_rt[:-1, :-1] = r

        m_s = np.eye(4, dtype=np.float32) * 250
        m_s[3, 3] = 1

        camera_shader_program.set_matrix("model", (rorate_x_90 @ m_rt @ m_s).T)

        camera_shader_program.un_use()
        camera_model.draw(camera_shader_program, draw_type=GL_LINES)

def main():
    init()
    window.set_render_function(render)
    window.start_window_loop()


if __name__ == "__main__":
    main()