How do I know which meshes can be seen by one camera but not by another?

Question

I now have a need like this: I have two cameras in blender, marked A and B. I want to know which meshes A can see but B cannot?

Answer 1

Thanks to everyone's help, I finally solved the problem. I put my approach here, it may not be the best way, but it works. You can try the following code, copy the code into blender and run it. This code will do the following things:

1. Remove all the existing object in the scene.
2. Add a camera and config the rendering setting.
3. Add a "monkey".
4. Calculate the rays that the camera should emit.
5. Calculate the faces that hit by rays.
6. Delete the faces that not hit by rays.
7. Add some cylinders to represent rays (for debugging).

If everything works perfectly, you will find all the meshes that can not seen by the camera are removed.Like the following picture.

import numpy as np
import bpy
import bmesh
import mathutils
def delete_objects(del_obj):
    with bpy.context.temp_override(window=bpy.context.window, selected_objects=list(del_obj)):
        bpy.ops.object.delete()
def init():
    if bpy.context.mode != 'OBJECT':
        bpy.ops.object.mode_set(mode='OBJECT')
    delete_objects([ob for ob in bpy.context.scene.objects])
    # set the camera
    bpy.ops.object.add(location=(0, 0, 0), type='EMPTY')
    camera_parent = bpy.context.active_object
    bpy.ops.object.camera_add()
    camera = bpy.context.active_object
    camera.parent = camera_parent
    camera.data.shift_x = 0
    camera.data.shift_y = 0
    camera.data.clip_start = 0.1
    camera.data.clip_end = 1e6
    camera.data.angle = 0.785398
    camera.data.type = 'PERSP'
    camera_constraint = camera.constraints.new(type='TRACK_TO')
    camera_constraint.track_axis = 'TRACK_NEGATIVE_Z'
    camera_constraint.up_axis = 'UP_Y'
    camera_constraint.target = camera.parent
    bpy.context.scene.camera = camera
    camera.location = (0, 0, 8)
    bpy.context.scene.render.film_transparent = True
    bpy.context.scene.world.use_nodes = False
    bpy.context.scene.world.color = (0, 0, 0)
    bpy.context.scene.render.resolution_x = 800
    bpy.context.scene.render.resolution_y = 400
    # add a monkey
    bpy.ops.mesh.primitive_monkey_add(enter_editmode=False, align='WORLD', location=(0, 0, 0), scale=(1, 1, 1))
def get_rays():
    # Get the real fov, because the fov in blender is actually the fov of the widest side.
    reso_x, reso_y = bpy.context.scene.render.resolution_x * bpy.context.scene.render.resolution_percentage / 100, bpy.context.scene.render.resolution_y * bpy.context.scene.render.resolution_percentage / 100
    aspe_x, aspe_y = bpy.context.scene.render.pixel_aspect_x, bpy.context.scene.render.pixel_aspect_y
    fov = bpy.context.scene.camera.data.angle
    if reso_x * aspe_x >= reso_y * aspe_y:
        fov_x, fov_y = fov, fov / (reso_x * aspe_x) * (reso_y * aspe_y)
    else:
        fov_y, fov_x = fov, fov / (reso_y * aspe_y) * (reso_x * aspe_x)
    # Calculate the direction of the ray
    K = np.array([[1. / np.tan(fov_x * 0.5) * 0.5, 0., 0.5], [0., 1. / np.tan(fov_y * 0.5) * 0.5, 0.5], [0, 0., 1]])
    c2w = np.array(bpy.context.scene.camera.matrix_world)
    # note: the 2 here is something that like upper sampling.
    # I found that if the rays are too sparse, there may be some problems,
    # because ray_cast will only return one of the faces when it hits a point or line.
    i, j = np.meshgrid(np.linspace(0, 1, int(reso_x  2)), np.linspace(0, 1, int(reso_y * 2)), indexing="xy")
    dirs = np.stack([(i - K[0][2]) / K[0][0], -(j - K[1][2]) / K[1][1], -np.ones_like(i)], -1)
    # This line is a matrix multiplication, but with some transpositions on both the input and output.
    dirs = np.einsum('H W j , i j->H W i', dirs, c2w[:3, :3])
    return dirs
def main():
    init()
    bpy.context.scene.camera.parent.rotation_euler = (np.pi / 6, np.pi / 4, 0)
    bpy.context.view_layer.update()
    cam_location = bpy.context.scene.camera.matrix_world.translation
    rays = get_rays()
    short = [rays[0][0], rays[0][-1], rays[-1][0], rays[-1][-1]]
    # ray_cast!
    # note we need to put all the faces that hit by the ray_cast to a set, and then delete them together.
    mapps = {}
    for ray_direction_world in rays.reshape((-1, rays.shape[-1])):
        result, location, normal, index, obj, matrix = bpy.context.scene.ray_cast(bpy.context.view_layer.depsgraph, cam_location, ray_direction_world)
        if result:
            if mapps.get(obj) is None:
                mapps[obj] = set()
            mapps[obj].add(index)
for obj, v in mapps.items():
    bpy.context.view_layer.objects.active = obj
    bpy.ops.object.mode_set(mode='EDIT')
    bpy.ops.mesh.select_mode(type='FACE')
    bm = bmesh.from_edit_mesh(obj.data)
    bm.faces.ensure_lookup_table()
    # When entering the face editing mode, all faces of the current object will be selected.
    for i in v:
        bm.faces[i].select = False
    bpy.ops.mesh.delete(type='ONLY_FACE')
    bpy.ops.object.mode_set(mode='OBJECT')

# add some cylinders to represent rays
for ray_direction_world in short:
    bpy.ops.mesh.primitive_cylinder_add(radius=0.005, depth=100, enter_editmode=False, align='WORLD', location=cam_location, scale=(1, 1, 1))
    ray_object = bpy.context.object
    ray_object.rotation_euler = mathutils.Vector(ray_direction_world).to_track_quat('Z', 'Y').to_euler()  # 设置射线方向



main()