Simple way to deactivate prims based on camera intersection

[jcoelho88]

I wanted to share something we are looking to use in a possible workflow.

We have seen a need on our end to be able to quickly clean up prims that never cross the camera in a shot.

We've done this before with just pure Maya data, you can see the inspiration for this here: https://gizmosandgames.com/2017/05/21/frustum-culling-in-maya/

To do the same on a USD stage we made a function that will do essentially the same thing.

from pxr import Sdf, Usd, UsdUtils, Gf, UsdGeom

def get_none_intersecting_prims(stage, camera_path, return_reverse=False):
    # Get frame range of stage
    start_frame = int(stage.GetStartTimeCode())
    end_frame = int(stage.GetEndTimeCode())

    # Determine the list of prims we want to check:
    # Visible meshes (not hidden)
    prims_to_check = set()
    for prim in stage.Traverse():
        prim_type = prim.GetTypeName()
        if prim_type == 'Mesh' or prim.IsInstance() is True:
            mesh = UsdGeom.Mesh(prim)
            visible_state = mesh.ComputeEffectiveVisibility()
            if visible_state == 'visible':
                prims_to_check.add(prim)

    # Create the BBox cache
    bounding_box_cache = UsdGeom.BBoxCache(
        Usd.TimeCode().Default(),
        UsdGeom.Imageable.GetOrderedPurposeTokens()
    )

    # Get the camera
    camera_prim = stage.GetPrimAtPath(camera_path)
    camera_geom = UsdGeom.Camera(camera_prim)

    # Check each every prim on every frame.
    visible_prims = set()
    for f in range(start_frame, end_frame + 1):
        bounding_box_cache.SetTime(f)
        
        # Get the camera frustum
        camera_gf = camera_geom.GetCamera(f)
        frustum = camera_gf.frustum
        for prim in prims_to_check:
            bbox = bounding_box_cache.ComputeWorldBound(prim)
            if frustum.Intersects(bbox):
                visible_prims.add(prim)
        # Once a prim is deemed visible, we don't need to check in again on further frames
        prims_to_check = prims_to_check - visible_prims
        if not prims_to_check:
            break

    if return_reverse:
        return visible_prims
        
    return prims_to_check

The function takes a stage and the prim path to a camera you want to check the intersections with.

It currently only cares to check the visibility of Mesh types or if a prim is an instance.

The reason for checking for an instance is because if there was a mesh whos bounding box intersected with the camera you would not be able to give an opinion to either keep it active or deactivate, this way the parent prim of that instance mesh is what will be active or deactivated.

You can make adjustments by changing what its going to be checking for intersects.

Once it has the list of prims it creates a bounding box cache and gets the cameras frustum. It will loop through the stages time range and confirm which prims bounding boxes intersect with the camera and returns you that list.

You can do whatever you want with the returned list of prims, in our case we deactivate them. Just be aware that in some cases you would want to keep some meshes who's prims do not intersect active(for shadows and the like)

prims_to_deactivate = get_none_intersecting_prims(stage, camera_prim_path)

for prim in prims_to_deactivate:
    prim.SetActive(False)

I hope this can be helpful and would like to know if anyone has any other ideas where camera based intersects can be used.

Cheers,

Jason Coelho

Edit: I realized the name of the function was not descriptive of it's actual purpose so I changed it.

[wallworm]

Thank you for sharing that with us! :)