Exporters (.exporters)

Render Error Check (.exporters.render_error_check)

adaptive_sampling

exception infinigen2.exporters.render_error_check.adaptive_sampling.AdaptiveSamplingError

Bases: RuntimeError

infinigen2.exporters.render_error_check.adaptive_sampling.configure_sample_count_output(view_layer, folder)

Parameters:

• view_layer (ViewLayer)

• folder (Path)

infinigen2.exporters.render_error_check.adaptive_sampling.unconverged_fraction(sample_count_path) → float

Parameters:

sample_count_path (Path)

infinigen2.exporters.render_error_check.adaptive_sampling.assert_adaptive_sampling_converged(...) → dict[int, float]

Parameters:

• render_log (str)

• sample_count_folder (Path)

• max_samples (int)

• fail_fraction (float)

check_frames_valid

exception infinigen2.exporters.render_error_check.check_frames_valid.FrameCheckError

Bases: RuntimeError

infinigen2.exporters.render_error_check.check_frames_valid.frame_mean_pixel(path) → float

Parameters:

path (Path)

infinigen2.exporters.render_error_check.check_frames_valid.assert_frames_not_black(paths, mean_pixel_thresh) → dict[str, float]

Parameters:

• paths (list[Path])

• mean_pixel_thresh (float | None)

cycles_errors

exception infinigen2.exporters.render_error_check.cycles_errors.CyclesShaderError

Bases: RuntimeError

infinigen2.exporters.render_error_check.cycles_errors.detect_cycles_errors(replay=True) → Iterator[dict]

Parameters:

replay (bool) -- (default: True)

displacement

exception infinigen2.exporters.render_error_check.displacement.DisplacementCoordError

Bases: ValueError

infinigen2.exporters.render_error_check.displacement.unsafe_displacement_materials(materials=None) → dict[str, str]

Parameters:

materials (list[pf.Material] | None) -- (default: None)

infinigen2.exporters.render_error_check.displacement.assert_displacement_coords_safe(

objects=None,

displacement_mode=DisplacementMode.DISPLACEMENT_AND_BUMP,

)

Parameters:

• objects (list[pf.MeshObject] | None) -- (default: None)

• displacement_mode (DisplacementMode) -- (default: <DisplacementMode.DISPLACEMENT_AND_BUMP: 'BOTH'>)

finite_geometry

exception infinigen2.exporters.render_error_check.finite_geometry.NonFiniteGeometryError

Bases: ValueError

infinigen2.exporters.render_error_check.finite_geometry.nonfinite_vertex_counts(objects=None) → dict[str, int]

Parameters:

objects (list[pf.MeshObject] | None) -- (default: None)

infinigen2.exporters.render_error_check.finite_geometry.assert_geometry_finite(objects=None)

Parameters:

objects (list[pf.MeshObject] | None) -- (default: None)

material_attributes

exception infinigen2.exporters.render_error_check.material_attributes.MissingAttributeError

Bases: ValueError

infinigen2.exporters.render_error_check.material_attributes.missing_attribute_issues(obj) → list[str]

Parameters:

obj (Object)

infinigen2.exporters.render_error_check.material_attributes.assert_material_attributes_present(objects=None)

Parameters:

objects (list[pf.MeshObject] | None) -- (default: None)

material_nodes

exception infinigen2.exporters.render_error_check.material_nodes.MaterialNodeError

Bases: ValueError

infinigen2.exporters.render_error_check.material_nodes.material_node_issues(material) → dict[str, list[str]]

Parameters:

material (pf.Material)

infinigen2.exporters.render_error_check.material_nodes.assert_material_nodes_valid(objects=None)

Parameters:

objects (list[pf.MeshObject] | None) -- (default: None)

object_transform

exception infinigen2.exporters.render_error_check.object_transform.SingularTransformError

Bases: ValueError

infinigen2.exporters.render_error_check.object_transform.singular_transform_objects(objects=None) → dict[str, float]

Parameters:

objects (list[pf.MeshObject] | None) -- (default: None)

infinigen2.exporters.render_error_check.object_transform.assert_transforms_nonsingular(objects=None)

Parameters:

objects (list[pf.MeshObject] | None) -- (default: None)

object_visibility

exception infinigen2.exporters.render_error_check.object_visibility.HiddenRenderObjectError

Bases: RuntimeError

infinigen2.exporters.render_error_check.object_visibility.hidden_render_objects(objects) → dict[str, str]

Parameters:

objects (list[pf.MeshObject])

infinigen2.exporters.render_error_check.object_visibility.assert_render_objects_visible(objects=None)

Parameters:

objects (list[pf.MeshObject] | None) -- (default: None)

pre_render_validity

infinigen2.exporters.render_error_check.pre_render_validity.render_validity_check(

objects,

displacement_mode=DisplacementMode.DISPLACEMENT_AND_BUMP,

) → dict[ExportType, list[Path]]

Parameters:

• objects (list[pf.MeshObject])

• displacement_mode (DisplacementMode) -- (default: <DisplacementMode.DISPLACEMENT_AND_BUMP: 'BOTH'>)

shader_complexity

exception infinigen2.exporters.render_error_check.shader_complexity.ShaderTooComplexError

Bases: RuntimeError

infinigen2.exporters.render_error_check.shader_complexity.count_material_nodes(material) → int

Parameters:

material (pf.Material)

infinigen2.exporters.render_error_check.shader_complexity.assert_shader_complexity_ok(objects=None)

Parameters:

objects (list[pf.MeshObject] | None) -- (default: None)

util

infinigen2.exporters.render_error_check.util.iter_all_nodes(

node_tree,

nested=False,

seen=None,

) → Iterator[tuple[bpy_types.Node, bool]]

Parameters:

• node_tree (NodeTree)

• nested (bool) -- (default: False)

• seen (set[int] | None) -- (default: None)

infinigen2.exporters.render_error_check.util.flattened_node_count(node_tree, memo) → int

Parameters:

• node_tree (NodeTree)

• memo (dict[int, int])

infinigen2.exporters.render_error_check.util.active_material_output(tree) → bpy_types.Node | None

Parameters:

tree (NodeTree)

infinigen2.exporters.render_error_check.util.backward_reachable(socket) → Iterator[bpy_types.Node]

Parameters:

socket (NodeSocket)

infinigen2.exporters.render_error_check.util.context_meshes(objects) → list[bpy_types.Object]

Parameters:

objects (list[pf.MeshObject] | None)

infinigen2.exporters.render_error_check.util.evaluated_mesh(obj) → bpy_types.Mesh | None

Parameters:

obj (Object)

infinigen2.exporters.render_error_check.util.context_materials(objects) → list[pf.Material]

Parameters:

objects (list[pf.MeshObject] | None)

uv_coords

class infinigen2.exporters.render_error_check.uv_coords.UVLayerInfo(active_render, names, degenerate)

Bases: NamedTuple

active_render: str | None

names: tuple[str, ...]

degenerate: frozenset

exception infinigen2.exporters.render_error_check.uv_coords.UVCoordError

Bases: ValueError

infinigen2.exporters.render_error_check.uv_coords.check_material_uv_coords(obj, material=None, mat_index=None) → list[str]

Parameters:

• obj (Object)

• material (pf.Material | None) -- (default: None)

• mat_index (int | None) -- (default: None)

infinigen2.exporters.render_error_check.uv_coords.assert_uv_coords_satisfied(objects=None)

Parameters:

objects (list[pf.MeshObject] | None) -- (default: None)

Module contents

exception infinigen2.exporters.render_error_check.AdaptiveSamplingError

Bases: RuntimeError

exception infinigen2.exporters.render_error_check.CyclesShaderError

Bases: RuntimeError

exception infinigen2.exporters.render_error_check.DisplacementCoordError

Bases: ValueError

exception infinigen2.exporters.render_error_check.FrameCheckError

Bases: RuntimeError

exception infinigen2.exporters.render_error_check.HiddenRenderObjectError

Bases: RuntimeError

exception infinigen2.exporters.render_error_check.MaterialNodeError

Bases: ValueError

exception infinigen2.exporters.render_error_check.MissingAttributeError

Bases: ValueError

exception infinigen2.exporters.render_error_check.NonFiniteGeometryError

Bases: ValueError

exception infinigen2.exporters.render_error_check.ShaderTooComplexError

Bases: RuntimeError

exception infinigen2.exporters.render_error_check.SingularTransformError

Bases: ValueError

exception infinigen2.exporters.render_error_check.UVCoordError

Bases: ValueError

class infinigen2.exporters.render_error_check.UVLayerInfo(active_render, names, degenerate)

Bases: NamedTuple

active_render: str | None

names: tuple[str, ...]

degenerate: frozenset

infinigen2.exporters.render_error_check.assert_adaptive_sampling_converged(...) → dict[int, float]

Parameters:

• render_log (str)

• sample_count_folder (Path)

• max_samples (int)

• fail_fraction (float)

infinigen2.exporters.render_error_check.assert_displacement_coords_safe(

objects=None,

displacement_mode=DisplacementMode.DISPLACEMENT_AND_BUMP,

)

Parameters:

• objects (list[pf.MeshObject] | None) -- (default: None)

• displacement_mode (DisplacementMode) -- (default: <DisplacementMode.DISPLACEMENT_AND_BUMP: 'BOTH'>)

infinigen2.exporters.render_error_check.assert_frames_not_black(paths, mean_pixel_thresh) → dict[str, float]

Parameters:

• paths (list[Path])

• mean_pixel_thresh (float | None)

infinigen2.exporters.render_error_check.assert_geometry_finite(objects=None)

Parameters:

objects (list[pf.MeshObject] | None) -- (default: None)

infinigen2.exporters.render_error_check.assert_material_attributes_present(objects=None)

Parameters:

objects (list[pf.MeshObject] | None) -- (default: None)

infinigen2.exporters.render_error_check.assert_material_nodes_valid(objects=None)

Parameters:

objects (list[pf.MeshObject] | None) -- (default: None)

infinigen2.exporters.render_error_check.assert_render_objects_visible(objects=None)

Parameters:

objects (list[pf.MeshObject] | None) -- (default: None)

infinigen2.exporters.render_error_check.assert_shader_complexity_ok(objects=None)

Parameters:

objects (list[pf.MeshObject] | None) -- (default: None)

infinigen2.exporters.render_error_check.assert_transforms_nonsingular(objects=None)

Parameters:

objects (list[pf.MeshObject] | None) -- (default: None)

infinigen2.exporters.render_error_check.assert_uv_coords_satisfied(objects=None)

Parameters:

objects (list[pf.MeshObject] | None) -- (default: None)

infinigen2.exporters.render_error_check.check_material_uv_coords(obj, material=None, mat_index=None) → list[str]

Parameters:

• obj (Object)

• material (pf.Material | None) -- (default: None)

• mat_index (int | None) -- (default: None)

infinigen2.exporters.render_error_check.configure_sample_count_output(view_layer, folder)

Parameters:

• view_layer (ViewLayer)

• folder (Path)

infinigen2.exporters.render_error_check.count_material_nodes(material) → int

Parameters:

material (pf.Material)

infinigen2.exporters.render_error_check.detect_cycles_errors(replay=True) → Iterator[dict]

Parameters:

replay (bool) -- (default: True)

infinigen2.exporters.render_error_check.hidden_render_objects(objects) → dict[str, str]

Parameters:

objects (list[pf.MeshObject])

infinigen2.exporters.render_error_check.material_node_issues(material) → dict[str, list[str]]

Parameters:

material (pf.Material)

infinigen2.exporters.render_error_check.missing_attribute_issues(obj) → list[str]

Parameters:

obj (Object)

infinigen2.exporters.render_error_check.nonfinite_vertex_counts(objects=None) → dict[str, int]

Parameters:

objects (list[pf.MeshObject] | None) -- (default: None)

infinigen2.exporters.render_error_check.render_validity_check(

objects,

displacement_mode=DisplacementMode.DISPLACEMENT_AND_BUMP,

) → dict[ExportType, list[Path]]

Parameters:

• objects (list[pf.MeshObject])

• displacement_mode (DisplacementMode) -- (default: <DisplacementMode.DISPLACEMENT_AND_BUMP: 'BOTH'>)

infinigen2.exporters.render_error_check.singular_transform_objects(objects=None) → dict[str, float]

Parameters:

objects (list[pf.MeshObject] | None) -- (default: None)

infinigen2.exporters.render_error_check.unsafe_displacement_materials(materials=None) → dict[str, str]

Parameters:

materials (list[pf.Material] | None) -- (default: None)

imu

infinigen2.exporters.imu.get_camera_intrinsics(camera)

Parameters:

camera

infinigen2.exporters.imu.save_imu(...) → dict

Parameters:

• camera

• objects

• output_folder (Path)

• frame_start (int)

• frame_end (int)

infinigen2.exporters.imu.save_imu_tum_files(...)

Write imu and tum data to output files for each obj.

Parameters:

• output_folder

• objects (list[Object])

• frame_start (int | None) -- (default: None)

• frame_end (int | None) -- (default: None)

render_cycles

class infinigen2.exporters.render_cycles.DenoiseMode(value)

Bases: Enum

NONE = 'none'

BEST = 'best'

OPTIX = 'OPTIX'

OPENIMAGEDENOISE = 'OPENIMAGEDENOISE'

infinigen2.exporters.render_cycles.configure_cycles_devices(device_type='BEST_AVAILABLE')

Parameters:

device_type (str) -- (default: 'BEST_AVAILABLE')

infinigen2.exporters.render_cycles.configure_cycles_performance(...)

Parameters:

• max_samples (int)

• min_samples (int)

• samples_adaptive_threshold (float)

• film_exposure (float)

• volume_step_rate (float)

• volume_preview_step_rate (float)

• volume_max_steps (int)

• volume_bounces (int)

• max_bounces (int)

• diffuse_bounces (int)

• glossy_bounces (int)

• sample_clamp_indirect (float)

• sample_clamp_direct (float)

• transmission_bounces (int)

infinigen2.exporters.render_cycles.render_cycles(

...,

) → dict[ExportType, list[Path]]

Parameters:

• objects (list[pf.MeshObject])

• camera (CameraObject)

• output_folder (Path)

• render_passes (list[RenderPass])

• lights (list[LightObject] | None) -- (default: None)

• frame_start (int) -- (default: 1)

• frame_end (int) -- (default: 1)

• resolution (tuple[int, int]) -- (default: (1280, 720))

• frame_rate (int) -- (default: 24)

• device_type (str) -- (default: 'BEST_AVAILABLE')

• view_layer (ViewLayer) -- (default: None)

• depth_of_field_fstop (float | None) -- (default: None)

• motion_blur_shutter (float | None) -- (default: None)

• displacement_mode (DisplacementMode) -- (default: <DisplacementMode.DISPLACEMENT_AND_BUMP: 'BOTH'>)

• render_skip_existing (bool) -- (default: False)

• min_samples (int) -- (default: 32)

• max_samples (int) -- (default: 256)

• samples_adaptive_threshold (float) -- (default: 0.01)

• film_exposure (float) -- (default: 1.0)

• volume_step_rate (float) -- (default: 0.1)

• volume_preview_step_rate (float) -- (default: 0.1)

• volume_max_steps (int) -- (default: 32)

• volume_bounces (int) -- (default: 4)

• max_bounces (int) -- (default: 4)

• diffuse_bounces (int) -- (default: 4)

• glossy_bounces (int) -- (default: 4)

• sample_clamp_indirect (float) -- (default: 10.0)

• sample_clamp_direct (float) -- (default: 10.0)

• transmission_bounces (int) -- (default: 2)

• denoise_mode (DenoiseMode) -- (default: <DenoiseMode.BEST: 'best'>)

• fail_for_black_frame_thresh (float | None) -- (default: 0.02)

• fail_for_unconverged_pix_frac (float | None) -- (default: None)

infinigen2.exporters.render_cycles.render_cycles_ground_truth(

...,

) → dict[ExportType, list[Path]]

Parameters:

• objects (list[pf.MeshObject])

• camera (CameraObject)

• output_folder (Path)

• render_passes (list[RenderPass])

• lights (list[LightObject] | None) -- (default: None)

• frame_start (int) -- (default: 1)

• frame_end (int) -- (default: 1)

• resolution (tuple[int, int]) -- (default: (1280, 720))

• frame_rate (int) -- (default: 24)

• device_type (str) -- (default: 'BEST_AVAILABLE')

• view_layer (ViewLayer) -- (default: None)

• depth_of_field_fstop (float | None) -- (default: None)

• motion_blur_shutter (float | None) -- (default: None)

• displacement_mode (DisplacementMode) -- (default: <DisplacementMode.DISPLACEMENT_AND_BUMP: 'BOTH'>)

• render_skip_existing (bool) -- (default: False)

• min_samples (int) -- (default: 32)

• max_samples (int) -- (default: 256)

• samples_adaptive_threshold (float) -- (default: 0.01)

• film_exposure (float) -- (default: 1.0)

• volume_step_rate (float) -- (default: 0.1)

• volume_preview_step_rate (float) -- (default: 0.1)

• volume_max_steps (int) -- (default: 32)

• volume_bounces (int) -- (default: 4)

• max_bounces (int) -- (default: 4)

• diffuse_bounces (int) -- (default: 4)

• glossy_bounces (int) -- (default: 4)

• sample_clamp_indirect (float) -- (default: 10.0)

• sample_clamp_direct (float) -- (default: 10.0)

• transmission_bounces (int) -- (default: 2)

• denoise_mode (DenoiseMode) -- (default: <DenoiseMode.BEST: 'best'>)

render_eevee

class infinigen2.exporters.render_eevee.RenderEeveeParams(

taa_render_samples: int = 64,

use_taa_reprojection: bool = True,

film_exposure: float = 1.0,

taa_samples: int = 16,

use_gtao: bool = False,

gtao_distance: float = 0.2,

gtao_quality: float = 0.25,

use_shadows: bool = True,

shadow_pool_size: int = '512',

shadow_ray_count: int = 1,

shadow_resolution_scale: float = 1.0,

shadow_step_count: int = 6,

use_raytracing: bool = False,

ray_tracing_method: str = 'SCREEN',

use_fast_gi: bool = False,

fast_gi_method: str = 'GLOBAL_ILLUMINATION',

fast_gi_ray_count: int = 2,

fast_gi_resolution: str = '2',

fast_gi_step_count: int = 8,

fast_gi_quality: float = 0.25,

fast_gi_bias: float = 0.05,

fast_gi_distance: float = 0.0,

fast_gi_thickness_far: float = 0.785,

fast_gi_thickness_near: float = 0.25,

use_overscan: bool = False,

overscan_size: float = 3.0,

use_volume_custom_range: bool = False,

volumetric_start: float = 0.1,

volumetric_end: float = 100.0,

volumetric_samples: int = 64,

volumetric_shadow_samples: int = 16,

volumetric_tile_size: str = '8',

volumetric_sample_rand: float = 0.8,

volumetric_light_clamp: float = 0.0,

volumetric_ray_depth: int = 16,

use_volumetric_shadows: bool = False,

)

Bases: object

Parameters:

• taa_render_samples (int)

• use_taa_reprojection (bool)

• film_exposure (float)

• taa_samples (int)

• use_gtao (bool)

• gtao_distance (float)

• gtao_quality (float)

• use_shadows (bool)

• shadow_pool_size (int)

• shadow_ray_count (int)

• shadow_resolution_scale (float)

• shadow_step_count (int)

• use_raytracing (bool)

• ray_tracing_method (str)

• use_fast_gi (bool)

• fast_gi_method (str)

• fast_gi_ray_count (int)

• fast_gi_resolution (str)

• fast_gi_step_count (int)

• fast_gi_quality (float)

• fast_gi_bias (float)

• fast_gi_distance (float)

• fast_gi_thickness_far (float)

• fast_gi_thickness_near (float)

• use_overscan (bool)

• overscan_size (float)

• use_volume_custom_range (bool)

• volumetric_start (float)

• volumetric_end (float)

• volumetric_samples (int)

• volumetric_shadow_samples (int)

• volumetric_tile_size (str)

• volumetric_sample_rand (float)

• volumetric_light_clamp (float)

• volumetric_ray_depth (int)

• use_volumetric_shadows (bool)

taa_render_samples: int = 64

use_taa_reprojection: bool = True

film_exposure: float = 1.0

taa_samples: int = 16

use_gtao: bool = False

gtao_distance: float = 0.2

gtao_quality: float = 0.25

use_shadows: bool = True

shadow_pool_size: int = '512'

shadow_ray_count: int = 1

shadow_resolution_scale: float = 1.0

shadow_step_count: int = 6

use_raytracing: bool = False

ray_tracing_method: str = 'SCREEN'

use_fast_gi: bool = False

fast_gi_method: str = 'GLOBAL_ILLUMINATION'

fast_gi_ray_count: int = 2

fast_gi_resolution: str = '2'

fast_gi_step_count: int = 8

fast_gi_quality: float = 0.25

fast_gi_bias: float = 0.05

fast_gi_distance: float = 0.0

fast_gi_thickness_far: float = 0.785398

fast_gi_thickness_near: float = 0.25

use_overscan: bool = False

overscan_size: float = 3.0

use_volume_custom_range: bool = False

volumetric_start: float = 0.1

volumetric_end: float = 100.0

volumetric_samples: int = 64

volumetric_shadow_samples: int = 16

volumetric_tile_size: str = '8'

volumetric_sample_rand: float = 0.8

volumetric_light_clamp: float = 0.0

volumetric_ray_depth: int = 16

use_volumetric_shadows: bool = False

infinigen2.exporters.render_eevee.configure_eevee_params(params)

Parameters:

params (RenderEeveeParams)

infinigen2.exporters.render_eevee.render_eevee(

...,

) → dict[ExportType, list[Path]]

Render using Eevee with multiple passes

Parameters:

• objects (list[pf.MeshObject])

• camera (CameraObject)

• output_folder (Path)

• render_passes (list[RenderPass])

• frame_start (int)

• frame_end (int)

• lights (list[LightObject] | None) -- (default: None)

• resolution (tuple[int, int]) -- (default: (1280, 720))

• frame_rate (int) -- (default: 24)

• view_layer (ViewLayer) -- (default: None)

• depth_of_field_fstop (float | None) -- (default: None)

• motion_blur_shutter (float | None) -- (default: None)

• displacement_mode (DisplacementMode) -- (default: <DisplacementMode.DISPLACEMENT_AND_BUMP: 'BOTH'>)

• allow_gt_types (bool) -- (default: False)

• parameters (Unpack[RenderEeveeParams])

infinigen2.exporters.render_eevee.render_eevee_ground_truth(

...,

) → dict[ExportType, list[Path]]

Parameters:

• objects (list[pf.MeshObject])

• camera (CameraObject)

• output_folder (Path)

• render_passes (list[RenderPass])

• frame_start (int)

• frame_end (int)

• lights (list[LightObject] | None) -- (default: None)

• resolution (tuple[int, int]) -- (default: (1280, 720))

• frame_rate (int) -- (default: 24)

• view_layer (ViewLayer) -- (default: None)

• depth_of_field_fstop (float | None) -- (default: None)

• motion_blur_shutter (float | None) -- (default: None)

• displacement_mode (DisplacementMode) -- (default: <DisplacementMode.DISPLACEMENT_AND_BUMP: 'BOTH'>)

• parameters (Unpack[RenderEeveeParams])

render_workbench

infinigen2.exporters.render_workbench.render_workbench(

...,

) → dict[ExportType, list[Path]]

Parameters:

• objects (list[pf.MeshObject])

• camera (CameraObject)

• output_folder (Path)

• render_passes (list[RenderPass])

• lights (list[LightObject] | None) -- (default: None)

• frame_start (int) -- (default: 1)

• frame_end (int) -- (default: 1)

• resolution (tuple[int, int]) -- (default: (1280, 720))

• frame_rate (int) -- (default: 24)

• displacement_mode (DisplacementMode) -- (default: <DisplacementMode.DISPLACEMENT_AND_BUMP: 'BOTH'>)

• render_skip_existing (bool) -- (default: False)

• lighting (str) -- (default: 'MATCAP')

• color_type (str) -- (default: 'RANDOM')

• studio_light (str) -- (default: 'studio.sl')

• matcap_light (str) -- (default: 'basic_1.exr')

• samples (int) -- (default: 16)

visualize_gt

infinigen2.exporters.visualize_gt.visualize_gt(

exports,

output_folder,

) → dict[ExportType, list[Path]]

Parameters:

• exports (dict[ExportType, list[Path]] | list[dict[ExportType, list[Path]]])

• output_folder (Path)

Module contents

class infinigen2.exporters.DisplacementMode(value)

Bases: Enum

NONE = 'NONE'

BUMP = 'BUMP'

DISPLACEMENT = 'DISPLACEMENT'

DISPLACEMENT_AND_BUMP = 'BOTH'

REALIZE_MESH = 'REALIZE_MESH'

class infinigen2.exporters.ExportType(value)

Bases: Enum

CAMERA = 'camera'

IMAGE = 'rgb'

IMAGE_DENOISED = 'rgb-denoised'

IMAGE_HDR = 'rgb-hdr'

IMAGE_DENOISED_HDR = 'rgb-denoised-hdr'

BLENDER_FILE = 'scene'

CAM_IMU_TUM_TRAJ = 'cam-trajectory-imu-tum'

OBJ_IMU_TUM_TRAJ = 'obj-trajectory-imu-tum'

MESH = 'mesh'

OBJECTS_FILE = 'objects'

OBJECT_DATA = 'object-data'

OPTICAL_FLOW = 'optical-flow'

DEPTH_CHANGE = 'depth-change'

FLOW_3D = 'flow-3d'

FLOW_MASK_MATCHED = 'flow-mask-matched'

FLOW_MASK_CYCLECONSISTENCY = 'flow-mask-cycle-consistency'

INV_FLOW = 'inv-flow-3d'

POINT_TRAJECTORIES = 'point-trajectories-3d'

INV_POINT_TRAJECTORIES = 'inv-point-trajectories-3d'

DEPTH = 'depth'

SURFACE_NORMAL = 'surface-normal'

SURFACE_NORMAL_WORLD = 'surface-normal-world'

OCCLUSION_BOUNDARIES = 'occlusion'

OBJECT_INDEX = 'semantic-segmentation'

INSTANCE_SEGMENTATION = 'instance-segmentation'

MATERIAL_INDEX = 'material-segmentation'

OBJECT_INDEX_TABLE = 'object-index-table'

MATERIAL_INDEX_TABLE = 'material-index-table'

ATTRIBUTE_MASK = 'attribute-mask'

VISUALIZATIONS = 'visualizations'

DIFFUSE_COLOR = 'diffuse-color'

AMBIENT_OCCLUSION = 'ambient-occlusion'

DIFFUSE_DIRECT = 'diffuse-direct'

DIFFUSE_INDIRECT = 'diffuse-indirect'

GLOSSY_DIRECT = 'glossy-direct'

GLOSSY_INDIRECT = 'glossy-indirect'

TRANSMISSION_DIRECT = 'transmission-direct'

TRANSMISSION_INDIRECT = 'transmission-indirect'

VOLUME_DIRECT = 'volume-direct'

EMISSION = 'emission'

ENVIRONMENT = 'environment'

class infinigen2.exporters.RenderPass(

type: ExportType,

path: Path,

data_type: dtype,

)

Bases: object

Parameters:

• type (ExportType)

• path (Path)

• data_type (dtype)