Add files using upload-large-folder tool

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/configs/overfit_base.yaml

@@ -0,0 +1,79 @@
+defaults:
+- default_config
+- _self_
+exp_dir: ./data/exps/overfit_base/
+training_loop_ImplicitronTrainingLoop_args:
+  visdom_port: 8097
+  visualize_interval: 0
+  max_epochs: 1000
+data_source_ImplicitronDataSource_args:
+  data_loader_map_provider_class_type: SequenceDataLoaderMapProvider
+  dataset_map_provider_class_type: JsonIndexDatasetMapProvider
+  data_loader_map_provider_SequenceDataLoaderMapProvider_args:
+    dataset_length_train: 1000
+    dataset_length_val: 1
+    num_workers: 8
+  dataset_map_provider_JsonIndexDatasetMapProvider_args:
+    dataset_root: ${oc.env:CO3D_DATASET_ROOT}
+    n_frames_per_sequence: -1
+    test_on_train: true
+    test_restrict_sequence_id: 0
+    dataset_JsonIndexDataset_args:
+      load_point_clouds: false
+      mask_depths: false
+      mask_images: false
+model_factory_ImplicitronModelFactory_args:
+  model_class_type: "OverfitModel"
+  model_OverfitModel_args:
+    loss_weights:
+      loss_mask_bce: 1.0
+      loss_prev_stage_mask_bce: 1.0
+      loss_autodecoder_norm: 0.01
+      loss_rgb_mse: 1.0
+      loss_prev_stage_rgb_mse: 1.0
+    output_rasterized_mc: false
+    chunk_size_grid: 102400
+    render_image_height: 400
+    render_image_width: 400
+    share_implicit_function_across_passes: false
+    implicit_function_class_type: "NeuralRadianceFieldImplicitFunction"
+    implicit_function_NeuralRadianceFieldImplicitFunction_args:
+      n_harmonic_functions_xyz: 10
+      n_harmonic_functions_dir: 4
+      n_hidden_neurons_xyz: 256
+      n_hidden_neurons_dir: 128
+      n_layers_xyz: 8
+      append_xyz:
+      - 5
+    coarse_implicit_function_class_type: "NeuralRadianceFieldImplicitFunction"
+    coarse_implicit_function_NeuralRadianceFieldImplicitFunction_args:
+      n_harmonic_functions_xyz: 10
+      n_harmonic_functions_dir: 4
+      n_hidden_neurons_xyz: 256
+      n_hidden_neurons_dir: 128
+      n_layers_xyz: 8
+      append_xyz:
+      - 5
+    raysampler_AdaptiveRaySampler_args:
+      n_rays_per_image_sampled_from_mask: 1024
+      scene_extent: 8.0
+      n_pts_per_ray_training: 64
+      n_pts_per_ray_evaluation: 64
+      stratified_point_sampling_training: true
+      stratified_point_sampling_evaluation: false
+    renderer_MultiPassEmissionAbsorptionRenderer_args:
+      n_pts_per_ray_fine_training: 64
+      n_pts_per_ray_fine_evaluation: 64
+      append_coarse_samples_to_fine: true
+      density_noise_std_train: 1.0
+optimizer_factory_ImplicitronOptimizerFactory_args:
+  breed: Adam
+  weight_decay: 0.0
+  lr_policy: MultiStepLR
+  multistep_lr_milestones: []
+  lr: 0.0005
+  gamma: 0.1
+  momentum: 0.9
+  betas:
+  - 0.9
+  - 0.999

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/configs/overfit_singleseq_base.yaml

@@ -0,0 +1,42 @@
+defaults:
+- overfit_base
+- _self_
+data_source_ImplicitronDataSource_args:
+  data_loader_map_provider_SequenceDataLoaderMapProvider_args:
+    batch_size: 1
+    dataset_length_train: 1000
+    dataset_length_val: 1
+    num_workers: 8
+  dataset_map_provider_JsonIndexDatasetMapProvider_args:
+    assert_single_seq: true
+    n_frames_per_sequence: -1
+    test_restrict_sequence_id: 0
+    test_on_train: false
+model_factory_ImplicitronModelFactory_args:
+  model_class_type: "OverfitModel"
+  model_OverfitModel_args:
+    render_image_height: 800
+    render_image_width: 800
+    log_vars:
+    - loss_rgb_psnr_fg
+    - loss_rgb_psnr
+    - loss_eikonal
+    - loss_prev_stage_rgb_psnr
+    - loss_mask_bce
+    - loss_prev_stage_mask_bce
+    - loss_rgb_mse
+    - loss_prev_stage_rgb_mse
+    - loss_depth_abs
+    - loss_depth_abs_fg
+    - loss_kl
+    - loss_mask_neg_iou
+    - objective
+    - epoch
+    - sec/it
+optimizer_factory_ImplicitronOptimizerFactory_args:
+  lr: 0.0005
+  multistep_lr_milestones:
+  - 200
+  - 300
+training_loop_ImplicitronTrainingLoop_args:
+  max_epochs: 400

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/configs/overfit_singleseq_nerf_blender.yaml

@@ -0,0 +1,56 @@
+defaults:
+- overfit_singleseq_base
+- _self_
+exp_dir: "./data/overfit_nerf_blender_repro/${oc.env:BLENDER_SINGLESEQ_CLASS}"
+data_source_ImplicitronDataSource_args:
+  data_loader_map_provider_SequenceDataLoaderMapProvider_args:
+    dataset_length_train: 100
+  dataset_map_provider_class_type: BlenderDatasetMapProvider
+  dataset_map_provider_BlenderDatasetMapProvider_args:
+    base_dir: ${oc.env:BLENDER_DATASET_ROOT}/${oc.env:BLENDER_SINGLESEQ_CLASS}
+    n_known_frames_for_test: null
+    object_name: ${oc.env:BLENDER_SINGLESEQ_CLASS}
+    path_manager_factory_class_type: PathManagerFactory
+    path_manager_factory_PathManagerFactory_args:
+      silence_logs: true
+
+model_factory_ImplicitronModelFactory_args:
+  model_class_type: "OverfitModel"
+  model_OverfitModel_args:
+    mask_images: false
+    raysampler_class_type: AdaptiveRaySampler
+    raysampler_AdaptiveRaySampler_args:
+      n_pts_per_ray_training: 64
+      n_pts_per_ray_evaluation: 64
+      n_rays_per_image_sampled_from_mask: 4096
+      stratified_point_sampling_training: true
+      stratified_point_sampling_evaluation: false
+      scene_extent: 2.0
+      scene_center:
+      - 0.0
+      - 0.0
+      - 0.0
+    renderer_MultiPassEmissionAbsorptionRenderer_args:
+      density_noise_std_train: 0.0
+      n_pts_per_ray_fine_training: 128
+      n_pts_per_ray_fine_evaluation: 128
+      raymarcher_EmissionAbsorptionRaymarcher_args:
+        blend_output: false
+    loss_weights:
+      loss_rgb_mse: 1.0
+      loss_prev_stage_rgb_mse: 1.0
+      loss_mask_bce: 0.0
+      loss_prev_stage_mask_bce: 0.0
+      loss_autodecoder_norm: 0.00
+
+optimizer_factory_ImplicitronOptimizerFactory_args:
+  exponential_lr_step_size: 3001
+  lr_policy: LinearExponential
+  linear_exponential_lr_milestone: 200
+
+training_loop_ImplicitronTrainingLoop_args:
+  max_epochs: 6000
+  metric_print_interval: 10
+  store_checkpoints_purge: 3
+  test_when_finished: true
+  validation_interval: 100

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/configs/repro_base.yaml

@@ -0,0 +1,80 @@
+defaults:
+- default_config
+- _self_
+exp_dir: ./data/exps/base/
+training_loop_ImplicitronTrainingLoop_args:
+  visdom_port: 8097
+  visualize_interval: 0
+  max_epochs: 1000
+data_source_ImplicitronDataSource_args:
+  data_loader_map_provider_class_type: SequenceDataLoaderMapProvider
+  dataset_map_provider_class_type: JsonIndexDatasetMapProvider
+  data_loader_map_provider_SequenceDataLoaderMapProvider_args:
+    dataset_length_train: 1000
+    dataset_length_val: 1
+    num_workers: 8
+  dataset_map_provider_JsonIndexDatasetMapProvider_args:
+    dataset_root: ${oc.env:CO3D_DATASET_ROOT}
+    n_frames_per_sequence: -1
+    test_on_train: true
+    test_restrict_sequence_id: 0
+    dataset_JsonIndexDataset_args:
+      load_point_clouds: false
+      mask_depths: false
+      mask_images: false
+model_factory_ImplicitronModelFactory_args:
+  model_GenericModel_args:
+    loss_weights:
+      loss_mask_bce: 1.0
+      loss_prev_stage_mask_bce: 1.0
+      loss_autodecoder_norm: 0.01
+      loss_rgb_mse: 1.0
+      loss_prev_stage_rgb_mse: 1.0
+    output_rasterized_mc: false
+    chunk_size_grid: 102400
+    render_image_height: 400
+    render_image_width: 400
+    num_passes: 2
+    implicit_function_NeuralRadianceFieldImplicitFunction_args:
+      n_harmonic_functions_xyz: 10
+      n_harmonic_functions_dir: 4
+      n_hidden_neurons_xyz: 256
+      n_hidden_neurons_dir: 128
+      n_layers_xyz: 8
+      append_xyz:
+      - 5
+    raysampler_AdaptiveRaySampler_args:
+      n_rays_per_image_sampled_from_mask: 1024
+      scene_extent: 8.0
+      n_pts_per_ray_training: 64
+      n_pts_per_ray_evaluation: 64
+      stratified_point_sampling_training: true
+      stratified_point_sampling_evaluation: false
+    renderer_MultiPassEmissionAbsorptionRenderer_args:
+      n_pts_per_ray_fine_training: 64
+      n_pts_per_ray_fine_evaluation: 64
+      append_coarse_samples_to_fine: true
+      density_noise_std_train: 1.0
+    view_pooler_args:
+      view_sampler_args:
+        masked_sampling: false
+    image_feature_extractor_ResNetFeatureExtractor_args:
+      stages:
+      - 1
+      - 2
+      - 3
+      - 4
+      proj_dim: 16
+      image_rescale: 0.32
+      first_max_pool: false
+optimizer_factory_ImplicitronOptimizerFactory_args:
+  breed: Adam
+  weight_decay: 0.0
+  lr_policy: MultiStepLR
+  multistep_lr_milestones: []
+  lr: 0.0005
+  gamma: 0.1
+  momentum: 0.9
+  betas:
+  - 0.9
+  - 0.999

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/configs/repro_multiseq_base.yaml

@@ -0,0 +1,38 @@
+defaults:
+- repro_base.yaml
+- _self_
+data_source_ImplicitronDataSource_args:
+  data_loader_map_provider_SequenceDataLoaderMapProvider_args:
+    batch_size: 10
+    dataset_length_train: 1000
+    dataset_length_val: 1
+    num_workers: 8
+    train_conditioning_type: SAME
+    val_conditioning_type: SAME
+    test_conditioning_type: SAME
+    images_per_seq_options:
+    - 2
+    - 3
+    - 4
+    - 5
+    - 6
+    - 7
+    - 8
+    - 9
+    - 10
+  dataset_map_provider_JsonIndexDatasetMapProvider_args:
+    assert_single_seq: false
+    task_str: multisequence
+    n_frames_per_sequence: -1
+    test_on_train: true
+    test_restrict_sequence_id: 0
+optimizer_factory_ImplicitronOptimizerFactory_args:
+  multistep_lr_milestones:
+  - 1000
+training_loop_ImplicitronTrainingLoop_args:
+  max_epochs: 3000
+  evaluator_ImplicitronEvaluator_args:
+    camera_difficulty_bin_breaks:
+      - 0.666667
+      - 0.833334
+    is_multisequence: true

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/configs/repro_multiseq_nerf_ad.yaml

@@ -0,0 +1,12 @@
+defaults:
+- repro_multiseq_base.yaml
+- _self_
+model_factory_ImplicitronModelFactory_args:
+  model_GenericModel_args:
+    chunk_size_grid: 16000
+    view_pooler_enabled: false
+    global_encoder_class_type: SequenceAutodecoder
+    global_encoder_SequenceAutodecoder_args:
+      autodecoder_args:
+        n_instances: 20000
+        encoding_dim: 256

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/configs/repro_multiseq_nerformer.yaml

@@ -0,0 +1,18 @@
+defaults:
+- repro_multiseq_base.yaml
+- repro_feat_extractor_transformer.yaml
+- _self_
+model_factory_ImplicitronModelFactory_args:
+  model_GenericModel_args:
+    chunk_size_grid: 16000
+    raysampler_AdaptiveRaySampler_args:
+      n_rays_per_image_sampled_from_mask: 800
+      n_pts_per_ray_training: 32
+      n_pts_per_ray_evaluation: 32
+    renderer_MultiPassEmissionAbsorptionRenderer_args:
+      n_pts_per_ray_fine_training: 16
+      n_pts_per_ray_fine_evaluation: 16
+    implicit_function_class_type: NeRFormerImplicitFunction
+    view_pooler_enabled: true
+    view_pooler_args:
+      feature_aggregator_class_type: IdentityFeatureAggregator

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/configs/repro_multiseq_nerformer_angle_w.yaml

@@ -0,0 +1,7 @@
+defaults:
+- repro_multiseq_nerformer.yaml
+- _self_
+model_factory_ImplicitronModelFactory_args:
+  model_GenericModel_args:
+    view_pooler_args:
+      feature_aggregator_class_type: AngleWeightedIdentityFeatureAggregator

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/configs/repro_multiseq_srn_ad_hypernet_noharm.yaml

@@ -0,0 +1,11 @@
+defaults:
+- repro_multiseq_srn_ad_hypernet.yaml
+- _self_
+model_factory_ImplicitronModelFactory_args:
+  model_GenericModel_args:
+    num_passes: 1
+    implicit_function_SRNHyperNetImplicitFunction_args:
+      pixel_generator_args:
+        n_harmonic_functions: 0
+      hypernet_args:
+        n_harmonic_functions: 0

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/configs/repro_multiseq_srn_wce.yaml

@@ -0,0 +1,31 @@
+defaults:
+- repro_multiseq_base.yaml
+- repro_feat_extractor_normed.yaml
+- _self_
+model_factory_ImplicitronModelFactory_args:
+  model_GenericModel_args:
+    chunk_size_grid: 32000
+    num_passes: 1
+    n_train_target_views: -1
+    loss_weights:
+      loss_rgb_mse: 200.0
+      loss_prev_stage_rgb_mse: 0.0
+      loss_mask_bce: 1.0
+      loss_prev_stage_mask_bce: 0.0
+      loss_autodecoder_norm: 0.0
+      depth_neg_penalty: 10000.0
+    raysampler_class_type: NearFarRaySampler
+    raysampler_NearFarRaySampler_args:
+      n_rays_per_image_sampled_from_mask: 2048
+      min_depth: 0.05
+      max_depth: 0.05
+      n_pts_per_ray_training: 1
+      n_pts_per_ray_evaluation: 1
+      stratified_point_sampling_training: false
+      stratified_point_sampling_evaluation: false
+    renderer_class_type: LSTMRenderer
+    implicit_function_class_type: SRNImplicitFunction
+    view_pooler_enabled: true
+optimizer_factory_ImplicitronOptimizerFactory_args:
+  breed: Adam
+  lr: 5.0e-05

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/configs/repro_multiseq_v2_nerf_wce.yaml

@@ -0,0 +1,4 @@
+defaults:
+- repro_multiseq_nerf_wce.yaml
+- repro_multiseq_co3dv2_base.yaml
+- _self_

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/configs/repro_multiseq_v2_nerformer.yaml

@@ -0,0 +1,4 @@
+defaults:
+- repro_multiseq_nerformer.yaml
+- repro_multiseq_co3dv2_base.yaml
+- _self_

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/configs/repro_multiseq_v2_srn_ad_hypernet.yaml

@@ -0,0 +1,4 @@
+defaults:
+- repro_multiseq_srn_ad_hypernet.yaml
+- repro_multiseq_co3dv2_base.yaml
+- _self_

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/configs/repro_multiseq_v2_srn_wce.yaml

@@ -0,0 +1,4 @@
+defaults:
+- repro_multiseq_srn_wce.yaml
+- repro_multiseq_co3dv2_base.yaml
+- _self_

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/configs/repro_singleseq_co3dv2_base.yaml

@@ -0,0 +1,8 @@
+data_source_ImplicitronDataSource_args:
+  dataset_map_provider_class_type: JsonIndexDatasetMapProviderV2
+  dataset_map_provider_JsonIndexDatasetMapProviderV2_args:
+    category: teddybear
+    subset_name: manyview_dev_0
+training_loop_ImplicitronTrainingLoop_args:
+  evaluator_ImplicitronEvaluator_args:
+    is_multisequence: false

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/configs/repro_singleseq_idr.yaml

@@ -0,0 +1,57 @@
+defaults:
+- repro_singleseq_base
+- _self_
+model_factory_ImplicitronModelFactory_args:
+  model_GenericModel_args:
+    loss_weights:
+      loss_mask_bce: 100.0
+      loss_kl: 0.0
+      loss_rgb_mse: 1.0
+      loss_eikonal: 0.1
+    chunk_size_grid: 65536
+    num_passes: 1
+    view_pooler_enabled: false
+    implicit_function_IdrFeatureField_args:
+      n_harmonic_functions_xyz: 6
+      bias: 0.6
+      d_in: 3
+      d_out: 1
+      dims:
+      - 512
+      - 512
+      - 512
+      - 512
+      - 512
+      - 512
+      - 512
+      - 512
+      geometric_init: true
+      pooled_feature_dim: 0
+      skip_in:
+      - 6
+      weight_norm: true
+    renderer_SignedDistanceFunctionRenderer_args:
+      ray_tracer_args:
+        line_search_step: 0.5
+        line_step_iters: 3
+        n_secant_steps: 8
+        n_steps: 100
+        sdf_threshold: 5.0e-05
+      ray_normal_coloring_network_args:
+        d_in: 9
+        d_out: 3
+        dims:
+        - 512
+        - 512
+        - 512
+        - 512
+        mode: idr
+        n_harmonic_functions_dir: 4
+        pooled_feature_dim: 0
+        weight_norm: true
+    raysampler_AdaptiveRaySampler_args:
+      n_rays_per_image_sampled_from_mask: 1024
+      n_pts_per_ray_training: 0
+      n_pts_per_ray_evaluation: 0
+    renderer_class_type: SignedDistanceFunctionRenderer
+    implicit_function_class_type: IdrFeatureField

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/configs/repro_singleseq_nerf.yaml

@@ -0,0 +1,3 @@
+defaults:
+- repro_singleseq_base
+- _self_

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/configs/repro_singleseq_srn.yaml

@@ -0,0 +1,29 @@
+defaults:
+- repro_singleseq_base.yaml
+- _self_
+model_factory_ImplicitronModelFactory_args:
+  model_GenericModel_args:
+    num_passes: 1
+    chunk_size_grid: 32000
+    view_pooler_enabled: false
+    loss_weights:
+      loss_rgb_mse: 200.0
+      loss_prev_stage_rgb_mse: 0.0
+      loss_mask_bce: 1.0
+      loss_prev_stage_mask_bce: 0.0
+      loss_autodecoder_norm: 0.0
+      depth_neg_penalty: 10000.0
+    raysampler_class_type: NearFarRaySampler
+    raysampler_NearFarRaySampler_args:
+      n_rays_per_image_sampled_from_mask: 2048
+      min_depth: 0.05
+      max_depth: 0.05
+      n_pts_per_ray_training: 1
+      n_pts_per_ray_evaluation: 1
+      stratified_point_sampling_training: false
+      stratified_point_sampling_evaluation: false
+    renderer_class_type: LSTMRenderer
+    implicit_function_class_type: SRNImplicitFunction
+optimizer_factory_ImplicitronOptimizerFactory_args:
+  breed: Adam
+  lr: 5.0e-05

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/configs/repro_singleseq_srn_wce.yaml

@@ -0,0 +1,30 @@
+defaults:
+- repro_singleseq_wce_base
+- repro_feat_extractor_normed.yaml
+- _self_
+model_factory_ImplicitronModelFactory_args:
+  model_GenericModel_args:
+    num_passes: 1
+    chunk_size_grid: 32000
+    view_pooler_enabled: true
+    loss_weights:
+      loss_rgb_mse: 200.0
+      loss_prev_stage_rgb_mse: 0.0
+      loss_mask_bce: 1.0
+      loss_prev_stage_mask_bce: 0.0
+      loss_autodecoder_norm: 0.0
+      depth_neg_penalty: 10000.0
+    raysampler_class_type: NearFarRaySampler
+    raysampler_NearFarRaySampler_args:
+      n_rays_per_image_sampled_from_mask: 2048
+      min_depth: 0.05
+      max_depth: 0.05
+      n_pts_per_ray_training: 1
+      n_pts_per_ray_evaluation: 1
+      stratified_point_sampling_training: false
+      stratified_point_sampling_evaluation: false
+    renderer_class_type: LSTMRenderer
+    implicit_function_class_type: SRNImplicitFunction
+optimizer_factory_ImplicitronOptimizerFactory_args:
+  breed: Adam
+  lr: 5.0e-05

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/configs/repro_singleseq_srn_wce_noharm.yaml

@@ -0,0 +1,11 @@
+defaults:
+- repro_singleseq_srn_wce.yaml
+- _self_
+model_factory_ImplicitronModelFactory_args:
+  model_GenericModel_args:
+    num_passes: 1
+    implicit_function_SRNImplicitFunction_args:
+      pixel_generator_args:
+        n_harmonic_functions: 0
+      raymarch_function_args:
+        n_harmonic_functions: 0

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/configs/repro_singleseq_v2_nerf.yaml

@@ -0,0 +1,4 @@
+defaults:
+- repro_singleseq_nerf.yaml
+- repro_singleseq_co3dv2_base.yaml
+- _self_

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/blending/sigmoid_alpha_blend.cu

@@ -0,0 +1,216 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <ATen/ATen.h>
+#include <ATen/cuda/CUDAContext.h>
+#include <c10/cuda/CUDAGuard.h>
+#include <cmath>
+#include <vector>
+
+template <typename scalar_t>
+__global__ void SigmoidAlphaBlendForwardKernel(
+    // clang-format off
+    const at::PackedTensorAccessor64<scalar_t, 4, at::RestrictPtrTraits> distances, // (N, H, W, K)
+    const at::PackedTensorAccessor64<int64_t, 4, at::RestrictPtrTraits> pix_to_face, // (N, H, W, K)
+    at::PackedTensorAccessor64<scalar_t, 3, at::RestrictPtrTraits> alphas, // (N, H, W)
+    // clang-format on
+    const scalar_t sigma,
+    const int N,
+    const int H,
+    const int W,
+    const int K) {
+  // Parallelize over each pixel in images of
+  // size H * W, for each image in the batch of size N.
+  const int num_threads = gridDim.x * blockDim.x;
+  const int tid = blockIdx.x * blockDim.x + threadIdx.x;
+
+  // TODO: revisit performance of this kernel with shared memory usage
+
+  for (int t_i = tid; t_i < N * H * W; t_i += num_threads) {
+    // Convert linear index to 3D index
+    const int n = t_i / (H * W); // batch index.
+    const int pix_idx = t_i % (H * W);
+
+    // TODO: fix index calculation for non square images.
+    const int yi = pix_idx / W;
+    const int xi = pix_idx % W;
+    scalar_t alpha = 1.0;
+
+    // Loop over all the faces for this pixel.
+    for (int k = 0; k < K; k++) {
+      // Index into (N, H, W, K) tensors
+      const int f = pix_to_face[n][yi][xi][k];
+      if (f < 0) {
+        // Sentinel value is -1 indicating no face overlaps the pixel.
+        continue;
+      }
+      // The distance is negative if a pixel is inside a face and positive
+      // outside the face. Therefore use -1.0 * the distance to get the
+      // correct sign.
+      scalar_t dist = -1.0 * distances[n][yi][xi][k];
+
+      // Calculate the sigmoid probability.
+      scalar_t prob = 1. / (1. + exp(-dist / sigma));
+
+      // The cumulative product ensures that alpha will be 0.0 if at least 1
+      // face fully covers the pixel as for that face, prob will be 1.0.
+      // This results in a multiplication by 0.0 because of the (1.0 - prob)
+      // term. Therefore the final result of (1.0 - alpha) will be 1.0.
+      alpha *= (1.0 - prob);
+    }
+    alphas[n][yi][xi] = 1.0 - alpha;
+  }
+}
+
+at::Tensor SigmoidAlphaBlendForwardCuda(
+    const at::Tensor& distances, // (N, H, W, K)
+    const at::Tensor& pix_to_face, // (N, H, W, K)
+    const float sigma) {
+  const int N = distances.size(0);
+  const int H = distances.size(1);
+  const int W = distances.size(2);
+  const int K = distances.size(3);
+
+  at::Tensor alphas = at::zeros({N, H, W}, distances.options());
+  const size_t blocks = 1024;
+  const size_t threads = 128;
+
+  // Check inputs are on the same device
+  at::TensorArg distances_t{distances, "distances", 1},
+      pix_to_face_t{pix_to_face, "pix_to_face", 2};
+  at::CheckedFrom c = "SigmoidAlphaBlendForwardCuda";
+  at::checkAllSameGPU(c, {distances_t, pix_to_face_t});
+
+  // Set the device for the kernel launch based on the device of distances
+  at::cuda::CUDAGuard device_guard(distances.device());
+  cudaStream_t stream = at::cuda::getCurrentCUDAStream();
+
+  if (distances.numel() == 0) {
+    AT_CUDA_CHECK(cudaGetLastError());
+    return alphas;
+  }
+
+  AT_DISPATCH_FLOATING_TYPES(
+      distances.scalar_type(), "sigmoid_alpha_blend_kernel", ([&] {
+        // clang-format off
+      SigmoidAlphaBlendForwardKernel<scalar_t><<<blocks, threads, 0, stream>>>(
+      distances.packed_accessor64<scalar_t, 4, at::RestrictPtrTraits>(),
+      pix_to_face.packed_accessor64<int64_t, 4, at::RestrictPtrTraits>(),
+      alphas.packed_accessor64<scalar_t, 3, at::RestrictPtrTraits>(),
+      sigma,
+      N,
+      H,
+      W,
+      K);
+        // clang-format on
+      }));
+
+  AT_CUDA_CHECK(cudaGetLastError());
+  return alphas;
+}
+
+template <typename scalar_t>
+__global__ void SigmoidAlphaBlendBackwardKernel(
+    // clang-format off
+    const at::PackedTensorAccessor64<scalar_t, 3, at::RestrictPtrTraits> grad_alphas, // (N, H, W)
+    const at::PackedTensorAccessor64<scalar_t, 3, at::RestrictPtrTraits> alphas, // (N, H, W)
+    const at::PackedTensorAccessor64<scalar_t, 4, at::RestrictPtrTraits> distances, // (N, H, W, K)
+    const at::PackedTensorAccessor64<int64_t, 4, at::RestrictPtrTraits> pix_to_face, // (N, H, W, K)
+    at::PackedTensorAccessor64<scalar_t, 4, at::RestrictPtrTraits> grad_distances, // (N, H, W)
+    // clang-format on
+    const scalar_t sigma,
+    const int N,
+    const int H,
+    const int W,
+    const int K) {
+  // Parallelize over each of the top K faces for each pixel in images of
+  // size H * W * K, for each image in the batch of size N.
+
+  // Get block and thread index.
+  const int n = blockIdx.x;
+  const int num_pixels = H * W * K;
+  const int num_threads = gridDim.y * blockDim.x;
+  const int tid = blockIdx.y * blockDim.x + threadIdx.x;
+
+  for (int t_i = tid; t_i < num_pixels; t_i += num_threads) {
+    // Convert linear index to 3D index.
+    int yi = t_i / (W * K);
+    int xi = (t_i % (W * K)) / K;
+    int k = (t_i % (W * K)) % K;
+
+    const scalar_t alpha = 1.0 - alphas[n][yi][xi];
+    const scalar_t grad_alpha = grad_alphas[n][yi][xi];
+    const int f = pix_to_face[n][yi][xi][k];
+
+    // Sentinel value is -1 indicating no face overlaps the pixel.
+    if (f >= 0) {
+      // The distance is negative if a pixel is inside a face and positive
+      // outside the face. Therefore use -1.0 * the distance to get the
+      // correct sign.
+      scalar_t dist = -1.0 * distances[n][yi][xi][k];
+
+      // Calculate the sigmoid probability.
+      scalar_t prob = 1. / (1. + exp(-dist / sigma));
+
+      grad_distances[n][yi][xi][k] = grad_alpha * (-1.0 / sigma) * prob * alpha;
+    }
+  }
+}
+
+at::Tensor SigmoidAlphaBlendBackwardCuda(
+    const at::Tensor& grad_alphas, // (N, H, W)
+    const at::Tensor& alphas, // (N, H, W)
+    const at::Tensor& distances, // (N, H, W, K)
+    const at::Tensor& pix_to_face, // (N, H, W, K)
+    float sigma) {
+  const int N = distances.size(0);
+  const int H = distances.size(1);
+  const int W = distances.size(2);
+  const int K = distances.size(3);
+
+  at::Tensor grad_distances = at::zeros({N, H, W, K}, distances.options());
+
+  const dim3 threads(512);
+  const dim3 blocks(N, 1024 / N + 1);
+
+  at::TensorArg grad_alphas_t{grad_alphas, "grad_alphas", 1},
+      alphas_t{alphas, "alphas", 2}, distances_t{distances, "distances", 3},
+      pix_to_face_t{pix_to_face, "pix_to_face", 4};
+  at::CheckedFrom c = "SigmoidAlphaBlendBackwardCuda";
+  at::checkAllSameGPU(c, {grad_alphas_t, alphas_t, distances_t, pix_to_face_t});
+
+  // Set the device for the kernel launch based on the device of distances
+  at::cuda::CUDAGuard device_guard(alphas.device());
+  cudaStream_t stream = at::cuda::getCurrentCUDAStream();
+
+  if (alphas.numel() == 0) {
+    AT_CUDA_CHECK(cudaGetLastError());
+    return grad_alphas;
+  }
+
+  AT_DISPATCH_FLOATING_TYPES(
+      distances.scalar_type(), "sigmoid_alpha_blend_backward_kernel", ([&] {
+        SigmoidAlphaBlendBackwardKernel<
+            scalar_t><<<blocks, threads, 0, stream>>>(
+            // clang-format off
+            grad_alphas.packed_accessor64<scalar_t, 3,at::RestrictPtrTraits>(),
+            alphas.packed_accessor64<scalar_t, 3, at::RestrictPtrTraits>(),
+            distances.packed_accessor64<scalar_t, 4, at::RestrictPtrTraits>(),
+            pix_to_face.packed_accessor64<int64_t, 4, at::RestrictPtrTraits>(),
+            grad_distances.packed_accessor64<scalar_t, 4, at::RestrictPtrTraits>(),
+            // clang-format on
+            sigma,
+            N,
+            H,
+            W,
+            K);
+      }));
+
+  AT_CUDA_CHECK(cudaGetLastError());
+  return grad_distances;
+}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/blending/sigmoid_alpha_blend.h

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+#include <torch/extension.h>
+#include <tuple>
+
+// clang-format off
+// Function to blend the top K faces per pixel based on the 2d euclidean distance
+// from the center of the pixel to the face. This method is adapted from [1].
+// The output can be used to set the alpha value in an RGBA image.
+// Args:
+//      pix_to_face: LongTensor of shape (N, H, W, K), indices of faces overlapping
+//          with each pixel, where N is the batch size, H, W are the dimensions of the
+//          image and K is the number of faces rasterized per pixel.
+//      distances: FloatTensor of shape (N, H, W, K), 2d euclidean distance of each pixel
+//          relative to the faces in pix_to_face
+//      sigma: float, parameter which controls the width of the sigmoid for blending
+// Returns:
+//      alphas: FloatTensor of shape (N, H, W), the blended values for each pixel
+//          in the image.
+//
+// [1] Shichen Liu et al, 'Soft Rasterizer: A Differentiable Renderer for
+// Image-based 3D Reasoning'
+// clang-format on
+at::Tensor SigmoidAlphaBlendForwardCpu(
+    const at::Tensor& distances,
+    const at::Tensor& pix_to_face,
+    const float sigma);
+
+#ifdef WITH_CUDA
+at::Tensor SigmoidAlphaBlendForwardCuda(
+    const at::Tensor& distances,
+    const at::Tensor& pix_to_face,
+    const float sigma);
+#endif
+
+// clang-format off
+// Args:
+//      grad_alphas: FloatTensor of shape (N, H, W), upstream gradients for alphas
+//      alphas: FloatTensor of shape (N, H, W), the alpha values from the forward pass
+//      pix_to_face: LongTensor of shape (N, H, W, K), indices of faces overlapping
+//          with each pixel, where N is the batch size, H, W are the dimensions of the
+//          image, and K is the number of faces rasterized per pixel
+//      distances: FloatTensor of shape (N, H, W, K), 2d euclidean distance of each pixel
+//          to the corresponding faces in pix_to_face
+//      sigma: float, parameter which controls the width of the sigmoid for blending
+// Returns:
+//      grad_distances: FloatTensor of shape (N, H, W, K)
+// clang-format on
+at::Tensor SigmoidAlphaBlendBackwardCpu(
+    const at::Tensor& grad_alphas,
+    const at::Tensor& alphas,
+    const at::Tensor& distances,
+    const at::Tensor& pix_to_face,
+    const float sigma);
+
+#ifdef WITH_CUDA
+at::Tensor SigmoidAlphaBlendBackwardCuda(
+    const at::Tensor& grad_alphas,
+    const at::Tensor& alphas,
+    const at::Tensor& distances,
+    const at::Tensor& pix_to_face,
+    const float sigma);
+#endif
+
+// Implementation which is exposed.
+at::Tensor
+SigmoidAlphaBlend(at::Tensor& distances, at::Tensor& pix_to_face, float sigma) {
+  if (distances.is_cuda() && pix_to_face.is_cuda()) {
+#ifdef WITH_CUDA
+    return SigmoidAlphaBlendForwardCuda(distances, pix_to_face, sigma);
+#else
+    AT_ERROR("Not compiled with GPU support.");
+#endif
+  }
+  return SigmoidAlphaBlendForwardCpu(distances, pix_to_face, sigma);
+}
+
+// Implementation which is exposed.
+at::Tensor SigmoidAlphaBlendBackward(
+    const at::Tensor& grad_alphas,
+    const at::Tensor& alphas,
+    const at::Tensor& distances,
+    const at::Tensor& pix_to_face,
+    const float sigma) {
+  if (distances.is_cuda() && pix_to_face.is_cuda() && alphas.is_cuda() &&
+      grad_alphas.is_cuda()) {
+#ifdef WITH_CUDA
+    return SigmoidAlphaBlendBackwardCuda(
+        grad_alphas, alphas, distances, pix_to_face, sigma);
+#else
+    AT_ERROR("Not compiled with GPU support.");
+#endif
+  }
+  return SigmoidAlphaBlendBackwardCpu(
+      grad_alphas, alphas, distances, pix_to_face, sigma);
+}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/blending/sigmoid_alpha_blend_cpu.cpp

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <torch/extension.h>
+#include <cmath>
+#include <vector>
+
+at::Tensor SigmoidAlphaBlendForwardCpu(
+    const at::Tensor& distances, // (N, H, W, K)
+    const at::Tensor& pix_to_face, // (N, H, W, K)
+    const float sigma) {
+  const int N = distances.size(0);
+  const int H = distances.size(1);
+  const int W = distances.size(2);
+  const int K = distances.size(3);
+
+  torch::Tensor out = torch::empty({N, H, W}, distances.options());
+
+  auto distances_a = distances.accessor<float, 4>();
+  auto pix_to_face_a = pix_to_face.accessor<int64_t, 4>();
+  auto out_a = out.accessor<float, 3>();
+
+  // Iterate over the images in the batch.
+  for (int n = 0; n < N; ++n) {
+    // Iterate through the horizontal lines of the image from top to bottom.
+    for (int h = 0; h < H; ++h) {
+      // Iterate over the pixels on this horizontal line, left to right.
+      for (int w = 0; w < W; ++w) {
+        float alpha = 1.0;
+
+        // Loop through the top K faces for each pixel.
+        for (int k = 0; k < K; ++k) {
+          const int f = pix_to_face_a[n][h][w][k];
+          if (f < 0) {
+            // Sentinel value is -1 indicating no face overlaps the pixel.
+            continue;
+          }
+          // The distance is negative if a pixel is inside a face and positive
+          // outside the face. Therefore use -1.0 * the distance to get the
+          // correct sign.
+          float dist = -1.0 * distances_a[n][h][w][k];
+
+          // Calculate the sigmoid probability.
+          float prob = 1. / (1. + exp(-dist / sigma));
+
+          // The product ensures that alpha will be 0.0 if at least 1
+          // face fully covers the pixel as for that face, prob will be 1.0.
+          // This results in a multiplication by 0.0 because of the (1.0 - prob)
+          // term. Therefore 1.0 - alpha will be 1.0.
+          alpha *= 1.0 - prob;
+        }
+        out_a[n][h][w] = 1.0 - alpha;
+      }
+    }
+  }
+  return out;
+}
+
+at::Tensor SigmoidAlphaBlendBackwardCpu(
+    const at::Tensor& grad_alphas, // (N, H, W)
+    const at::Tensor& alphas, // (N, H, W)
+    const at::Tensor& distances, // (N, H, W, K)
+    const at::Tensor& pix_to_face, // (N, H, W, K)
+    const float sigma) {
+  const int N = distances.size(0);
+  const int H = distances.size(1);
+  const int W = distances.size(2);
+  const int K = distances.size(3);
+
+  auto distances_a = distances.accessor<float, 4>();
+  auto pix_to_face_a = pix_to_face.accessor<int64_t, 4>();
+  auto alphas_a = alphas.accessor<float, 3>();
+  auto grad_alphas_a = grad_alphas.accessor<float, 3>();
+
+  torch::Tensor grad_distances =
+      torch::zeros({N, H, W, K}, distances.options());
+  auto grad_distances_a = grad_distances.accessor<float, 4>();
+
+  // Iterate over the images in the batch.
+  for (int n = 0; n < N; ++n) {
+    // Iterate through the horizontal lines of the image from top to bottom.
+    for (int h = 0; h < H; ++h) {
+      // Iterate over the pixels on this horizontal line, left to right.
+      for (int w = 0; w < W; ++w) {
+        // Get the alpha value from the forward pass and the
+        // upstream gradient.
+        const float alpha = 1.0 - alphas_a[n][h][w];
+        const float grad_alpha = grad_alphas_a[n][h][w];
+
+        // Loop through the top K faces for each pixel.
+        for (int k = 0; k < K; ++k) {
+          const int f = pix_to_face_a[n][h][w][k];
+          if (f < 0) {
+            // Sentinel value is -1 indicating no face overlaps the pixel
+            continue;
+          }
+          // The distance is negative if a pixel is inside a face and positive
+          // outside the face. Therefore use -1.0 * distance to get the
+          // correct sign.
+          float dist = -1.0 * distances_a[n][h][w][k];
+
+          // Calculate the sigmoid probability.
+          float prob = 1. / (1. + exp(-dist / sigma));
+
+          // clang-format off
+          // We need to take the derivative of alpha w.r.t to the distance.
+          // alpha = 1.0 - (1.0- sigmoid(-x)) * (1.0 - sigmoid(-x2)) * ... * (1.0 - sigmoid(-xn))
+          //
+          // Note that d/dx sigmoid(x) = sigmoid(x) * (1.0 - sigmoid(x))
+          //
+          // This gives:
+          // d_alpha/d_dist = -1.0 * -1.0 * sigmoid(-x)(1. - sigmoid(-x)) * (-1.0/sigma)
+          //        * ((1.0 - sigmoid(-x2) * ... * (1.0 - sigmoid(-xn))
+          //    = (-1.0/sigma) * prob * (1.0 - prob) * alpha/(1.0 - prob)
+          //    = (-1.0/sigma) * prob * alpha
+          // clang-format on
+          grad_distances_a[n][h][w][k] =
+              grad_alpha * (-1.0 / sigma) * prob * alpha;
+        }
+      }
+    }
+  }
+  return grad_distances;
+}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/ext.cpp

@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// clang-format off
+#if !defined(USE_ROCM)
+#include "./pulsar/global.h" // Include before <torch/extension.h>.
+#endif
+#include <torch/extension.h>
+// clang-format on
+#if !defined(USE_ROCM)
+#include "./pulsar/pytorch/renderer.h"
+#include "./pulsar/pytorch/tensor_util.h"
+#endif
+#include "ball_query/ball_query.h"
+#include "blending/sigmoid_alpha_blend.h"
+#include "compositing/alpha_composite.h"
+#include "compositing/norm_weighted_sum.h"
+#include "compositing/weighted_sum.h"
+#include "face_areas_normals/face_areas_normals.h"
+#include "gather_scatter/gather_scatter.h"
+#include "interp_face_attrs/interp_face_attrs.h"
+#include "iou_box3d/iou_box3d.h"
+#include "knn/knn.h"
+#include "marching_cubes/marching_cubes.h"
+#include "mesh_normal_consistency/mesh_normal_consistency.h"
+#include "packed_to_padded_tensor/packed_to_padded_tensor.h"
+#include "point_mesh/point_mesh_cuda.h"
+#include "points_to_volumes/points_to_volumes.h"
+#include "rasterize_meshes/rasterize_meshes.h"
+#include "rasterize_points/rasterize_points.h"
+#include "sample_farthest_points/sample_farthest_points.h"
+#include "sample_pdf/sample_pdf.h"
+
+PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
+  m.def("face_areas_normals_forward", &FaceAreasNormalsForward);
+  m.def("face_areas_normals_backward", &FaceAreasNormalsBackward);
+  m.def("packed_to_padded", &PackedToPadded);
+  m.def("padded_to_packed", &PaddedToPacked);
+  m.def("interp_face_attrs_forward", &InterpFaceAttrsForward);
+  m.def("interp_face_attrs_backward", &InterpFaceAttrsBackward);
+#ifdef WITH_CUDA
+  m.def("knn_check_version", &KnnCheckVersion);
+#endif
+  m.def("knn_points_idx", &KNearestNeighborIdx);
+  m.def("knn_points_backward", &KNearestNeighborBackward);
+  m.def("ball_query", &BallQuery);
+  m.def("sample_farthest_points", &FarthestPointSampling);
+  m.def(
+      "mesh_normal_consistency_find_verts", &MeshNormalConsistencyFindVertices);
+  m.def("gather_scatter", &GatherScatter);
+  m.def("points_to_volumes_forward", PointsToVolumesForward);
+  m.def("points_to_volumes_backward", PointsToVolumesBackward);
+  m.def("rasterize_points", &RasterizePoints);
+  m.def("rasterize_points_backward", &RasterizePointsBackward);
+  m.def("rasterize_meshes_backward", &RasterizeMeshesBackward);
+  m.def("rasterize_meshes", &RasterizeMeshes);
+  m.def("sigmoid_alpha_blend", &SigmoidAlphaBlend);
+  m.def("sigmoid_alpha_blend_backward", &SigmoidAlphaBlendBackward);
+
+  // Accumulation functions
+  m.def("accum_weightedsumnorm", &weightedSumNormForward);
+  m.def("accum_weightedsum", &weightedSumForward);
+  m.def("accum_alphacomposite", &alphaCompositeForward);
+  m.def("accum_weightedsumnorm_backward", &weightedSumNormBackward);
+  m.def("accum_weightedsum_backward", &weightedSumBackward);
+  m.def("accum_alphacomposite_backward", &alphaCompositeBackward);
+
+  // These are only visible for testing; users should not call them directly
+  m.def("_rasterize_points_coarse", &RasterizePointsCoarse);
+  m.def("_rasterize_points_naive", &RasterizePointsNaive);
+  m.def("_rasterize_meshes_naive", &RasterizeMeshesNaive);
+  m.def("_rasterize_meshes_coarse", &RasterizeMeshesCoarse);
+  m.def("_rasterize_meshes_fine", &RasterizeMeshesFine);
+
+  // PointEdge distance functions
+  m.def("point_edge_dist_forward", &PointEdgeDistanceForward);
+  m.def("point_edge_dist_backward", &PointEdgeDistanceBackward);
+  m.def("edge_point_dist_forward", &EdgePointDistanceForward);
+  m.def("edge_point_dist_backward", &EdgePointDistanceBackward);
+  m.def("point_edge_array_dist_forward", &PointEdgeArrayDistanceForward);
+  m.def("point_edge_array_dist_backward", &PointEdgeArrayDistanceBackward);
+
+  // PointFace distance functions
+  m.def("point_face_dist_forward", &PointFaceDistanceForward);
+  m.def("point_face_dist_backward", &PointFaceDistanceBackward);
+  m.def("face_point_dist_forward", &FacePointDistanceForward);
+  m.def("face_point_dist_backward", &FacePointDistanceBackward);
+  m.def("point_face_array_dist_forward", &PointFaceArrayDistanceForward);
+  m.def("point_face_array_dist_backward", &PointFaceArrayDistanceBackward);
+
+  // Sample PDF
+  m.def("sample_pdf", &SamplePdf);
+
+  // 3D IoU
+  m.def("iou_box3d", &IoUBox3D);
+
+  // Marching cubes
+  m.def("marching_cubes", &MarchingCubes);
+
+  // Pulsar.
+  // Pulsar not enabled on AMD.
+#if !defined(USE_ROCM)
+#ifdef PULSAR_LOGGING_ENABLED
+  c10::ShowLogInfoToStderr();
+#endif
+  py::class_<
+      pulsar::pytorch::Renderer,
+      std::shared_ptr<pulsar::pytorch::Renderer>>(m, "PulsarRenderer")
+      .def(py::init<
+           const uint&,
+           const uint&,
+           const uint&,
+           const bool&,
+           const bool&,
+           const float&,
+           const uint&,
+           const uint&>())
+      .def(
+          "__eq__",
+          [](const pulsar::pytorch::Renderer& a,
+             const pulsar::pytorch::Renderer& b) { return a == b; },
+          py::is_operator())
+      .def(
+          "__ne__",
+          [](const pulsar::pytorch::Renderer& a,
+             const pulsar::pytorch::Renderer& b) { return !(a == b); },
+          py::is_operator())
+      .def(
+          "__repr__",
+          [](const pulsar::pytorch::Renderer& self) {
+            std::stringstream ss;
+            ss << self;
+            return ss.str();
+          })
+      .def(
+          "forward",
+          &pulsar::pytorch::Renderer::forward,
+          py::arg("vert_pos"),
+          py::arg("vert_col"),
+          py::arg("vert_radii"),
+
+          py::arg("cam_pos"),
+          py::arg("pixel_0_0_center"),
+          py::arg("pixel_vec_x"),
+          py::arg("pixel_vec_y"),
+          py::arg("focal_length"),
+          py::arg("principal_point_offsets"),
+
+          py::arg("gamma"),
+          py::arg("max_depth"),
+          py::arg("min_depth") /* = 0.f*/,
+          py::arg(
+              "bg_col") /* = at::nullopt not exposed properly in pytorch 1.1. */
+          ,
+          py::arg("opacity") /* = at::nullopt ... */,
+          py::arg("percent_allowed_difference") = 0.01f,
+          py::arg("max_n_hits") = MAX_UINT,
+          py::arg("mode") = 0)
+      .def("backward", &pulsar::pytorch::Renderer::backward)
+      .def_property(
+          "device_tracker",
+          [](const pulsar::pytorch::Renderer& self) {
+            return self.device_tracker;
+          },
+          [](pulsar::pytorch::Renderer& self, const torch::Tensor& val) {
+            self.device_tracker = val;
+          })
+      .def_property_readonly("width", &pulsar::pytorch::Renderer::width)
+      .def_property_readonly("height", &pulsar::pytorch::Renderer::height)
+      .def_property_readonly(
+          "max_num_balls", &pulsar::pytorch::Renderer::max_num_balls)
+      .def_property_readonly(
+          "orthogonal", &pulsar::pytorch::Renderer::orthogonal)
+      .def_property_readonly(
+          "right_handed", &pulsar::pytorch::Renderer::right_handed)
+      .def_property_readonly("n_track", &pulsar::pytorch::Renderer::n_track);
+  m.def(
+      "pulsar_sphere_ids_from_result_info_nograd",
+      &pulsar::pytorch::sphere_ids_from_result_info_nograd);
+  // Constants.
+  m.attr("EPS") = py::float_(EPS);
+  m.attr("MAX_FLOAT") = py::float_(MAX_FLOAT);
+  m.attr("MAX_INT") = py::int_(MAX_INT);
+  m.attr("MAX_UINT") = py::int_(MAX_UINT);
+  m.attr("MAX_USHORT") = py::int_(MAX_USHORT);
+  m.attr("PULSAR_MAX_GRAD_SPHERES") = py::int_(MAX_GRAD_SPHERES);
+#endif
+}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/face_areas_normals/face_areas_normals.cu

@@ -0,0 +1,301 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <ATen/ATen.h>
+#include <ATen/cuda/CUDAContext.h>
+#include <c10/cuda/CUDAGuard.h>
+#include <tuple>
+
+template <typename scalar_t>
+__global__ void FaceAreasNormalsForwardKernel(
+    const scalar_t* __restrict__ verts,
+    const int64_t* __restrict__ faces,
+    scalar_t* __restrict__ face_areas,
+    scalar_t* __restrict__ face_normals,
+    const size_t V,
+    const size_t F) {
+  const size_t tid = blockIdx.x * blockDim.x + threadIdx.x;
+  const size_t stride = gridDim.x * blockDim.x;
+
+  // Faces split evenly over the number of threads in the grid.
+  // Each thread computes the area & normal of its respective faces and adds it
+  // to the global face_areas tensor.
+  for (size_t f = tid; f < F; f += stride) {
+    const int64_t i0 = faces[3 * f + 0];
+    const int64_t i1 = faces[3 * f + 1];
+    const int64_t i2 = faces[3 * f + 2];
+
+    const scalar_t v0_x = verts[3 * i0 + 0];
+    const scalar_t v0_y = verts[3 * i0 + 1];
+    const scalar_t v0_z = verts[3 * i0 + 2];
+
+    const scalar_t v1_x = verts[3 * i1 + 0];
+    const scalar_t v1_y = verts[3 * i1 + 1];
+    const scalar_t v1_z = verts[3 * i1 + 2];
+
+    const scalar_t v2_x = verts[3 * i2 + 0];
+    const scalar_t v2_y = verts[3 * i2 + 1];
+    const scalar_t v2_z = verts[3 * i2 + 2];
+
+    const scalar_t ax = v1_x - v0_x;
+    const scalar_t ay = v1_y - v0_y;
+    const scalar_t az = v1_z - v0_z;
+
+    const scalar_t bx = v2_x - v0_x;
+    const scalar_t by = v2_y - v0_y;
+    const scalar_t bz = v2_z - v0_z;
+
+    const scalar_t cx = ay * bz - az * by;
+    const scalar_t cy = az * bx - ax * bz;
+    const scalar_t cz = ax * by - ay * bx;
+
+    scalar_t norm = sqrt(cx * cx + cy * cy + cz * cz);
+    face_areas[f] = norm / 2.0;
+    norm = (norm < 1e-6) ? 1e-6 : norm; // max(norm, 1e-6)
+    face_normals[3 * f + 0] = cx / norm;
+    face_normals[3 * f + 1] = cy / norm;
+    face_normals[3 * f + 2] = cz / norm;
+  }
+}
+
+// TODO(gkioxari) support all data types once AtomicAdd supports doubles.
+// Currently, support is for floats only.
+__global__ void FaceAreasNormalsBackwardKernel(
+    const float* __restrict__ grad_areas,
+    const float* __restrict__ grad_normals,
+    const float* __restrict__ verts,
+    const int64_t* __restrict__ faces,
+    float* __restrict__ grad_verts,
+    const size_t V,
+    const size_t F) {
+  const size_t tid = blockIdx.x * blockDim.x + threadIdx.x;
+  const size_t stride = gridDim.x * blockDim.x;
+
+  // Faces split evenly over the number of threads in the grid.
+  // Each thread computes the area & normal of its respective faces and adds it
+  // to the global face_areas tensor.
+  for (size_t f = tid; f < F; f += stride) {
+    const int64_t i0 = faces[3 * f + 0];
+    const int64_t i1 = faces[3 * f + 1];
+    const int64_t i2 = faces[3 * f + 2];
+
+    const float v0_x = verts[3 * i0 + 0];
+    const float v0_y = verts[3 * i0 + 1];
+    const float v0_z = verts[3 * i0 + 2];
+
+    const float v1_x = verts[3 * i1 + 0];
+    const float v1_y = verts[3 * i1 + 1];
+    const float v1_z = verts[3 * i1 + 2];
+
+    const float v2_x = verts[3 * i2 + 0];
+    const float v2_y = verts[3 * i2 + 1];
+    const float v2_z = verts[3 * i2 + 2];
+
+    const float ax = v1_x - v0_x;
+    const float ay = v1_y - v0_y;
+    const float az = v1_z - v0_z;
+
+    const float bx = v2_x - v0_x;
+    const float by = v2_y - v0_y;
+    const float bz = v2_z - v0_z;
+
+    const float cx = ay * bz - az * by;
+    const float cy = az * bx - ax * bz;
+    const float cz = ax * by - ay * bx;
+
+    float norm = sqrt(cx * cx + cy * cy + cz * cz);
+    norm = (norm < 1e-6) ? 1e-6 : norm; // max(norm, 1e-6)
+    float inv_norm = 1. / norm;
+    float inv_norm_2 = pow(inv_norm, 2.0f);
+    float inv_norm_3 = pow(inv_norm, 3.0f);
+
+    // We compute gradients with respect to the input vertices.
+    // For each vertex, gradients come from grad_areas and grad_normals.
+    // eg, grad_v0_x = (d / d v0_x)
+    //       = \sum_f (d / d areas[f]) * (d areas[f] / d v0_x)
+    //              + (d / d normals[f, 0]) * (d normals[f, 0] / d v0_x)
+    //              + (d / d normals[f, 1]) * (d normals[f, 1] / d v0_x)
+    //              + (d / d normals[f, 2]) * (d normals[f, 2] / d v0_x)
+    // with (d / d areas[f]) = grad_areas[f] and
+    //      (d / d normals[f, j]) = grad_normals[f][j].
+    // The equations below are derived after taking
+    // derivatives wrt to the vertices (fun times!).
+
+    // grad v0 coming from grad areas and grad normals
+    const float grad_v0_x =
+        ((-az + bz) * cy + (-by + ay) * cz) / 2.0 * inv_norm * grad_areas[f] +
+        -cx * ((-az + bz) * cy + (-by + ay) * cz) * inv_norm_3 *
+            grad_normals[3 * f + 0] +
+        ((-az + bz) - cy * ((-az + bz) * cy + (-by + ay) * cz) * inv_norm_2) *
+            inv_norm * grad_normals[3 * f + 1] +
+        ((-by + ay) - cz * ((-az + bz) * cy + (-by + ay) * cz) * inv_norm_2) *
+            inv_norm * grad_normals[3 * f + 2];
+    atomicAdd(grad_verts + 3 * i0 + 0, grad_v0_x);
+
+    const float grad_v0_y =
+        ((-bz + az) * cx + (-ax + bx) * cz) / 2.0 * inv_norm * grad_areas[f] +
+        ((-bz + az) - cx * ((-bz + az) * cx + (-ax + bx) * cz) * inv_norm_2) *
+            inv_norm * grad_normals[3 * f + 0] +
+        -cy * ((-bz + az) * cx + (-ax + bx) * cz) * inv_norm_3 *
+            grad_normals[3 * f + 1] +
+        ((-ax + bx) - cz * ((-bz + az) * cx + (-ax + bx) * cz) * inv_norm_2) *
+            inv_norm * grad_normals[3 * f + 2];
+    atomicAdd(grad_verts + 3 * i0 + 1, grad_v0_y);
+
+    const float grad_v0_z =
+        ((-ay + by) * cx + (-bx + ax) * cy) / 2.0 * inv_norm * grad_areas[f] +
+        ((-ay + by) - cx * ((-ay + by) * cx + (-bx + ax) * cy) * inv_norm_2) *
+            inv_norm * grad_normals[3 * f + 0] +
+        ((-bx + ax) - cy * ((-ay + by) * cx + (-bx + ax) * cy) * inv_norm_2) *
+            inv_norm * grad_normals[3 * f + 1] +
+        -cz * ((-ay + by) * cx + (-bx + ax) * cy) * inv_norm_3 *
+            grad_normals[3 * f + 2];
+    atomicAdd(grad_verts + 3 * i0 + 2, grad_v0_z);
+
+    // grad v1 coming from grad areas and grad normals
+    const float grad_v1_x =
+        (by * cz - bz * cy) / 2.0 * inv_norm * grad_areas[f] +
+        -cx * (by * cz - bz * cy) * inv_norm_3 * grad_normals[3 * f + 0] +
+        (-bz - cy * (by * cz - bz * cy) * inv_norm_2) * inv_norm *
+            grad_normals[3 * f + 1] +
+        (by - cz * (by * cz - bz * cy) * inv_norm_2) * inv_norm *
+            grad_normals[3 * f + 2];
+    atomicAdd(grad_verts + 3 * i1 + 0, grad_v1_x);
+
+    const float grad_v1_y =
+        (bz * cx - bx * cz) / 2.0 * inv_norm * grad_areas[f] +
+        (bz - cx * (bz * cx - bx * cz) * inv_norm_2) * inv_norm *
+            grad_normals[3 * f + 0] +
+        -cy * (bz * cx - bx * cz) * inv_norm_3 * grad_normals[3 * f + 1] +
+        (-bx - cz * (bz * cx - bx * cz) * inv_norm_2) * inv_norm *
+            grad_normals[3 * f + 2];
+    atomicAdd(grad_verts + 3 * i1 + 1, grad_v1_y);
+
+    const float grad_v1_z =
+        (bx * cy - by * cx) / 2.0 * inv_norm * grad_areas[f] +
+        (-by - cx * (bx * cy - by * cx) * inv_norm_2) * inv_norm *
+            grad_normals[3 * f + 0] +
+        (bx - cx * (bx * cy - by * cx) * inv_norm_2) * inv_norm *
+            grad_normals[3 * f + 1] +
+        -cz * (bx * cy - by * cx) * inv_norm_3 * grad_normals[3 * f + 2];
+    atomicAdd(grad_verts + 3 * i1 + 2, grad_v1_z);
+
+    // grad v2 coming from grad areas
+    const float grad_v2_x =
+        (az * cy - ay * cz) / 2.0 * inv_norm * grad_areas[f] +
+        -cx * (az * cy - ay * cz) * inv_norm_3 * grad_normals[3 * f + 0] +
+        (az - cy * (az * cy - ay * cz) * inv_norm_2) * inv_norm *
+            grad_normals[3 * f + 1] +
+        (-ay - cz * (az * cy - ay * cz) * inv_norm_2) * inv_norm *
+            grad_normals[3 * f + 2];
+    atomicAdd(grad_verts + 3 * i2 + 0, grad_v2_x);
+
+    const float grad_v2_y =
+        (ax * cz - az * cx) / 2.0 * inv_norm * grad_areas[f] +
+        (-az - cx * (ax * cz - az * cx) * inv_norm_2) * inv_norm *
+            grad_normals[3 * f + 0] +
+        -cy * (ax * cz - az * cx) * inv_norm_3 * grad_normals[3 * f + 1] +
+        (ax - cz * (ax * cz - az * cx) * inv_norm_2) * inv_norm *
+            grad_normals[3 * f + 2];
+    atomicAdd(grad_verts + 3 * i2 + 1, grad_v2_y);
+
+    const float grad_v2_z =
+        (ay * cx - ax * cy) / 2.0 * inv_norm * grad_areas[f] +
+        (ay - cx * (ay * cx - ax * cy) * inv_norm_2) * inv_norm *
+            grad_normals[3 * f + 0] +
+        (-ax - cy * (ay * cx - ax * cy) * inv_norm_2) * inv_norm *
+            grad_normals[3 * f + 1] +
+        -cz * (ay * cx - ax * cy) * inv_norm_3 * grad_normals[3 * f + 2];
+    atomicAdd(grad_verts + 3 * i2 + 2, grad_v2_z);
+  }
+}
+
+std::tuple<at::Tensor, at::Tensor> FaceAreasNormalsForwardCuda(
+    const at::Tensor verts,
+    const at::Tensor faces) {
+  const auto V = verts.size(0);
+  const auto F = faces.size(0);
+
+  // Check inputs are on the same device
+  at::TensorArg verts_t{verts, "verts", 1}, faces_t{faces, "faces", 2};
+  at::CheckedFrom c = "FaceAreasNormalsForwardCuda";
+  at::checkAllSameGPU(c, {verts_t, faces_t});
+
+  // Set the device for the kernel launch based on the device of verts
+  at::cuda::CUDAGuard device_guard(verts.device());
+  cudaStream_t stream = at::cuda::getCurrentCUDAStream();
+
+  at::Tensor areas = at::empty({F}, verts.options());
+  at::Tensor normals = at::empty({F, 3}, verts.options());
+
+  if (areas.numel() == 0) {
+    AT_CUDA_CHECK(cudaGetLastError());
+    return std::make_tuple(areas, normals);
+  }
+
+  const int blocks = 64;
+  const int threads = 512;
+
+  AT_DISPATCH_FLOATING_TYPES(
+      verts.scalar_type(), "face_areas_normals_forward_cuda", ([&] {
+        FaceAreasNormalsForwardKernel<scalar_t><<<blocks, threads, 0, stream>>>(
+            verts.contiguous().data_ptr<scalar_t>(),
+            faces.contiguous().data_ptr<int64_t>(),
+            areas.data_ptr<scalar_t>(),
+            normals.data_ptr<scalar_t>(),
+            V,
+            F);
+      }));
+  AT_CUDA_CHECK(cudaGetLastError());
+  return std::make_tuple(areas, normals);
+}
+
+at::Tensor FaceAreasNormalsBackwardCuda(
+    const at::Tensor grad_areas,
+    const at::Tensor grad_normals,
+    const at::Tensor verts,
+    const at::Tensor faces) {
+  // Check inputs are on the same device
+  at::TensorArg verts_t{verts, "verts", 1}, faces_t{faces, "faces", 2},
+      grad_areas_t{grad_areas, "grad_areas", 3},
+      grad_normals_t{grad_normals, "grad_normals", 4};
+  at::CheckedFrom c = "FaceAreasNormalsBackwardCuda";
+  at::checkAllSameGPU(c, {verts_t, faces_t, grad_areas_t, grad_normals_t});
+  // This is nondeterministic because atomicAdd
+  at::globalContext().alertNotDeterministic("FaceAreasNormalsBackwardCuda");
+
+  // Set the device for the kernel launch based on the device of verts
+  at::cuda::CUDAGuard device_guard(verts.device());
+  cudaStream_t stream = at::cuda::getCurrentCUDAStream();
+
+  const auto V = verts.size(0);
+  const auto F = faces.size(0);
+
+  at::Tensor grad_verts = at::zeros({V, 3}, grad_areas.options());
+
+  if (grad_verts.numel() == 0) {
+    AT_CUDA_CHECK(cudaGetLastError());
+    return grad_verts;
+  }
+
+  const int blocks = 64;
+  const int threads = 512;
+  // TODO(gkioxari) add AT_DISPATCH_FLOATING_TYPES once atomicAdd supports
+  // doubles. Currently, support is for floats only.
+  FaceAreasNormalsBackwardKernel<<<blocks, threads, 0, stream>>>(
+      grad_areas.contiguous().data_ptr<float>(),
+      grad_normals.contiguous().data_ptr<float>(),
+      verts.contiguous().data_ptr<float>(),
+      faces.contiguous().data_ptr<int64_t>(),
+      grad_verts.data_ptr<float>(),
+      V,
+      F);
+
+  AT_CUDA_CHECK(cudaGetLastError());
+  return grad_verts;
+}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/face_areas_normals/face_areas_normals.h

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+#include <torch/extension.h>
+#include <tuple>
+#include "utils/pytorch3d_cutils.h"
+
+// Compute areas of mesh faces using packed representation.
+//
+// Inputs:
+//    verts: FloatTensor of shape (V, 3) giving vertex positions.
+//    faces: LongTensor of shape (F, 3) giving faces.
+//
+// Returns:
+//    areas: FloatTensor of shape (F,) where areas[f] is the area of faces[f].
+//    normals: FloatTensor of shape (F, 3) where normals[f] is the normal of
+//    faces[f]
+//
+
+// Cpu implementation.
+std::tuple<at::Tensor, at::Tensor> FaceAreasNormalsForwardCpu(
+    const at::Tensor verts,
+    const at::Tensor faces);
+// Cpu implementation
+at::Tensor FaceAreasNormalsBackwardCpu(
+    const at::Tensor grad_areas,
+    const at::Tensor grad_normals,
+    const at::Tensor verts,
+    const at::Tensor faces);
+
+#ifdef WITH_CUDA
+// Cuda implementation.
+std::tuple<at::Tensor, at::Tensor> FaceAreasNormalsForwardCuda(
+    const at::Tensor verts,
+    const at::Tensor faces);
+// Cuda implementation.
+at::Tensor FaceAreasNormalsBackwardCuda(
+    const at::Tensor grad_areas,
+    const at::Tensor grad_normals,
+    const at::Tensor verts,
+    const at::Tensor faces);
+#endif
+
+// Implementation which is exposed.
+std::tuple<at::Tensor, at::Tensor> FaceAreasNormalsForward(
+    const at::Tensor verts,
+    const at::Tensor faces) {
+  if (verts.is_cuda() && faces.is_cuda()) {
+#ifdef WITH_CUDA
+    CHECK_CUDA(verts);
+    CHECK_CUDA(faces);
+    return FaceAreasNormalsForwardCuda(verts, faces);
+#else
+    AT_ERROR("Not compiled with GPU support.");
+#endif
+  }
+  return FaceAreasNormalsForwardCpu(verts, faces);
+}
+
+// Implementation which is exposed.
+at::Tensor FaceAreasNormalsBackward(
+    const at::Tensor grad_areas,
+    const at::Tensor grad_normals,
+    const at::Tensor verts,
+    const at::Tensor faces) {
+  if (verts.is_cuda() && faces.is_cuda()) {
+#ifdef WITH_CUDA
+    CHECK_CUDA(verts);
+    CHECK_CUDA(faces);
+    CHECK_CUDA(grad_areas);
+    CHECK_CUDA(grad_normals);
+    return FaceAreasNormalsBackwardCuda(grad_areas, grad_normals, verts, faces);
+#else
+    AT_ERROR("Not compiled with GPU support.");
+#endif
+  }
+  return FaceAreasNormalsBackwardCpu(grad_areas, grad_normals, verts, faces);
+}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/face_areas_normals/face_areas_normals_cpu.cpp

@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <torch/extension.h>
+#include <tuple>
+
+std::tuple<at::Tensor, at::Tensor> FaceAreasNormalsForwardCpu(
+    const at::Tensor verts,
+    const at::Tensor faces) {
+  const int F = faces.size(0);
+
+  at::Tensor areas = at::empty({F}, verts.options());
+  at::Tensor normals = at::empty({F, 3}, verts.options());
+
+  auto verts_a = verts.accessor<float, 2>();
+  auto faces_a = faces.accessor<int64_t, 2>();
+  auto areas_a = areas.accessor<float, 1>();
+  auto normals_a = normals.accessor<float, 2>();
+
+  for (int f = 0; f < F; ++f) {
+    const int64_t i0 = faces_a[f][0];
+    const int64_t i1 = faces_a[f][1];
+    const int64_t i2 = faces_a[f][2];
+
+    const float v0_x = verts_a[i0][0];
+    const float v0_y = verts_a[i0][1];
+    const float v0_z = verts_a[i0][2];
+
+    const float v1_x = verts_a[i1][0];
+    const float v1_y = verts_a[i1][1];
+    const float v1_z = verts_a[i1][2];
+
+    const float v2_x = verts_a[i2][0];
+    const float v2_y = verts_a[i2][1];
+    const float v2_z = verts_a[i2][2];
+
+    const float ax = v1_x - v0_x;
+    const float ay = v1_y - v0_y;
+    const float az = v1_z - v0_z;
+
+    const float bx = v2_x - v0_x;
+    const float by = v2_y - v0_y;
+    const float bz = v2_z - v0_z;
+
+    const float cx = ay * bz - az * by;
+    const float cy = az * bx - ax * bz;
+    const float cz = ax * by - ay * bx;
+
+    float norm = sqrt(cx * cx + cy * cy + cz * cz);
+    areas_a[f] = norm / 2.0;
+    norm = (norm < 1e-6) ? 1e-6 : norm; // max(norm, 1e-6)
+    normals_a[f][0] = cx / norm;
+    normals_a[f][1] = cy / norm;
+    normals_a[f][2] = cz / norm;
+  }
+  return std::make_tuple(areas, normals);
+}
+
+at::Tensor FaceAreasNormalsBackwardCpu(
+    const at::Tensor grad_areas,
+    const at::Tensor grad_normals,
+    const at::Tensor verts,
+    const at::Tensor faces) {
+  const int V = verts.size(0);
+  const int F = faces.size(0);
+
+  at::Tensor grad_verts = at::zeros({V, 3}, grad_areas.options());
+
+  auto grad_areas_a = grad_areas.accessor<float, 1>();
+  auto grad_normals_a = grad_normals.accessor<float, 2>();
+  auto verts_a = verts.accessor<float, 2>();
+  auto faces_a = faces.accessor<int64_t, 2>();
+  auto grad_verts_a = grad_verts.accessor<float, 2>();
+
+  for (int f = 0; f < F; ++f) {
+    const int64_t i0 = faces_a[f][0];
+    const int64_t i1 = faces_a[f][1];
+    const int64_t i2 = faces_a[f][2];
+
+    const float v0_x = verts_a[i0][0];
+    const float v0_y = verts_a[i0][1];
+    const float v0_z = verts_a[i0][2];
+
+    const float v1_x = verts_a[i1][0];
+    const float v1_y = verts_a[i1][1];
+    const float v1_z = verts_a[i1][2];
+
+    const float v2_x = verts_a[i2][0];
+    const float v2_y = verts_a[i2][1];
+    const float v2_z = verts_a[i2][2];
+
+    const float ax = v1_x - v0_x;
+    const float ay = v1_y - v0_y;
+    const float az = v1_z - v0_z;
+
+    const float bx = v2_x - v0_x;
+    const float by = v2_y - v0_y;
+    const float bz = v2_z - v0_z;
+
+    const float cx = ay * bz - az * by;
+    const float cy = az * bx - ax * bz;
+    const float cz = ax * by - ay * bx;
+
+    float norm = sqrt(cx * cx + cy * cy + cz * cz);
+    norm = (norm < 1e-6) ? 1e-6 : norm; // max(norm, 1e-6)
+    float inv_norm = 1. / norm;
+    float inv_norm_2 = pow(inv_norm, 2.0f);
+    float inv_norm_3 = pow(inv_norm, 3.0f);
+
+    // We compute gradients with respect to the input vertices.
+    // For each vertex, gradients come from grad_areas and grad_normals.
+    // eg, grad_v0_x = (d / d v0_x)
+    //       = \sum_f (d / d areas[f]) * (d areas[f] / d v0_x)
+    //              + (d / d normals[f, 0]) * (d normals[f, 0] / d v0_x)
+    //              + (d / d normals[f, 1]) * (d normals[f, 1] / d v0_x)
+    //              + (d / d normals[f, 2]) * (d normals[f, 2] / d v0_x)
+    // with (d / d areas[f]) = grad_areas[f] and
+    //      (d / d normals[f, j]) = grad_normals[f][j].
+    // The equations below are derived after taking
+    // derivatives wrt to the vertices (fun times!).
+
+    // grad v0 coming from grad areas and grad normals
+    const float grad_v0_x =
+        ((-az + bz) * cy + (-by + ay) * cz) / 2.0 * inv_norm * grad_areas_a[f] +
+        -cx * ((-az + bz) * cy + (-by + ay) * cz) * inv_norm_3 *
+            grad_normals_a[f][0] +
+        ((-az + bz) - cy * ((-az + bz) * cy + (-by + ay) * cz) * inv_norm_2) *
+            inv_norm * grad_normals_a[f][1] +
+        ((-by + ay) - cz * ((-az + bz) * cy + (-by + ay) * cz) * inv_norm_2) *
+            inv_norm * grad_normals_a[f][2];
+    grad_verts_a[i0][0] += grad_v0_x;
+
+    const float grad_v0_y =
+        ((-bz + az) * cx + (-ax + bx) * cz) / 2.0 * inv_norm * grad_areas_a[f] +
+        ((-bz + az) - cx * ((-bz + az) * cx + (-ax + bx) * cz) * inv_norm_2) *
+            inv_norm * grad_normals_a[f][0] +
+        -cy * ((-bz + az) * cx + (-ax + bx) * cz) * inv_norm_3 *
+            grad_normals_a[f][1] +
+        ((-ax + bx) - cz * ((-bz + az) * cx + (-ax + bx) * cz) * inv_norm_2) *
+            inv_norm * grad_normals_a[f][2];
+    grad_verts[i0][1] += grad_v0_y;
+
+    const float grad_v0_z =
+        ((-ay + by) * cx + (-bx + ax) * cy) / 2.0 * inv_norm * grad_areas_a[f] +
+        ((-ay + by) - cx * ((-ay + by) * cx + (-bx + ax) * cy) * inv_norm_2) *
+            inv_norm * grad_normals_a[f][0] +
+        ((-bx + ax) - cy * ((-ay + by) * cx + (-bx + ax) * cy) * inv_norm_2) *
+            inv_norm * grad_normals_a[f][1] +
+        -cz * ((-ay + by) * cx + (-bx + ax) * cy) * inv_norm_3 *
+            grad_normals_a[f][2];
+    grad_verts[i0][2] += grad_v0_z;
+
+    // grad v1 coming from grad areas and grad normals
+    const float grad_v1_x =
+        (by * cz - bz * cy) / 2.0 * inv_norm * grad_areas_a[f] +
+        -cx * (by * cz - bz * cy) * inv_norm_3 * grad_normals_a[f][0] +
+        (-bz - cy * (by * cz - bz * cy) * inv_norm_2) * inv_norm *
+            grad_normals_a[f][1] +
+        (by - cz * (by * cz - bz * cy) * inv_norm_2) * inv_norm *
+            grad_normals_a[f][2];
+    grad_verts[i1][0] += grad_v1_x;
+
+    const float grad_v1_y =
+        (bz * cx - bx * cz) / 2.0 * inv_norm * grad_areas_a[f] +
+        (bz - cx * (bz * cx - bx * cz) * inv_norm_2) * inv_norm *
+            grad_normals_a[f][0] +
+        -cy * (bz * cx - bx * cz) * inv_norm_3 * grad_normals_a[f][1] +
+        (-bx - cz * (bz * cx - bx * cz) * inv_norm_2) * inv_norm *
+            grad_normals_a[f][2];
+    grad_verts[i1][1] += grad_v1_y;
+
+    const float grad_v1_z =
+        (bx * cy - by * cx) / 2.0 * inv_norm * grad_areas_a[f] +
+        (-by - cx * (bx * cy - by * cx) * inv_norm_2) * inv_norm *
+            grad_normals_a[f][0] +
+        (bx - cx * (bx * cy - by * cx) * inv_norm_2) * inv_norm *
+            grad_normals_a[f][1] +
+        -cz * (bx * cy - by * cx) * inv_norm_3 * grad_normals_a[f][2];
+    grad_verts[i1][2] += grad_v1_z;
+
+    // grad v2 coming from grad areas
+    const float grad_v2_x =
+        (az * cy - ay * cz) / 2.0 * inv_norm * grad_areas_a[f] +
+        -cx * (az * cy - ay * cz) * inv_norm_3 * grad_normals_a[f][0] +
+        (az - cy * (az * cy - ay * cz) * inv_norm_2) * inv_norm *
+            grad_normals_a[f][1] +
+        (-ay - cz * (az * cy - ay * cz) * inv_norm_2) * inv_norm *
+            grad_normals_a[f][2];
+    grad_verts[i2][0] += grad_v2_x;
+
+    const float grad_v2_y =
+        (ax * cz - az * cx) / 2.0 * inv_norm * grad_areas_a[f] +
+        (-az - cx * (ax * cz - az * cx) * inv_norm_2) * inv_norm *
+            grad_normals_a[f][0] +
+        -cy * (ax * cz - az * cx) * inv_norm_3 * grad_normals_a[f][1] +
+        (ax - cz * (ax * cz - az * cx) * inv_norm_2) * inv_norm *
+            grad_normals_a[f][2];
+    grad_verts[i2][1] += grad_v2_y;
+
+    const float grad_v2_z =
+        (ay * cx - ax * cy) / 2.0 * inv_norm * grad_areas_a[f] +
+        (ay - cx * (ay * cx - ax * cy) * inv_norm_2) * inv_norm *
+            grad_normals_a[f][0] +
+        (-ax - cy * (ay * cx - ax * cy) * inv_norm_2) * inv_norm *
+            grad_normals_a[f][1] +
+        -cz * (ay * cx - ax * cy) * inv_norm_3 * grad_normals_a[f][2];
+    grad_verts[i2][2] += grad_v2_z;
+  }
+  return grad_verts;
+}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/gather_scatter/gather_scatter.cu

@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <ATen/ATen.h>
+#include <ATen/cuda/CUDAContext.h>
+#include <c10/cuda/CUDAGuard.h>
+
+// TODO(T47953967) to make this cuda kernel support all datatypes.
+__global__ void GatherScatterCudaKernel(
+    const float* __restrict__ input,
+    const int64_t* __restrict__ edges,
+    float* __restrict__ output,
+    bool directed,
+    bool backward,
+    const size_t V,
+    const size_t D,
+    const size_t E) {
+  const int tid = threadIdx.x;
+
+  // Reverse the vertex order if backward.
+  const int v0_idx = backward ? 1 : 0;
+  const int v1_idx = backward ? 0 : 1;
+
+  // Edges are split evenly across the blocks.
+  for (int e = blockIdx.x; e < E; e += gridDim.x) {
+    // Get indices of vertices which form the edge.
+    const int64_t v0 = edges[2 * e + v0_idx];
+    const int64_t v1 = edges[2 * e + v1_idx];
+
+    // Split vertex features evenly across threads.
+    // This implementation will be quite wasteful when D<128 since there will be
+    // a lot of threads doing nothing.
+    for (int d = tid; d < D; d += blockDim.x) {
+      const float val = input[v1 * D + d];
+      float* address = output + v0 * D + d;
+      atomicAdd(address, val);
+      if (!directed) {
+        const float val = input[v0 * D + d];
+        float* address = output + v1 * D + d;
+        atomicAdd(address, val);
+      }
+    }
+    __syncthreads();
+  }
+}
+
+at::Tensor GatherScatterCuda(
+    const at::Tensor& input,
+    const at::Tensor& edges,
+    bool directed,
+    bool backward) {
+  // Check inputs are on the same device
+  at::TensorArg input_t{input, "input", 1}, edges_t{edges, "edges", 2};
+  at::CheckedFrom c = "GatherScatterCuda";
+  at::checkAllSameGPU(c, {input_t, edges_t});
+
+  // Set the device for the kernel launch based on the device of the input
+  at::cuda::CUDAGuard device_guard(input.device());
+  cudaStream_t stream = at::cuda::getCurrentCUDAStream();
+
+  const auto num_vertices = input.size(0);
+  const auto input_feature_dim = input.size(1);
+  const auto num_edges = edges.size(0);
+
+  auto output = at::zeros({num_vertices, input_feature_dim}, input.options());
+  const size_t threads = 128;
+  const size_t max_blocks = 1920;
+  const size_t blocks = num_edges < max_blocks ? num_edges : max_blocks;
+
+  if (output.numel() == 0) {
+    AT_CUDA_CHECK(cudaGetLastError());
+    return output;
+  }
+
+  GatherScatterCudaKernel<<<blocks, threads, 0, stream>>>(
+      input.contiguous().data_ptr<float>(),
+      edges.contiguous().data_ptr<int64_t>(),
+      output.data_ptr<float>(),
+      directed,
+      backward,
+      num_vertices,
+      input_feature_dim,
+      num_edges);
+  AT_CUDA_CHECK(cudaGetLastError());
+  return output;
+}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/knn/knn_cpu.cpp

@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <torch/extension.h>
+#include <queue>
+#include <tuple>
+
+std::tuple<at::Tensor, at::Tensor> KNearestNeighborIdxCpu(
+    const at::Tensor& p1,
+    const at::Tensor& p2,
+    const at::Tensor& lengths1,
+    const at::Tensor& lengths2,
+    const int norm,
+    const int K) {
+  const int N = p1.size(0);
+  const int P1 = p1.size(1);
+  const int D = p1.size(2);
+
+  auto long_opts = lengths1.options().dtype(torch::kInt64);
+  torch::Tensor idxs = torch::full({N, P1, K}, 0, long_opts);
+  torch::Tensor dists = torch::full({N, P1, K}, 0, p1.options());
+
+  auto p1_a = p1.accessor<float, 3>();
+  auto p2_a = p2.accessor<float, 3>();
+  auto lengths1_a = lengths1.accessor<int64_t, 1>();
+  auto lengths2_a = lengths2.accessor<int64_t, 1>();
+  auto idxs_a = idxs.accessor<int64_t, 3>();
+  auto dists_a = dists.accessor<float, 3>();
+
+  for (int n = 0; n < N; ++n) {
+    const int64_t length1 = lengths1_a[n];
+    const int64_t length2 = lengths2_a[n];
+    for (int64_t i1 = 0; i1 < length1; ++i1) {
+      // Use a priority queue to store (distance, index) tuples.
+      std::priority_queue<std::tuple<float, int>> q;
+      for (int64_t i2 = 0; i2 < length2; ++i2) {
+        float dist = 0;
+        for (int d = 0; d < D; ++d) {
+          float diff = p1_a[n][i1][d] - p2_a[n][i2][d];
+          if (norm == 1) {
+            dist += abs(diff);
+          } else { // norm is 2 (default)
+            dist += diff * diff;
+          }
+        }
+        int size = static_cast<int>(q.size());
+        if (size < K || dist < std::get<0>(q.top())) {
+          q.emplace(dist, i2);
+          if (size >= K) {
+            q.pop();
+          }
+        }
+      }
+      while (!q.empty()) {
+        auto t = q.top();
+        q.pop();
+        const int k = q.size();
+        dists_a[n][i1][k] = std::get<0>(t);
+        idxs_a[n][i1][k] = std::get<1>(t);
+      }
+    }
+  }
+  return std::make_tuple(idxs, dists);
+}
+
+// ------------------------------------------------------------- //
+//                   Backward Operators                          //
+// ------------------------------------------------------------- //
+
+std::tuple<at::Tensor, at::Tensor> KNearestNeighborBackwardCpu(
+    const at::Tensor& p1,
+    const at::Tensor& p2,
+    const at::Tensor& lengths1,
+    const at::Tensor& lengths2,
+    const at::Tensor& idxs,
+    const int norm,
+    const at::Tensor& grad_dists) {
+  const int N = p1.size(0);
+  const int P1 = p1.size(1);
+  const int D = p1.size(2);
+  const int P2 = p2.size(1);
+  const int K = idxs.size(2);
+
+  torch::Tensor grad_p1 = torch::full({N, P1, D}, 0, p1.options());
+  torch::Tensor grad_p2 = torch::full({N, P2, D}, 0, p2.options());
+
+  auto p1_a = p1.accessor<float, 3>();
+  auto p2_a = p2.accessor<float, 3>();
+  auto lengths1_a = lengths1.accessor<int64_t, 1>();
+  auto lengths2_a = lengths2.accessor<int64_t, 1>();
+  auto idxs_a = idxs.accessor<int64_t, 3>();
+  auto grad_dists_a = grad_dists.accessor<float, 3>();
+  auto grad_p1_a = grad_p1.accessor<float, 3>();
+  auto grad_p2_a = grad_p2.accessor<float, 3>();
+
+  for (int n = 0; n < N; ++n) {
+    const int64_t length1 = lengths1_a[n];
+    int64_t length2 = lengths2_a[n];
+    length2 = (length2 < K) ? length2 : K;
+    for (int64_t i1 = 0; i1 < length1; ++i1) {
+      for (int64_t k = 0; k < length2; ++k) {
+        const int64_t i2 = idxs_a[n][i1][k];
+        // If the index is the pad value of -1 then ignore it
+        if (i2 == -1) {
+          continue;
+        }
+        for (int64_t d = 0; d < D; ++d) {
+          float diff = 0.0;
+          if (norm == 1) {
+            float sign = (p1_a[n][i1][d] > p2_a[n][i2][d]) ? 1.0 : -1.0;
+            diff = grad_dists_a[n][i1][k] * sign;
+          } else { // norm is 2 (default)
+            diff = 2.0f * grad_dists_a[n][i1][k] *
+                (p1_a[n][i1][d] - p2_a[n][i2][d]);
+          }
+          grad_p1_a[n][i1][d] += diff;
+          grad_p2_a[n][i2][d] += -1.0f * diff;
+        }
+      }
+    }
+  }
+  return std::make_tuple(grad_p1, grad_p2);
+}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/marching_cubes/marching_cubes.cu

@@ -0,0 +1,565 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <ATen/ATen.h>
+#include <ATen/cuda/CUDAContext.h>
+#include <c10/cuda/CUDAGuard.h>
+#include <cstdio>
+#include "marching_cubes/tables.h"
+
+/*
+Parallelized marching cubes for pytorch extension
+referenced and adapted from CUDA-Samples:
+(https://github.com/NVIDIA/cuda-samples/tree/master/Samples/5_Domain_Specific/marchingCubes)
+We divide the algorithm into two forward-passes:
+(1) The first forward-pass executes "ClassifyVoxelKernel" to
+evaluate volume scalar field for each cube and pre-compute
+two arrays -- number of vertices per cube (d_voxelVerts) and
+occupied or not per cube (d_voxelOccupied).
+
+Some prepration steps:
+With d_voxelOccupied, an exclusive scan is performed to compute
+the number of activeVoxels, which can be used to accelerate
+computation. With d_voxelVerts, another exclusive scan
+is performed to compute the accumulated sum of vertices in the 3d
+grid and totalVerts.
+
+(2) The second forward-pass calls "GenerateFacesKernel" to
+generate interpolated vertex positions and face indices by "marching
+through" each cube in the grid.
+
+*/
+
+// EPS: Used to indicate if two float values are close
+__constant__ const float EPSILON = 1e-5;
+
+// Linearly interpolate the position where an isosurface cuts an edge
+// between two vertices, based on their scalar values
+//
+// Args:
+//    isolevel: float value used as threshold
+//    p1: position of point1
+//    p2: position of point2
+//    valp1: field value for p1
+//    valp2: field value for p2
+//
+// Returns:
+//    point: interpolated verte
+//
+__device__ float3
+vertexInterp(float isolevel, float3 p1, float3 p2, float valp1, float valp2) {
+  float ratio;
+  float3 p;
+
+  if (abs(isolevel - valp1) < EPSILON) {
+    return p1;
+  } else if (abs(isolevel - valp2) < EPSILON) {
+    return p2;
+  } else if (abs(valp1 - valp2) < EPSILON) {
+    return p1;
+  }
+
+  ratio = (isolevel - valp1) / (valp2 - valp1);
+
+  p.x = p1.x * (1 - ratio) + p2.x * ratio;
+  p.y = p1.y * (1 - ratio) + p2.y * ratio;
+  p.z = p1.z * (1 - ratio) + p2.z * ratio;
+
+  return p;
+}
+
+// Determine if the triangle is degenerate
+// A triangle is degenerate when at least two of the vertices
+// share the same position.
+//
+// Args:
+//    p1: position of vertex p1
+//    p2: position of vertex p2
+//    p3: position of vertex p3
+//
+// Returns:
+//    boolean indicator if the triangle is degenerate
+__device__ bool isDegenerate(float3 p1, float3 p2, float3 p3) {
+  if ((abs(p1.x - p2.x) < EPSILON && abs(p1.y - p2.y) < EPSILON &&
+       abs(p1.z - p2.z) < EPSILON) ||
+      (abs(p2.x - p3.x) < EPSILON && abs(p2.y - p3.y) < EPSILON &&
+       abs(p2.z - p3.z) < EPSILON) ||
+      (abs(p3.x - p1.x) < EPSILON && abs(p3.y - p1.y) < EPSILON &&
+       abs(p3.z - p1.z) < EPSILON)) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+// Convert from local vertex id to global vertex id, given position
+// of the cube where the vertex resides. The function ensures vertices
+// shared from adjacent cubes are mapped to the same global id.
+
+// Args:
+//     v: local vertex id
+//     x: x position of the cube where the vertex belongs
+//     y: y position of the cube where the vertex belongs
+//     z: z position of the cube where the vertex belongs
+//     W: width of x dimension
+//     H: height of y dimension
+
+// Returns:
+//     global vertex id represented by its x/y/z offsets
+__device__ uint localToGlobal(int v, int x, int y, int z, int W, int H) {
+  const int dx = v & 1;
+  const int dy = v >> 1 & 1;
+  const int dz = v >> 2 & 1;
+  return (x + dx) + (y + dy) * W + (z + dz) * W * H;
+}
+
+// Hash_combine a pair of global vertex id to a single integer.
+//
+// Args:
+//    v1_id: global id of vertex 1
+//    v2_id: global id of vertex 2
+//    W: width of the 3d grid
+//    H: height of the 3d grid
+//    Z: depth of the 3d grid
+//
+// Returns:
+//    hashing for a pair of vertex ids
+//
+__device__ int64_t hashVpair(uint v1_id, uint v2_id, int W, int H, int D) {
+  return (int64_t)v1_id * (W + W * H + W * H * D) + (int64_t)v2_id;
+}
+
+// precompute number of vertices and occupancy
+// for each voxel in the grid.
+//
+// Args:
+//    voxelVerts: pointer to device array to store number
+//          of verts per voxel
+//    voxelOccupied: pointer to device array to store
+//          occupancy state per voxel
+//    vol: torch tensor stored with 3D scalar field
+//    isolevel: threshold to determine isosurface intersection
+//
+__global__ void ClassifyVoxelKernel(
+    at::PackedTensorAccessor32<int, 1, at::RestrictPtrTraits> voxelVerts,
+    at::PackedTensorAccessor32<int, 1, at::RestrictPtrTraits> voxelOccupied,
+    const at::PackedTensorAccessor32<float, 3, at::RestrictPtrTraits> vol,
+    // const at::PackedTensorAccessor<int, 1, at::RestrictPtrTraits>
+    // numVertsTable,
+    float isolevel) {
+  const int indexTable[8]{0, 1, 4, 5, 3, 2, 7, 6};
+  const uint D = vol.size(0) - 1;
+  const uint H = vol.size(1) - 1;
+  const uint W = vol.size(2) - 1;
+
+  // 1-d grid
+  uint id = blockIdx.x * blockDim.x + threadIdx.x;
+  uint num_threads = gridDim.x * blockDim.x;
+
+  // Table mapping from cubeindex to number of vertices in the configuration
+  const unsigned char numVertsTable[256] = {
+      0,  3,  3,  6,  3,  6,  6,  9,  3,  6,  6,  9,  6,  9,  9,  6,  3,  6,
+      6,  9,  6,  9,  9,  12, 6,  9,  9,  12, 9,  12, 12, 9,  3,  6,  6,  9,
+      6,  9,  9,  12, 6,  9,  9,  12, 9,  12, 12, 9,  6,  9,  9,  6,  9,  12,
+      12, 9,  9,  12, 12, 9,  12, 15, 15, 6,  3,  6,  6,  9,  6,  9,  9,  12,
+      6,  9,  9,  12, 9,  12, 12, 9,  6,  9,  9,  12, 9,  12, 12, 15, 9,  12,
+      12, 15, 12, 15, 15, 12, 6,  9,  9,  12, 9,  12, 6,  9,  9,  12, 12, 15,
+      12, 15, 9,  6,  9,  12, 12, 9,  12, 15, 9,  6,  12, 15, 15, 12, 15, 6,
+      12, 3,  3,  6,  6,  9,  6,  9,  9,  12, 6,  9,  9,  12, 9,  12, 12, 9,
+      6,  9,  9,  12, 9,  12, 12, 15, 9,  6,  12, 9,  12, 9,  15, 6,  6,  9,
+      9,  12, 9,  12, 12, 15, 9,  12, 12, 15, 12, 15, 15, 12, 9,  12, 12, 9,
+      12, 15, 15, 12, 12, 9,  15, 6,  15, 12, 6,  3,  6,  9,  9,  12, 9,  12,
+      12, 15, 9,  12, 12, 15, 6,  9,  9,  6,  9,  12, 12, 15, 12, 15, 15, 6,
+      12, 9,  15, 12, 9,  6,  12, 3,  9,  12, 12, 15, 12, 15, 9,  12, 12, 15,
+      15, 6,  9,  12, 6,  3,  6,  9,  9,  6,  9,  12, 6,  3,  9,  6,  12, 3,
+      6,  3,  3,  0,
+  };
+
+  for (uint tid = id; tid < D * H * W; tid += num_threads) {
+    // compute global location of the voxel
+    const int gx = tid % W;
+    const int gy = tid / W % H;
+    const int gz = tid / (W * H);
+
+    int cubeindex = 0;
+    for (int i = 0; i < 8; i++) {
+      const int dx = i & 1;
+      const int dy = i >> 1 & 1;
+      const int dz = i >> 2 & 1;
+
+      const int x = gx + dx;
+      const int y = gy + dy;
+      const int z = gz + dz;
+
+      if (vol[z][y][x] < isolevel) {
+        cubeindex |= 1 << indexTable[i];
+      }
+    }
+    // collect number of vertices for each voxel
+    unsigned char numVerts = numVertsTable[cubeindex];
+    voxelVerts[tid] = numVerts;
+    voxelOccupied[tid] = (numVerts > 0);
+  }
+}
+
+// extract compact voxel array for acceleration
+//
+// Args:
+//    compactedVoxelArray: tensor of shape (activeVoxels,) which maps
+//          from accumulated non-empty voxel index to original 3d grid index
+//    voxelOccupied: tensor of shape (numVoxels,) which stores
+//          the occupancy state per voxel
+//    voxelOccupiedScan: tensor of shape (numVoxels,) which
+//          stores the accumulated occupied voxel counts
+//    numVoxels: number of total voxels in the grid
+//
+__global__ void CompactVoxelsKernel(
+    at::PackedTensorAccessor32<int, 1, at::RestrictPtrTraits>
+        compactedVoxelArray,
+    const at::PackedTensorAccessor32<int, 1, at::RestrictPtrTraits>
+        voxelOccupied,
+    const at::PackedTensorAccessor32<int64_t, 1, at::RestrictPtrTraits>
+        voxelOccupiedScan,
+    uint numVoxels) {
+  uint id = blockIdx.x * blockDim.x + threadIdx.x;
+  uint num_threads = gridDim.x * blockDim.x;
+  for (uint tid = id; tid < numVoxels; tid += num_threads) {
+    if (voxelOccupied[tid]) {
+      compactedVoxelArray[voxelOccupiedScan[tid]] = tid;
+    }
+  }
+}
+
+// generate triangles for each voxel using marching cubes
+//
+// Args:
+//    verts: torch tensor of shape (V, 3) to store interpolated mesh vertices
+//    faces: torch tensor of shape (F, 3) to store indices for mesh faces
+//    ids: torch tensor of shape (V) to store id of each vertex
+//    compactedVoxelArray: tensor of shape (activeVoxels,) which stores
+//          non-empty voxel index.
+//    numVertsScanned: tensor of shape (numVoxels,) which stores accumulated
+//          vertices count in the voxel
+//    activeVoxels: number of active voxels used for acceleration
+//    vol: torch tensor stored with 3D scalar field
+//    isolevel: threshold to determine isosurface intersection
+//
+__global__ void GenerateFacesKernel(
+    at::PackedTensorAccessor32<float, 2, at::RestrictPtrTraits> verts,
+    at::PackedTensorAccessor<int64_t, 2, at::RestrictPtrTraits> faces,
+    at::PackedTensorAccessor<int64_t, 1, at::RestrictPtrTraits> ids,
+    at::PackedTensorAccessor32<int, 1, at::RestrictPtrTraits>
+        compactedVoxelArray,
+    at::PackedTensorAccessor32<int64_t, 1, at::RestrictPtrTraits>
+        numVertsScanned,
+    const uint activeVoxels,
+    const at::PackedTensorAccessor32<float, 3, at::RestrictPtrTraits> vol,
+    const at::PackedTensorAccessor32<int, 2, at::RestrictPtrTraits> faceTable,
+    // const at::PackedTensorAccessor32<int, 1, at::RestrictPtrTraits>
+    // numVertsTable,
+    const float isolevel) {
+  uint id = blockIdx.x * blockDim.x + threadIdx.x;
+  uint num_threads = gridDim.x * blockDim.x;
+  const int faces_size = faces.size(0);
+  // Table mapping each edge to the corresponding cube vertices offsets
+  const int edgeToVertsTable[12][2] = {
+      {0, 1},
+      {1, 5},
+      {4, 5},
+      {0, 4},
+      {2, 3},
+      {3, 7},
+      {6, 7},
+      {2, 6},
+      {0, 2},
+      {1, 3},
+      {5, 7},
+      {4, 6},
+  };
+
+  // Table mapping from cubeindex to number of vertices in the configuration
+  const unsigned char numVertsTable[256] = {
+      0,  3,  3,  6,  3,  6,  6,  9,  3,  6,  6,  9,  6,  9,  9,  6,  3,  6,
+      6,  9,  6,  9,  9,  12, 6,  9,  9,  12, 9,  12, 12, 9,  3,  6,  6,  9,
+      6,  9,  9,  12, 6,  9,  9,  12, 9,  12, 12, 9,  6,  9,  9,  6,  9,  12,
+      12, 9,  9,  12, 12, 9,  12, 15, 15, 6,  3,  6,  6,  9,  6,  9,  9,  12,
+      6,  9,  9,  12, 9,  12, 12, 9,  6,  9,  9,  12, 9,  12, 12, 15, 9,  12,
+      12, 15, 12, 15, 15, 12, 6,  9,  9,  12, 9,  12, 6,  9,  9,  12, 12, 15,
+      12, 15, 9,  6,  9,  12, 12, 9,  12, 15, 9,  6,  12, 15, 15, 12, 15, 6,
+      12, 3,  3,  6,  6,  9,  6,  9,  9,  12, 6,  9,  9,  12, 9,  12, 12, 9,
+      6,  9,  9,  12, 9,  12, 12, 15, 9,  6,  12, 9,  12, 9,  15, 6,  6,  9,
+      9,  12, 9,  12, 12, 15, 9,  12, 12, 15, 12, 15, 15, 12, 9,  12, 12, 9,
+      12, 15, 15, 12, 12, 9,  15, 6,  15, 12, 6,  3,  6,  9,  9,  12, 9,  12,
+      12, 15, 9,  12, 12, 15, 6,  9,  9,  6,  9,  12, 12, 15, 12, 15, 15, 6,
+      12, 9,  15, 12, 9,  6,  12, 3,  9,  12, 12, 15, 12, 15, 9,  12, 12, 15,
+      15, 6,  9,  12, 6,  3,  6,  9,  9,  6,  9,  12, 6,  3,  9,  6,  12, 3,
+      6,  3,  3,  0,
+  };
+
+  for (uint tid = id; tid < activeVoxels; tid += num_threads) {
+    uint voxel = compactedVoxelArray[tid]; // maps from accumulated id to
+                                           // original 3d voxel id
+    // mapping from offsets to vi index
+    int indexTable[8]{0, 1, 4, 5, 3, 2, 7, 6};
+    // field value for each vertex
+    float val[8];
+    // position for each vertex
+    float3 p[8];
+    // 3d address
+    const uint D = vol.size(0) - 1;
+    const uint H = vol.size(1) - 1;
+    const uint W = vol.size(2) - 1;
+
+    const int gx = voxel % W;
+    const int gy = voxel / W % H;
+    const int gz = voxel / (W * H);
+
+    // recalculate cubeindex;
+    uint cubeindex = 0;
+    for (int i = 0; i < 8; i++) {
+      const int dx = i & 1;
+      const int dy = i >> 1 & 1;
+      const int dz = i >> 2 & 1;
+
+      const int x = gx + dx;
+      const int y = gy + dy;
+      const int z = gz + dz;
+
+      if (vol[z][y][x] < isolevel) {
+        cubeindex |= 1 << indexTable[i];
+      }
+      val[indexTable[i]] = vol[z][y][x]; // maps from vi to volume
+      p[indexTable[i]] = make_float3(x, y, z); // maps from vi to position
+    }
+
+    // Interpolate vertices where the surface intersects the cube
+    float3 vertlist[12];
+    vertlist[0] = vertexInterp(isolevel, p[0], p[1], val[0], val[1]);
+    vertlist[1] = vertexInterp(isolevel, p[1], p[2], val[1], val[2]);
+    vertlist[2] = vertexInterp(isolevel, p[3], p[2], val[3], val[2]);
+    vertlist[3] = vertexInterp(isolevel, p[0], p[3], val[0], val[3]);
+
+    vertlist[4] = vertexInterp(isolevel, p[4], p[5], val[4], val[5]);
+    vertlist[5] = vertexInterp(isolevel, p[5], p[6], val[5], val[6]);
+    vertlist[6] = vertexInterp(isolevel, p[7], p[6], val[7], val[6]);
+    vertlist[7] = vertexInterp(isolevel, p[4], p[7], val[4], val[7]);
+
+    vertlist[8] = vertexInterp(isolevel, p[0], p[4], val[0], val[4]);
+    vertlist[9] = vertexInterp(isolevel, p[1], p[5], val[1], val[5]);
+    vertlist[10] = vertexInterp(isolevel, p[2], p[6], val[2], val[6]);
+    vertlist[11] = vertexInterp(isolevel, p[3], p[7], val[3], val[7]);
+
+    // output triangle faces
+    uint numVerts = numVertsTable[cubeindex];
+
+    for (int i = 0; i < numVerts; i++) {
+      int index = numVertsScanned[voxel] + i;
+      unsigned char edge = faceTable[cubeindex][i];
+
+      uint v1 = edgeToVertsTable[edge][0];
+      uint v2 = edgeToVertsTable[edge][1];
+      uint v1_id = localToGlobal(v1, gx, gy, gz, W + 1, H + 1);
+      uint v2_id = localToGlobal(v2, gx, gy, gz, W + 1, H + 1);
+      int64_t edge_id = hashVpair(v1_id, v2_id, W + 1, H + 1, D + 1);
+
+      verts[index][0] = vertlist[edge].x;
+      verts[index][1] = vertlist[edge].y;
+      verts[index][2] = vertlist[edge].z;
+
+      if (index < faces_size) {
+        faces[index][0] = index * 3 + 0;
+        faces[index][1] = index * 3 + 1;
+        faces[index][2] = index * 3 + 2;
+      }
+
+      ids[index] = edge_id;
+    }
+  } // end for grid-strided kernel
+}
+
+// ATen/Torch does not have an exclusive-scan operator. Additionally, in the
+// code below we need to get the "total number of items to work on" after
+// a scan, which with an inclusive-scan would simply be the value of the last
+// element in the tensor.
+//
+// This utility function hits two birds with one stone, by running
+// an inclusive-scan into a right-shifted view of a tensor that's
+// allocated to be one element bigger than the input tensor.
+//
+// Note; return tensor is `int64_t` per element, even if the input
+// tensor is only 32-bit. Also, the return tensor is one element bigger
+// than the input one.
+//
+// Secondary optional argument is an output argument that gets the
+// value of the last element of the return tensor (because you almost
+// always need this CPU-side right after this function anyway).
+static at::Tensor ExclusiveScanAndTotal(
+    const at::Tensor& inTensor,
+    int64_t* optTotal = nullptr) {
+  const auto inSize = inTensor.sizes()[0];
+  auto retTensor = at::zeros({inSize + 1}, at::kLong).to(inTensor.device());
+
+  using at::indexing::None;
+  using at::indexing::Slice;
+  auto rightShiftedView = retTensor.index({Slice(1, None)});
+
+  // Do an (inclusive-scan) cumulative sum in to the view that's
+  // shifted one element to the right...
+  at::cumsum_out(rightShiftedView, inTensor, 0, at::kLong);
+
+  if (optTotal) {
+    *optTotal = retTensor[inSize].cpu().item<int64_t>();
+  }
+
+  // ...so that the not-shifted tensor holds the exclusive-scan
+  return retTensor;
+}
+
+// Entrance for marching cubes cuda extension. Marching Cubes is an algorithm to
+// create triangle meshes from an implicit function (one of the form f(x, y, z)
+// = 0). It works by iteratively checking a grid of cubes superimposed over a
+// region of the function. The number of faces and positions of the vertices in
+// each cube are determined by the the isolevel as well as the volume values
+// from the eight vertices of the cube.
+//
+// We implement this algorithm with two forward passes where the first pass
+// checks the occupancy and collects number of vertices for each cube. The
+// second pass will skip empty voxels and generate vertices as well as faces for
+// each cube through table lookup. The vertex positions, faces and identifiers
+// for each vertex will be returned.
+//
+//
+// Args:
+//    vol: torch tensor of shape (D, H, W) for volume scalar field
+//    isolevel: threshold to determine isosurface intesection
+//
+// Returns:
+//     tuple of <verts, faces, ids>: which stores vertex positions, face
+//         indices and integer identifiers for each vertex.
+//    verts: (N_verts, 3) FloatTensor for vertex positions
+//    faces: (N_faces, 3) LongTensor of face indices
+//    ids: (N_verts,) LongTensor used to identify each vertex. Vertices from
+//         adjacent edges can share the same 3d position. To reduce memory
+//         redudancy, we tag each vertex with a unique id for deduplication. In
+//         contrast to deduping on vertices, this has the benefit to avoid
+//         floating point precision issues.
+//
+std::tuple<at::Tensor, at::Tensor, at::Tensor> MarchingCubesCuda(
+    const at::Tensor& vol,
+    const float isolevel) {
+  // Set the device for the kernel launch based on the device of vol
+  at::cuda::CUDAGuard device_guard(vol.device());
+  cudaStream_t stream = at::cuda::getCurrentCUDAStream();
+
+  // transfer _FACE_TABLE data to device
+  at::Tensor face_table_tensor = at::zeros(
+      {256, 16}, at::TensorOptions().dtype(at::kInt).device(at::kCPU));
+  auto face_table_a = face_table_tensor.accessor<int, 2>();
+  for (int i = 0; i < 256; i++) {
+    for (int j = 0; j < 16; j++) {
+      face_table_a[i][j] = _FACE_TABLE[i][j];
+    }
+  }
+  at::Tensor faceTable = face_table_tensor.to(vol.device());
+
+  // get numVoxels
+  int threads = 128;
+  const uint D = vol.size(0);
+  const uint H = vol.size(1);
+  const uint W = vol.size(2);
+  const int numVoxels = (D - 1) * (H - 1) * (W - 1);
+  dim3 grid((numVoxels + threads - 1) / threads, 1, 1);
+  if (grid.x > 65535) {
+    grid.x = 65535;
+  }
+
+  using at::indexing::None;
+  using at::indexing::Slice;
+
+  auto d_voxelVerts =
+      at::zeros({numVoxels}, at::TensorOptions().dtype(at::kInt))
+          .to(vol.device());
+  auto d_voxelOccupied =
+      at::zeros({numVoxels}, at::TensorOptions().dtype(at::kInt))
+          .to(vol.device());
+
+  // Execute "ClassifyVoxelKernel" kernel to precompute
+  // two arrays - d_voxelOccupied and d_voxelVertices to global memory,
+  // which stores the occupancy state and number of voxel vertices per voxel.
+  ClassifyVoxelKernel<<<grid, threads, 0, stream>>>(
+      d_voxelVerts.packed_accessor32<int, 1, at::RestrictPtrTraits>(),
+      d_voxelOccupied.packed_accessor32<int, 1, at::RestrictPtrTraits>(),
+      vol.packed_accessor32<float, 3, at::RestrictPtrTraits>(),
+      isolevel);
+  AT_CUDA_CHECK(cudaGetLastError());
+  cudaDeviceSynchronize();
+
+  // Scan "d_voxelOccupied" array to generate accumulated voxel occupancy
+  // count for voxels in the grid and compute the number of active voxels.
+  // If the number of active voxels is 0, return zero tensor for verts and
+  // faces.
+  int64_t activeVoxels = 0;
+  auto d_voxelOccupiedScan =
+      ExclusiveScanAndTotal(d_voxelOccupied, &activeVoxels);
+
+  const int device_id = vol.device().index();
+  auto opt = at::TensorOptions().dtype(at::kInt).device(at::kCUDA, device_id);
+  auto opt_long =
+      at::TensorOptions().dtype(at::kLong).device(at::kCUDA, device_id);
+
+  if (activeVoxels == 0) {
+    int ntris = 0;
+    at::Tensor verts = at::zeros({ntris * 3, 3}, vol.options());
+    at::Tensor faces = at::zeros({ntris, 3}, opt_long);
+    at::Tensor ids = at::zeros({ntris}, opt_long);
+    return std::make_tuple(verts, faces, ids);
+  }
+
+  // Execute "CompactVoxelsKernel" kernel to compress voxels for acceleration.
+  // This allows us to run triangle generation on only the occupied voxels.
+  auto d_compVoxelArray = at::zeros({activeVoxels}, opt);
+  CompactVoxelsKernel<<<grid, threads, 0, stream>>>(
+      d_compVoxelArray.packed_accessor32<int, 1, at::RestrictPtrTraits>(),
+      d_voxelOccupied.packed_accessor32<int, 1, at::RestrictPtrTraits>(),
+      d_voxelOccupiedScan
+          .packed_accessor32<int64_t, 1, at::RestrictPtrTraits>(),
+      numVoxels);
+  AT_CUDA_CHECK(cudaGetLastError());
+  cudaDeviceSynchronize();
+
+  // Scan d_voxelVerts array to generate offsets of vertices for each voxel
+  int64_t totalVerts = 0;
+  auto d_voxelVertsScan = ExclusiveScanAndTotal(d_voxelVerts, &totalVerts);
+
+  // Execute "GenerateFacesKernel" kernel
+  // This runs only on the occupied voxels.
+  // It looks up the field values and generates the triangle data.
+  at::Tensor verts = at::zeros({totalVerts, 3}, vol.options());
+  at::Tensor faces = at::zeros({totalVerts / 3, 3}, opt_long);
+
+  at::Tensor ids = at::zeros({totalVerts}, opt_long);
+
+  dim3 grid2((activeVoxels + threads - 1) / threads, 1, 1);
+  if (grid2.x > 65535) {
+    grid2.x = 65535;
+  }
+
+  GenerateFacesKernel<<<grid2, threads, 0, stream>>>(
+      verts.packed_accessor32<float, 2, at::RestrictPtrTraits>(),
+      faces.packed_accessor<int64_t, 2, at::RestrictPtrTraits>(),
+      ids.packed_accessor<int64_t, 1, at::RestrictPtrTraits>(),
+      d_compVoxelArray.packed_accessor32<int, 1, at::RestrictPtrTraits>(),
+      d_voxelVertsScan.packed_accessor32<int64_t, 1, at::RestrictPtrTraits>(),
+      activeVoxels,
+      vol.packed_accessor32<float, 3, at::RestrictPtrTraits>(),
+      faceTable.packed_accessor32<int, 2, at::RestrictPtrTraits>(),
+      isolevel);
+  AT_CUDA_CHECK(cudaGetLastError());
+
+  return std::make_tuple(verts, faces, ids);
+}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/marching_cubes/marching_cubes.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+#include <torch/extension.h>
+#include <tuple>
+#include <vector>
+#include "utils/pytorch3d_cutils.h"
+
+// Run Marching Cubes algorithm over a batch of volume scalar fields
+// with a pre-defined threshold and return a mesh composed of vertices
+// and faces for the mesh.
+//
+// Args:
+//    vol: FloatTensor of shape (D, H, W) giving a volume
+//    scalar grids.
+//    isolevel: isosurface value to use as the threshoold to determine whether
+//    the points are within a volume.
+//
+// Returns:
+//    vertices: (N_verts, 3) FloatTensor of vertices
+//    faces: (N_faces, 3) LongTensor of faces
+//    ids: (N_verts,) LongTensor used to identify each vertex and deduplication
+//         to avoid floating point precision issues.
+//         For Cuda, will be used to dedupe redundant vertices.
+//         For cpp implementation, this tensor is just a placeholder.
+
+// CPU implementation
+std::tuple<at::Tensor, at::Tensor, at::Tensor> MarchingCubesCpu(
+    const at::Tensor& vol,
+    const float isolevel);
+
+// CUDA implementation
+std::tuple<at::Tensor, at::Tensor, at::Tensor> MarchingCubesCuda(
+    const at::Tensor& vol,
+    const float isolevel);
+
+// Implementation which is exposed
+inline std::tuple<at::Tensor, at::Tensor, at::Tensor> MarchingCubes(
+    const at::Tensor& vol,
+    const float isolevel) {
+  if (vol.is_cuda()) {
+#ifdef WITH_CUDA
+    CHECK_CUDA(vol);
+    const int D = vol.size(0);
+    const int H = vol.size(1);
+    const int W = vol.size(2);
+    if (D > 1024 || H > 1024 || W > 1024) {
+      AT_ERROR("Maximum volume size allowed 1K x 1K x 1K");
+    }
+    return MarchingCubesCuda(vol.contiguous(), isolevel);
+#else
+    AT_ERROR("Not compiled with GPU support.");
+#endif
+  }
+  return MarchingCubesCpu(vol.contiguous(), isolevel);
+}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/marching_cubes/marching_cubes_cpu.cpp

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <torch/extension.h>
+#include <algorithm>
+#include <array>
+#include <cstring>
+#include <unordered_map>
+#include <vector>
+#include "marching_cubes/marching_cubes_utils.h"
+#include "marching_cubes/tables.h"
+
+// Cpu implementation for Marching Cubes
+// Args:
+//    vol: a Tensor of size (D, H, W) corresponding to a 3D scalar field
+//    isolevel: the isosurface value to use as the threshold to determine
+//          whether points are within a volume.
+//
+// Returns:
+//    vertices: a float tensor of shape (N_verts, 3) for positions of the mesh
+//    faces: a long tensor of shape (N_faces, 3) for indices of the face
+//    ids: a long tensor of shape (N_verts) as placeholder
+//
+std::tuple<at::Tensor, at::Tensor, at::Tensor> MarchingCubesCpu(
+    const at::Tensor& vol,
+    const float isolevel) {
+  // volume shapes
+  const int D = vol.size(0);
+  const int H = vol.size(1);
+  const int W = vol.size(2);
+
+  // Create tensor accessors
+  auto vol_a = vol.accessor<float, 3>();
+  // edge_id_to_v maps from an edge id to a vertex position
+  std::unordered_map<int64_t, Vertex> edge_id_to_v;
+  // uniq_edge_id: used to remove redundant edge ids
+  std::unordered_map<int64_t, int64_t> uniq_edge_id;
+  std::vector<int64_t> faces; // store face indices
+  std::vector<Vertex> verts; // store vertex positions
+  // enumerate each cell in the 3d grid
+  for (int z = 0; z < D - 1; z++) {
+    for (int y = 0; y < H - 1; y++) {
+      for (int x = 0; x < W - 1; x++) {
+        Cube cube(x, y, z, vol_a, isolevel);
+        // Cube is entirely in/out of the surface
+        if (_FACE_TABLE[cube.cubeindex][0] == 255) {
+          continue;
+        }
+        // store all boundary vertices that intersect with the edges
+        std::array<Vertex, 12> interp_points;
+        // triangle vertex IDs and positions
+        std::vector<int64_t> tri;
+        std::vector<Vertex> ps;
+
+        // Interpolate the vertices where the surface intersects with the cube
+        for (int j = 0; _FACE_TABLE[cube.cubeindex][j] != 255; j++) {
+          const int e = _FACE_TABLE[cube.cubeindex][j];
+          interp_points[e] = cube.VertexInterp(isolevel, e, vol_a);
+
+          int64_t edge = cube.HashVpair(e, W, H, D);
+          tri.push_back(edge);
+          ps.push_back(interp_points[e]);
+
+          // Check if the triangle face is degenerate. A triangle face
+          // is degenerate if any of the two verices share the same 3D position
+          if ((j + 1) % 3 == 0 && ps[0] != ps[1] && ps[1] != ps[2] &&
+              ps[2] != ps[0]) {
+            for (int k = 0; k < 3; k++) {
+              int64_t v = tri.at(k);
+              edge_id_to_v[v] = ps.at(k);
+              if (!uniq_edge_id.count(v)) {
+                uniq_edge_id[v] = verts.size();
+                verts.push_back(edge_id_to_v[v]);
+              }
+              faces.push_back(uniq_edge_id[v]);
+            }
+            tri.clear();
+            ps.clear();
+          } // endif
+        } // endfor edge enumeration
+      } // endfor x
+    } // endfor y
+  } // endfor z
+  // Collect returning tensor
+  const int n_vertices = verts.size();
+  const int64_t n_faces = (int64_t)faces.size() / 3;
+  auto vert_tensor = torch::zeros({n_vertices, 3}, torch::kFloat);
+  auto id_tensor = torch::zeros({n_vertices}, torch::kInt64); // placeholder
+  auto face_tensor = torch::zeros({n_faces, 3}, torch::kInt64);
+
+  auto vert_a = vert_tensor.accessor<float, 2>();
+  for (int i = 0; i < n_vertices; i++) {
+    vert_a[i][0] = verts.at(i).x;
+    vert_a[i][1] = verts.at(i).y;
+    vert_a[i][2] = verts.at(i).z;
+  }
+
+  auto face_a = face_tensor.accessor<int64_t, 2>();
+  for (int64_t i = 0; i < n_faces; i++) {
+    face_a[i][0] = faces.at(i * 3 + 0);
+    face_a[i][1] = faces.at(i * 3 + 1);
+    face_a[i][2] = faces.at(i * 3 + 2);
+  }
+
+  return std::make_tuple(vert_tensor, face_tensor, id_tensor);
+}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/marching_cubes/marching_cubes_utils.h

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+#include <torch/extension.h>
+#include <cmath>
+#include <cstdint>
+#include <vector>
+#include "ATen/core/TensorAccessor.h"
+#include "marching_cubes/tables.h"
+
+// EPS: Used to assess whether two float values are close
+const float EPS = 1e-5;
+
+// Data structures for the marching cubes
+struct Vertex {
+  // Constructor used when performing marching cube in each cell
+  explicit Vertex(float x = 0.0f, float y = 0.0f, float z = 0.0f)
+      : x(x), y(y), z(z) {}
+
+  // The */+ operator overrides are used for vertex interpolation
+  Vertex operator*(float s) const {
+    return Vertex(x * s, y * s, z * s);
+  }
+  Vertex operator+(const Vertex& xyz) const {
+    return Vertex(x + xyz.x, y + xyz.y, z + xyz.z);
+  }
+  // The =/!= operator overrides is used for checking degenerate triangles
+  bool operator==(const Vertex& xyz) const {
+    return (
+        std::abs(x - xyz.x) < EPS && std::abs(y - xyz.y) < EPS &&
+        std::abs(z - xyz.z) < EPS);
+  }
+  bool operator!=(const Vertex& xyz) const {
+    return (
+        std::abs(x - xyz.x) >= EPS || std::abs(y - xyz.y) >= EPS ||
+        std::abs(z - xyz.z) >= EPS);
+  }
+  // vertex position
+  float x, y, z;
+};
+
+struct Cube {
+  // Edge and vertex convention:
+  //                     v4_______e4____________v5
+  //                     /|                    /|
+  //                    / |                   / |
+  //                 e7/  |                e5/  |
+  //                  /___|______e6_________/   |
+  //               v7|    |                 |v6 |e9
+  //                 |    |                 |   |
+  //                 |    |e8               |e10|
+  //              e11|    |                 |   |
+  //                 |    |_________________|___|
+  //                 |   / v0      e0       |   /v1
+  //                 |  /                   |  /
+  //                 | /e3                  | /e1
+  //                 |/_____________________|/
+  //                 v3         e2          v2
+
+  Vertex p[8];
+  int x, y, z;
+  int cubeindex = 0;
+  Cube(
+      int x,
+      int y,
+      int z,
+      const at::TensorAccessor<float, 3>& vol_a,
+      const float isolevel)
+      : x(x), y(y), z(z) {
+    // vertex position (x, y, z) for v0-v1-v4-v5-v3-v2-v7-v6
+    for (int v = 0; v < 8; v++) {
+      p[v] = Vertex(x + (v & 1), y + (v >> 1 & 1), z + (v >> 2 & 1));
+    }
+    // Calculates cube configuration index given values of the cube vertices
+    for (int i = 0; i < 8; i++) {
+      const int idx = _INDEX_TABLE[i];
+      Vertex v = p[idx];
+      if (vol_a[v.z][v.y][v.x] < isolevel) {
+        cubeindex |= (1 << i);
+      }
+    }
+  }
+
+  // Linearly interpolate the position where an isosurface cuts an edge
+  // between two vertices, based on their scalar values
+  //
+  // Args:
+  //    isolevel: float value used as threshold
+  //    edge: edge (ID) to interpolate
+  //    cube: current cube vertices
+  //    vol_a: 3D scalar field
+  //
+  // Returns:
+  //    point: interpolated vertex
+  Vertex VertexInterp(
+      float isolevel,
+      const int edge,
+      const at::TensorAccessor<float, 3>& vol_a) {
+    const int v1 = _EDGE_TO_VERTICES[edge][0];
+    const int v2 = _EDGE_TO_VERTICES[edge][1];
+    Vertex p1 = p[v1];
+    Vertex p2 = p[v2];
+    float val1 = vol_a[p1.z][p1.y][p1.x];
+    float val2 = vol_a[p2.z][p2.y][p2.x];
+
+    float ratio = 1.0f;
+    if (std::abs(isolevel - val1) < EPS) {
+      return p1;
+    } else if (std::abs(isolevel - val2) < EPS) {
+      return p2;
+    } else if (std::abs(val1 - val2) < EPS) {
+      return p1;
+    }
+    // interpolate vertex p based on two vertices on the edge
+    ratio = (isolevel - val1) / (val2 - val1);
+    return p1 * (1 - ratio) + p2 * ratio;
+  }
+
+  // Hash an edge into a global edge_id. The function binds an
+  // edge with an integer to address floating point precision issue.
+  //
+  // Args:
+  //    v1_id: global id of vertex 1
+  //    v2_id: global id of vertex 2
+  //    W: width of the 3d grid
+  //    H: height of the 3d grid
+  //    D: depth of the 3d grid
+  //
+  // Returns:
+  //    hashing for a pair of vertex ids
+  //
+  int64_t HashVpair(const int edge, int W, int H, int D) {
+    const int v1 = _EDGE_TO_VERTICES[edge][0];
+    const int v2 = _EDGE_TO_VERTICES[edge][1];
+    const int v1_id = p[v1].x + p[v1].y * W + p[v1].z * W * H;
+    const int v2_id = p[v2].x + p[v2].y * W + p[v2].z * W * H;
+    return (int64_t)v1_id * (W + W * H + W * H * D) + (int64_t)v2_id;
+  }
+};

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/marching_cubes/tables.h

@@ -0,0 +1,294 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+using uint = unsigned int;
+
+// A table mapping from cubeindex to a list of face configurations.
+// Each list contains at most 5 faces, where each face is represented with
+// 3 consecutive numbers
+// Table adapted from http://paulbourke.net/geometry/polygonise/
+//
+#define X 255
+const unsigned char _FACE_TABLE[256][16] = {
+    {X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X},
+    {0, 8, 3, X, X, X, X, X, X, X, X, X, X, X, X, X},
+    {0, 1, 9, X, X, X, X, X, X, X, X, X, X, X, X, X},
+    {1, 8, 3, 9, 8, 1, X, X, X, X, X, X, X, X, X, X},
+    {1, 2, 10, X, X, X, X, X, X, X, X, X, X, X, X, X},
+    {0, 8, 3, 1, 2, 10, X, X, X, X, X, X, X, X, X, X},
+    {9, 2, 10, 0, 2, 9, X, X, X, X, X, X, X, X, X, X},
+    {2, 8, 3, 2, 10, 8, 10, 9, 8, X, X, X, X, X, X, X},
+    {3, 11, 2, X, X, X, X, X, X, X, X, X, X, X, X, X},
+    {0, 11, 2, 8, 11, 0, X, X, X, X, X, X, X, X, X, X},
+    {1, 9, 0, 2, 3, 11, X, X, X, X, X, X, X, X, X, X},
+    {1, 11, 2, 1, 9, 11, 9, 8, 11, X, X, X, X, X, X, X},
+    {3, 10, 1, 11, 10, 3, X, X, X, X, X, X, X, X, X, X},
+    {0, 10, 1, 0, 8, 10, 8, 11, 10, X, X, X, X, X, X, X},
+    {3, 9, 0, 3, 11, 9, 11, 10, 9, X, X, X, X, X, X, X},
+    {9, 8, 10, 10, 8, 11, X, X, X, X, X, X, X, X, X, X},
+    {4, 7, 8, X, X, X, X, X, X, X, X, X, X, X, X, X},
+    {4, 3, 0, 7, 3, 4, X, X, X, X, X, X, X, X, X, X},
+    {0, 1, 9, 8, 4, 7, X, X, X, X, X, X, X, X, X, X},
+    {4, 1, 9, 4, 7, 1, 7, 3, 1, X, X, X, X, X, X, X},
+    {1, 2, 10, 8, 4, 7, X, X, X, X, X, X, X, X, X, X},
+    {3, 4, 7, 3, 0, 4, 1, 2, 10, X, X, X, X, X, X, X},
+    {9, 2, 10, 9, 0, 2, 8, 4, 7, X, X, X, X, X, X, X},
+    {2, 10, 9, 2, 9, 7, 2, 7, 3, 7, 9, 4, X, X, X, X},
+    {8, 4, 7, 3, 11, 2, X, X, X, X, X, X, X, X, X, X},
+    {11, 4, 7, 11, 2, 4, 2, 0, 4, X, X, X, X, X, X, X},
+    {9, 0, 1, 8, 4, 7, 2, 3, 11, X, X, X, X, X, X, X},
+    {4, 7, 11, 9, 4, 11, 9, 11, 2, 9, 2, 1, X, X, X, X},
+    {3, 10, 1, 3, 11, 10, 7, 8, 4, X, X, X, X, X, X, X},
+    {1, 11, 10, 1, 4, 11, 1, 0, 4, 7, 11, 4, X, X, X, X},
+    {4, 7, 8, 9, 0, 11, 9, 11, 10, 11, 0, 3, X, X, X, X},
+    {4, 7, 11, 4, 11, 9, 9, 11, 10, X, X, X, X, X, X, X},
+    {9, 5, 4, X, X, X, X, X, X, X, X, X, X, X, X, X},
+    {9, 5, 4, 0, 8, 3, X, X, X, X, X, X, X, X, X, X},
+    {0, 5, 4, 1, 5, 0, X, X, X, X, X, X, X, X, X, X},
+    {8, 5, 4, 8, 3, 5, 3, 1, 5, X, X, X, X, X, X, X},
+    {1, 2, 10, 9, 5, 4, X, X, X, X, X, X, X, X, X, X},
+    {3, 0, 8, 1, 2, 10, 4, 9, 5, X, X, X, X, X, X, X},
+    {5, 2, 10, 5, 4, 2, 4, 0, 2, X, X, X, X, X, X, X},
+    {2, 10, 5, 3, 2, 5, 3, 5, 4, 3, 4, 8, X, X, X, X},
+    {9, 5, 4, 2, 3, 11, X, X, X, X, X, X, X, X, X, X},
+    {0, 11, 2, 0, 8, 11, 4, 9, 5, X, X, X, X, X, X, X},
+    {0, 5, 4, 0, 1, 5, 2, 3, 11, X, X, X, X, X, X, X},
+    {2, 1, 5, 2, 5, 8, 2, 8, 11, 4, 8, 5, X, X, X, X},
+    {10, 3, 11, 10, 1, 3, 9, 5, 4, X, X, X, X, X, X, X},
+    {4, 9, 5, 0, 8, 1, 8, 10, 1, 8, 11, 10, X, X, X, X},
+    {5, 4, 0, 5, 0, 11, 5, 11, 10, 11, 0, 3, X, X, X, X},
+    {5, 4, 8, 5, 8, 10, 10, 8, 11, X, X, X, X, X, X, X},
+    {9, 7, 8, 5, 7, 9, X, X, X, X, X, X, X, X, X, X},
+    {9, 3, 0, 9, 5, 3, 5, 7, 3, X, X, X, X, X, X, X},
+    {0, 7, 8, 0, 1, 7, 1, 5, 7, X, X, X, X, X, X, X},
+    {1, 5, 3, 3, 5, 7, X, X, X, X, X, X, X, X, X, X},
+    {9, 7, 8, 9, 5, 7, 10, 1, 2, X, X, X, X, X, X, X},
+    {10, 1, 2, 9, 5, 0, 5, 3, 0, 5, 7, 3, X, X, X, X},
+    {8, 0, 2, 8, 2, 5, 8, 5, 7, 10, 5, 2, X, X, X, X},
+    {2, 10, 5, 2, 5, 3, 3, 5, 7, X, X, X, X, X, X, X},
+    {7, 9, 5, 7, 8, 9, 3, 11, 2, X, X, X, X, X, X, X},
+    {9, 5, 7, 9, 7, 2, 9, 2, 0, 2, 7, 11, X, X, X, X},
+    {2, 3, 11, 0, 1, 8, 1, 7, 8, 1, 5, 7, X, X, X, X},
+    {11, 2, 1, 11, 1, 7, 7, 1, 5, X, X, X, X, X, X, X},
+    {9, 5, 8, 8, 5, 7, 10, 1, 3, 10, 3, 11, X, X, X, X},
+    {5, 7, 0, 5, 0, 9, 7, 11, 0, 1, 0, 10, 11, 10, 0, X},
+    {11, 10, 0, 11, 0, 3, 10, 5, 0, 8, 0, 7, 5, 7, 0, X},
+    {11, 10, 5, 7, 11, 5, X, X, X, X, X, X, X, X, X, X},
+    {10, 6, 5, X, X, X, X, X, X, X, X, X, X, X, X, X},
+    {0, 8, 3, 5, 10, 6, X, X, X, X, X, X, X, X, X, X},
+    {9, 0, 1, 5, 10, 6, X, X, X, X, X, X, X, X, X, X},
+    {1, 8, 3, 1, 9, 8, 5, 10, 6, X, X, X, X, X, X, X},
+    {1, 6, 5, 2, 6, 1, X, X, X, X, X, X, X, X, X, X},
+    {1, 6, 5, 1, 2, 6, 3, 0, 8, X, X, X, X, X, X, X},
+    {9, 6, 5, 9, 0, 6, 0, 2, 6, X, X, X, X, X, X, X},
+    {5, 9, 8, 5, 8, 2, 5, 2, 6, 3, 2, 8, X, X, X, X},
+    {2, 3, 11, 10, 6, 5, X, X, X, X, X, X, X, X, X, X},
+    {11, 0, 8, 11, 2, 0, 10, 6, 5, X, X, X, X, X, X, X},
+    {0, 1, 9, 2, 3, 11, 5, 10, 6, X, X, X, X, X, X, X},
+    {5, 10, 6, 1, 9, 2, 9, 11, 2, 9, 8, 11, X, X, X, X},
+    {6, 3, 11, 6, 5, 3, 5, 1, 3, X, X, X, X, X, X, X},
+    {0, 8, 11, 0, 11, 5, 0, 5, 1, 5, 11, 6, X, X, X, X},
+    {3, 11, 6, 0, 3, 6, 0, 6, 5, 0, 5, 9, X, X, X, X},
+    {6, 5, 9, 6, 9, 11, 11, 9, 8, X, X, X, X, X, X, X},
+    {5, 10, 6, 4, 7, 8, X, X, X, X, X, X, X, X, X, X},
+    {4, 3, 0, 4, 7, 3, 6, 5, 10, X, X, X, X, X, X, X},
+    {1, 9, 0, 5, 10, 6, 8, 4, 7, X, X, X, X, X, X, X},
+    {10, 6, 5, 1, 9, 7, 1, 7, 3, 7, 9, 4, X, X, X, X},
+    {6, 1, 2, 6, 5, 1, 4, 7, 8, X, X, X, X, X, X, X},
+    {1, 2, 5, 5, 2, 6, 3, 0, 4, 3, 4, 7, X, X, X, X},
+    {8, 4, 7, 9, 0, 5, 0, 6, 5, 0, 2, 6, X, X, X, X},
+    {7, 3, 9, 7, 9, 4, 3, 2, 9, 5, 9, 6, 2, 6, 9, X},
+    {3, 11, 2, 7, 8, 4, 10, 6, 5, X, X, X, X, X, X, X},
+    {5, 10, 6, 4, 7, 2, 4, 2, 0, 2, 7, 11, X, X, X, X},
+    {0, 1, 9, 4, 7, 8, 2, 3, 11, 5, 10, 6, X, X, X, X},
+    {9, 2, 1, 9, 11, 2, 9, 4, 11, 7, 11, 4, 5, 10, 6, X},
+    {8, 4, 7, 3, 11, 5, 3, 5, 1, 5, 11, 6, X, X, X, X},
+    {5, 1, 11, 5, 11, 6, 1, 0, 11, 7, 11, 4, 0, 4, 11, X},
+    {0, 5, 9, 0, 6, 5, 0, 3, 6, 11, 6, 3, 8, 4, 7, X},
+    {6, 5, 9, 6, 9, 11, 4, 7, 9, 7, 11, 9, X, X, X, X},
+    {10, 4, 9, 6, 4, 10, X, X, X, X, X, X, X, X, X, X},
+    {4, 10, 6, 4, 9, 10, 0, 8, 3, X, X, X, X, X, X, X},
+    {10, 0, 1, 10, 6, 0, 6, 4, 0, X, X, X, X, X, X, X},
+    {8, 3, 1, 8, 1, 6, 8, 6, 4, 6, 1, 10, X, X, X, X},
+    {1, 4, 9, 1, 2, 4, 2, 6, 4, X, X, X, X, X, X, X},
+    {3, 0, 8, 1, 2, 9, 2, 4, 9, 2, 6, 4, X, X, X, X},
+    {0, 2, 4, 4, 2, 6, X, X, X, X, X, X, X, X, X, X},
+    {8, 3, 2, 8, 2, 4, 4, 2, 6, X, X, X, X, X, X, X},
+    {10, 4, 9, 10, 6, 4, 11, 2, 3, X, X, X, X, X, X, X},
+    {0, 8, 2, 2, 8, 11, 4, 9, 10, 4, 10, 6, X, X, X, X},
+    {3, 11, 2, 0, 1, 6, 0, 6, 4, 6, 1, 10, X, X, X, X},
+    {6, 4, 1, 6, 1, 10, 4, 8, 1, 2, 1, 11, 8, 11, 1, X},
+    {9, 6, 4, 9, 3, 6, 9, 1, 3, 11, 6, 3, X, X, X, X},
+    {8, 11, 1, 8, 1, 0, 11, 6, 1, 9, 1, 4, 6, 4, 1, X},
+    {3, 11, 6, 3, 6, 0, 0, 6, 4, X, X, X, X, X, X, X},
+    {6, 4, 8, 11, 6, 8, X, X, X, X, X, X, X, X, X, X},
+    {7, 10, 6, 7, 8, 10, 8, 9, 10, X, X, X, X, X, X, X},
+    {0, 7, 3, 0, 10, 7, 0, 9, 10, 6, 7, 10, X, X, X, X},
+    {10, 6, 7, 1, 10, 7, 1, 7, 8, 1, 8, 0, X, X, X, X},
+    {10, 6, 7, 10, 7, 1, 1, 7, 3, X, X, X, X, X, X, X},
+    {1, 2, 6, 1, 6, 8, 1, 8, 9, 8, 6, 7, X, X, X, X},
+    {2, 6, 9, 2, 9, 1, 6, 7, 9, 0, 9, 3, 7, 3, 9, X},
+    {7, 8, 0, 7, 0, 6, 6, 0, 2, X, X, X, X, X, X, X},
+    {7, 3, 2, 6, 7, 2, X, X, X, X, X, X, X, X, X, X},
+    {2, 3, 11, 10, 6, 8, 10, 8, 9, 8, 6, 7, X, X, X, X},
+    {2, 0, 7, 2, 7, 11, 0, 9, 7, 6, 7, 10, 9, 10, 7, X},
+    {1, 8, 0, 1, 7, 8, 1, 10, 7, 6, 7, 10, 2, 3, 11, X},
+    {11, 2, 1, 11, 1, 7, 10, 6, 1, 6, 7, 1, X, X, X, X},
+    {8, 9, 6, 8, 6, 7, 9, 1, 6, 11, 6, 3, 1, 3, 6, X},
+    {0, 9, 1, 11, 6, 7, X, X, X, X, X, X, X, X, X, X},
+    {7, 8, 0, 7, 0, 6, 3, 11, 0, 11, 6, 0, X, X, X, X},
+    {7, 11, 6, X, X, X, X, X, X, X, X, X, X, X, X, X},
+    {7, 6, 11, X, X, X, X, X, X, X, X, X, X, X, X, X},
+    {3, 0, 8, 11, 7, 6, X, X, X, X, X, X, X, X, X, X},
+    {0, 1, 9, 11, 7, 6, X, X, X, X, X, X, X, X, X, X},
+    {8, 1, 9, 8, 3, 1, 11, 7, 6, X, X, X, X, X, X, X},
+    {10, 1, 2, 6, 11, 7, X, X, X, X, X, X, X, X, X, X},
+    {1, 2, 10, 3, 0, 8, 6, 11, 7, X, X, X, X, X, X, X},
+    {2, 9, 0, 2, 10, 9, 6, 11, 7, X, X, X, X, X, X, X},
+    {6, 11, 7, 2, 10, 3, 10, 8, 3, 10, 9, 8, X, X, X, X},
+    {7, 2, 3, 6, 2, 7, X, X, X, X, X, X, X, X, X, X},
+    {7, 0, 8, 7, 6, 0, 6, 2, 0, X, X, X, X, X, X, X},
+    {2, 7, 6, 2, 3, 7, 0, 1, 9, X, X, X, X, X, X, X},
+    {1, 6, 2, 1, 8, 6, 1, 9, 8, 8, 7, 6, X, X, X, X},
+    {10, 7, 6, 10, 1, 7, 1, 3, 7, X, X, X, X, X, X, X},
+    {10, 7, 6, 1, 7, 10, 1, 8, 7, 1, 0, 8, X, X, X, X},
+    {0, 3, 7, 0, 7, 10, 0, 10, 9, 6, 10, 7, X, X, X, X},
+    {7, 6, 10, 7, 10, 8, 8, 10, 9, X, X, X, X, X, X, X},
+    {6, 8, 4, 11, 8, 6, X, X, X, X, X, X, X, X, X, X},
+    {3, 6, 11, 3, 0, 6, 0, 4, 6, X, X, X, X, X, X, X},
+    {8, 6, 11, 8, 4, 6, 9, 0, 1, X, X, X, X, X, X, X},
+    {9, 4, 6, 9, 6, 3, 9, 3, 1, 11, 3, 6, X, X, X, X},
+    {6, 8, 4, 6, 11, 8, 2, 10, 1, X, X, X, X, X, X, X},
+    {1, 2, 10, 3, 0, 11, 0, 6, 11, 0, 4, 6, X, X, X, X},
+    {4, 11, 8, 4, 6, 11, 0, 2, 9, 2, 10, 9, X, X, X, X},
+    {10, 9, 3, 10, 3, 2, 9, 4, 3, 11, 3, 6, 4, 6, 3, X},
+    {8, 2, 3, 8, 4, 2, 4, 6, 2, X, X, X, X, X, X, X},
+    {0, 4, 2, 4, 6, 2, X, X, X, X, X, X, X, X, X, X},
+    {1, 9, 0, 2, 3, 4, 2, 4, 6, 4, 3, 8, X, X, X, X},
+    {1, 9, 4, 1, 4, 2, 2, 4, 6, X, X, X, X, X, X, X},
+    {8, 1, 3, 8, 6, 1, 8, 4, 6, 6, 10, 1, X, X, X, X},
+    {10, 1, 0, 10, 0, 6, 6, 0, 4, X, X, X, X, X, X, X},
+    {4, 6, 3, 4, 3, 8, 6, 10, 3, 0, 3, 9, 10, 9, 3, X},
+    {10, 9, 4, 6, 10, 4, X, X, X, X, X, X, X, X, X, X},
+    {4, 9, 5, 7, 6, 11, X, X, X, X, X, X, X, X, X, X},
+    {0, 8, 3, 4, 9, 5, 11, 7, 6, X, X, X, X, X, X, X},
+    {5, 0, 1, 5, 4, 0, 7, 6, 11, X, X, X, X, X, X, X},
+    {11, 7, 6, 8, 3, 4, 3, 5, 4, 3, 1, 5, X, X, X, X},
+    {9, 5, 4, 10, 1, 2, 7, 6, 11, X, X, X, X, X, X, X},
+    {6, 11, 7, 1, 2, 10, 0, 8, 3, 4, 9, 5, X, X, X, X},
+    {7, 6, 11, 5, 4, 10, 4, 2, 10, 4, 0, 2, X, X, X, X},
+    {3, 4, 8, 3, 5, 4, 3, 2, 5, 10, 5, 2, 11, 7, 6, X},
+    {7, 2, 3, 7, 6, 2, 5, 4, 9, X, X, X, X, X, X, X},
+    {9, 5, 4, 0, 8, 6, 0, 6, 2, 6, 8, 7, X, X, X, X},
+    {3, 6, 2, 3, 7, 6, 1, 5, 0, 5, 4, 0, X, X, X, X},
+    {6, 2, 8, 6, 8, 7, 2, 1, 8, 4, 8, 5, 1, 5, 8, X},
+    {9, 5, 4, 10, 1, 6, 1, 7, 6, 1, 3, 7, X, X, X, X},
+    {1, 6, 10, 1, 7, 6, 1, 0, 7, 8, 7, 0, 9, 5, 4, X},
+    {4, 0, 10, 4, 10, 5, 0, 3, 10, 6, 10, 7, 3, 7, 10, X},
+    {7, 6, 10, 7, 10, 8, 5, 4, 10, 4, 8, 10, X, X, X, X},
+    {6, 9, 5, 6, 11, 9, 11, 8, 9, X, X, X, X, X, X, X},
+    {3, 6, 11, 0, 6, 3, 0, 5, 6, 0, 9, 5, X, X, X, X},
+    {0, 11, 8, 0, 5, 11, 0, 1, 5, 5, 6, 11, X, X, X, X},
+    {6, 11, 3, 6, 3, 5, 5, 3, 1, X, X, X, X, X, X, X},
+    {1, 2, 10, 9, 5, 11, 9, 11, 8, 11, 5, 6, X, X, X, X},
+    {0, 11, 3, 0, 6, 11, 0, 9, 6, 5, 6, 9, 1, 2, 10, X},
+    {11, 8, 5, 11, 5, 6, 8, 0, 5, 10, 5, 2, 0, 2, 5, X},
+    {6, 11, 3, 6, 3, 5, 2, 10, 3, 10, 5, 3, X, X, X, X},
+    {5, 8, 9, 5, 2, 8, 5, 6, 2, 3, 8, 2, X, X, X, X},
+    {9, 5, 6, 9, 6, 0, 0, 6, 2, X, X, X, X, X, X, X},
+    {1, 5, 8, 1, 8, 0, 5, 6, 8, 3, 8, 2, 6, 2, 8, X},
+    {1, 5, 6, 2, 1, 6, X, X, X, X, X, X, X, X, X, X},
+    {1, 3, 6, 1, 6, 10, 3, 8, 6, 5, 6, 9, 8, 9, 6, X},
+    {10, 1, 0, 10, 0, 6, 9, 5, 0, 5, 6, 0, X, X, X, X},
+    {0, 3, 8, 5, 6, 10, X, X, X, X, X, X, X, X, X, X},
+    {10, 5, 6, X, X, X, X, X, X, X, X, X, X, X, X, X},
+    {11, 5, 10, 7, 5, 11, X, X, X, X, X, X, X, X, X, X},
+    {11, 5, 10, 11, 7, 5, 8, 3, 0, X, X, X, X, X, X, X},
+    {5, 11, 7, 5, 10, 11, 1, 9, 0, X, X, X, X, X, X, X},
+    {10, 7, 5, 10, 11, 7, 9, 8, 1, 8, 3, 1, X, X, X, X},
+    {11, 1, 2, 11, 7, 1, 7, 5, 1, X, X, X, X, X, X, X},
+    {0, 8, 3, 1, 2, 7, 1, 7, 5, 7, 2, 11, X, X, X, X},
+    {9, 7, 5, 9, 2, 7, 9, 0, 2, 2, 11, 7, X, X, X, X},
+    {7, 5, 2, 7, 2, 11, 5, 9, 2, 3, 2, 8, 9, 8, 2, X},
+    {2, 5, 10, 2, 3, 5, 3, 7, 5, X, X, X, X, X, X, X},
+    {8, 2, 0, 8, 5, 2, 8, 7, 5, 10, 2, 5, X, X, X, X},
+    {9, 0, 1, 5, 10, 3, 5, 3, 7, 3, 10, 2, X, X, X, X},
+    {9, 8, 2, 9, 2, 1, 8, 7, 2, 10, 2, 5, 7, 5, 2, X},
+    {1, 3, 5, 3, 7, 5, X, X, X, X, X, X, X, X, X, X},
+    {0, 8, 7, 0, 7, 1, 1, 7, 5, X, X, X, X, X, X, X},
+    {9, 0, 3, 9, 3, 5, 5, 3, 7, X, X, X, X, X, X, X},
+    {9, 8, 7, 5, 9, 7, X, X, X, X, X, X, X, X, X, X},
+    {5, 8, 4, 5, 10, 8, 10, 11, 8, X, X, X, X, X, X, X},
+    {5, 0, 4, 5, 11, 0, 5, 10, 11, 11, 3, 0, X, X, X, X},
+    {0, 1, 9, 8, 4, 10, 8, 10, 11, 10, 4, 5, X, X, X, X},
+    {10, 11, 4, 10, 4, 5, 11, 3, 4, 9, 4, 1, 3, 1, 4, X},
+    {2, 5, 1, 2, 8, 5, 2, 11, 8, 4, 5, 8, X, X, X, X},
+    {0, 4, 11, 0, 11, 3, 4, 5, 11, 2, 11, 1, 5, 1, 11, X},
+    {0, 2, 5, 0, 5, 9, 2, 11, 5, 4, 5, 8, 11, 8, 5, X},
+    {9, 4, 5, 2, 11, 3, X, X, X, X, X, X, X, X, X, X},
+    {2, 5, 10, 3, 5, 2, 3, 4, 5, 3, 8, 4, X, X, X, X},
+    {5, 10, 2, 5, 2, 4, 4, 2, 0, X, X, X, X, X, X, X},
+    {3, 10, 2, 3, 5, 10, 3, 8, 5, 4, 5, 8, 0, 1, 9, X},
+    {5, 10, 2, 5, 2, 4, 1, 9, 2, 9, 4, 2, X, X, X, X},
+    {8, 4, 5, 8, 5, 3, 3, 5, 1, X, X, X, X, X, X, X},
+    {0, 4, 5, 1, 0, 5, X, X, X, X, X, X, X, X, X, X},
+    {8, 4, 5, 8, 5, 3, 9, 0, 5, 0, 3, 5, X, X, X, X},
+    {9, 4, 5, X, X, X, X, X, X, X, X, X, X, X, X, X},
+    {4, 11, 7, 4, 9, 11, 9, 10, 11, X, X, X, X, X, X, X},
+    {0, 8, 3, 4, 9, 7, 9, 11, 7, 9, 10, 11, X, X, X, X},
+    {1, 10, 11, 1, 11, 4, 1, 4, 0, 7, 4, 11, X, X, X, X},
+    {3, 1, 4, 3, 4, 8, 1, 10, 4, 7, 4, 11, 10, 11, 4, X},
+    {4, 11, 7, 9, 11, 4, 9, 2, 11, 9, 1, 2, X, X, X, X},
+    {9, 7, 4, 9, 11, 7, 9, 1, 11, 2, 11, 1, 0, 8, 3, X},
+    {11, 7, 4, 11, 4, 2, 2, 4, 0, X, X, X, X, X, X, X},
+    {11, 7, 4, 11, 4, 2, 8, 3, 4, 3, 2, 4, X, X, X, X},
+    {2, 9, 10, 2, 7, 9, 2, 3, 7, 7, 4, 9, X, X, X, X},
+    {9, 10, 7, 9, 7, 4, 10, 2, 7, 8, 7, 0, 2, 0, 7, X},
+    {3, 7, 10, 3, 10, 2, 7, 4, 10, 1, 10, 0, 4, 0, 10, X},
+    {1, 10, 2, 8, 7, 4, X, X, X, X, X, X, X, X, X, X},
+    {4, 9, 1, 4, 1, 7, 7, 1, 3, X, X, X, X, X, X, X},
+    {4, 9, 1, 4, 1, 7, 0, 8, 1, 8, 7, 1, X, X, X, X},
+    {4, 0, 3, 7, 4, 3, X, X, X, X, X, X, X, X, X, X},
+    {4, 8, 7, X, X, X, X, X, X, X, X, X, X, X, X, X},
+    {9, 10, 8, 10, 11, 8, X, X, X, X, X, X, X, X, X, X},
+    {3, 0, 9, 3, 9, 11, 11, 9, 10, X, X, X, X, X, X, X},
+    {0, 1, 10, 0, 10, 8, 8, 10, 11, X, X, X, X, X, X, X},
+    {3, 1, 10, 11, 3, 10, X, X, X, X, X, X, X, X, X, X},
+    {1, 2, 11, 1, 11, 9, 9, 11, 8, X, X, X, X, X, X, X},
+    {3, 0, 9, 3, 9, 11, 1, 2, 9, 2, 11, 9, X, X, X, X},
+    {0, 2, 11, 8, 0, 11, X, X, X, X, X, X, X, X, X, X},
+    {3, 2, 11, X, X, X, X, X, X, X, X, X, X, X, X, X},
+    {2, 3, 8, 2, 8, 10, 10, 8, 9, X, X, X, X, X, X, X},
+    {9, 10, 2, 0, 9, 2, X, X, X, X, X, X, X, X, X, X},
+    {2, 3, 8, 2, 8, 10, 0, 1, 8, 1, 10, 8, X, X, X, X},
+    {1, 10, 2, X, X, X, X, X, X, X, X, X, X, X, X, X},
+    {1, 3, 8, 9, 1, 8, X, X, X, X, X, X, X, X, X, X},
+    {0, 9, 1, X, X, X, X, X, X, X, X, X, X, X, X, X},
+    {0, 3, 8, X, X, X, X, X, X, X, X, X, X, X, X, X},
+    {X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X}};
+#undef X
+
+// Table mapping each edge to the corresponding cube vertices offsets
+const uint _EDGE_TO_VERTICES[12][2] = {
+    {0, 1},
+    {1, 5},
+    {4, 5},
+    {0, 4},
+    {2, 3},
+    {3, 7},
+    {6, 7},
+    {2, 6},
+    {0, 2},
+    {1, 3},
+    {5, 7},
+    {4, 6},
+};
+
+// Table mapping from 0-7 to v0-v7 in cube.vertices
+const int _INDEX_TABLE[8] = {0, 1, 5, 4, 2, 3, 7, 6};

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/mesh_normal_consistency/mesh_normal_consistency.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+#include <torch/extension.h>
+#include "utils/pytorch3d_cutils.h"
+
+// For mesh_normal_consistency, find pairs of vertices opposite the same edge.
+//
+// Args:
+//   edge_num: int64 Tensor of shape (E,) giving the number of vertices
+//              corresponding to each edge.
+//
+// Returns:
+//    pairs: int64 Tensor of shape (N,2)
+
+at::Tensor MeshNormalConsistencyFindVerticesCpu(const at::Tensor& edge_num);
+
+// Exposed implementation.
+at::Tensor MeshNormalConsistencyFindVertices(const at::Tensor& edge_num) {
+  if (edge_num.is_cuda()) {
+    AT_ERROR("This function needs a CPU tensor.");
+  }
+  return MeshNormalConsistencyFindVerticesCpu(edge_num);
+}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/mesh_normal_consistency/mesh_normal_consistency_cpu.cpp

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <ATen/ATen.h>
+#include <utility>
+#include <vector>
+
+at::Tensor MeshNormalConsistencyFindVerticesCpu(const at::Tensor& edge_num) {
+  // We take a LongTensor of shape (E,) giving the number of things intersecting
+  // each edge. The things are taken to be numbered in order.
+  // (In fact, the "things" are opposite vertices to edges, renumbered).
+  // We return a tensor of shape (?, 2) where for every pair of things which
+  // intersect the same edge there is a row of their numbers in the output.
+
+  // Example possible inputs and outputs (order of output is not specified):
+  //  [1,0,1,1,0] => [[]]
+  //          [3] => [[0,1], [0,2], [1,2]]
+  //        [0,3] => [[0,1], [0,2], [1,2]]
+  //        [1,3] => [[1,2], [1,3], [2,3]]
+  //[1,0,2,1,0,2] => [[1,2], [4,5]]
+
+  const auto num_edges = edge_num.size(0);
+  auto edges_a = edge_num.accessor<int64_t, 1>();
+
+  int64_t vert_idx = 0;
+  std::vector<std::pair<int64_t, int64_t>> pairs;
+  for (int64_t i_edge = 0; i_edge < num_edges; ++i_edge) {
+    int64_t e = edges_a[i_edge];
+    for (int64_t j = 0; j < e; ++j) {
+      for (int64_t i = 0; i < j; ++i) {
+        pairs.emplace_back(vert_idx + i, vert_idx + j);
+      }
+    }
+    vert_idx += e;
+  }
+
+  // Convert from std::vector by copying over the items to a new empty torch
+  // tensor.
+  auto pairs_tensor = at::empty({(int64_t)pairs.size(), 2}, edge_num.options());
+  auto pairs_a = pairs_tensor.accessor<int64_t, 2>();
+  for (int64_t i_pair = 0; i_pair < pairs.size(); ++i_pair) {
+    auto accessor = pairs_a[i_pair];
+    accessor[0] = pairs[i_pair].first;
+    accessor[1] = pairs[i_pair].second;
+  }
+
+  return pairs_tensor;
+}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/packed_to_padded_tensor/packed_to_padded_tensor.cu

@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <ATen/ATen.h>
+#include <ATen/cuda/CUDAContext.h>
+#include <c10/cuda/CUDAGuard.h>
+
+// Kernel for inputs_packed of shape (F, D), where D > 1
+template <typename scalar_t>
+__global__ void PackedToPaddedKernel(
+    const scalar_t* __restrict__ inputs_packed,
+    const int64_t* __restrict__ first_idxs,
+    scalar_t* __restrict__ inputs_padded,
+    const size_t batch_size,
+    const size_t max_size,
+    const size_t num_inputs,
+    const size_t D) {
+  // Batch elements split evenly across blocks (num blocks = batch_size) and
+  // values for each element split across threads in the block. Each thread adds
+  // the values of its respective input elements to the global inputs_padded
+  // tensor.
+  const size_t tid = threadIdx.x;
+  const size_t batch_idx = blockIdx.x;
+
+  const int64_t start = first_idxs[batch_idx];
+  const int64_t end =
+      batch_idx + 1 < batch_size ? first_idxs[batch_idx + 1] : num_inputs;
+  const int num = end - start;
+  for (size_t f = tid; f < num; f += blockDim.x) {
+    for (size_t j = 0; j < D; ++j) {
+      inputs_padded[batch_idx * max_size * D + f * D + j] =
+          inputs_packed[(start + f) * D + j];
+    }
+  }
+}
+
+// Kernel for inputs of shape (F, 1)
+template <typename scalar_t>
+__global__ void PackedToPaddedKernelD1(
+    const scalar_t* __restrict__ inputs_packed,
+    const int64_t* __restrict__ first_idxs,
+    scalar_t* __restrict__ inputs_padded,
+    const size_t batch_size,
+    const size_t max_size,
+    const size_t num_inputs) {
+  // Batch elements split evenly across blocks (num blocks = batch_size) and
+  // values for each element split across threads in the block. Each thread adds
+  // the values of its respective input elements to the global inputs_padded
+  // tensor.
+  const size_t tid = threadIdx.x;
+  const size_t batch_idx = blockIdx.x;
+
+  const int64_t start = first_idxs[batch_idx];
+  const int64_t end =
+      batch_idx + 1 < batch_size ? first_idxs[batch_idx + 1] : num_inputs;
+  const int num = end - start;
+  for (size_t f = tid; f < num; f += blockDim.x) {
+    inputs_padded[batch_idx * max_size + f] = inputs_packed[start + f];
+  }
+}
+
+// Kernel for inputs_padded of shape (B, F, D), where D > 1
+template <typename scalar_t>
+__global__ void PaddedToPackedKernel(
+    const scalar_t* __restrict__ inputs_padded,
+    const int64_t* __restrict__ first_idxs,
+    scalar_t* __restrict__ inputs_packed,
+    const size_t batch_size,
+    const size_t max_size,
+    const size_t num_inputs,
+    const size_t D) {
+  // Batch elements split evenly across blocks (num blocks = batch_size) and
+  // values for each element split across threads in the block. Each thread adds
+  // the values of its respective input elements to the global inputs_packed
+  // tensor.
+  const size_t tid = threadIdx.x;
+  const size_t batch_idx = blockIdx.x;
+
+  const int64_t start = first_idxs[batch_idx];
+  const int64_t end =
+      batch_idx + 1 < batch_size ? first_idxs[batch_idx + 1] : num_inputs;
+  const int num = end - start;
+  for (size_t f = tid; f < num; f += blockDim.x) {
+    for (size_t j = 0; j < D; ++j) {
+      inputs_packed[(start + f) * D + j] =
+          inputs_padded[batch_idx * max_size * D + f * D + j];
+    }
+  }
+}
+
+// Kernel for inputs_padded of shape (B, F, 1)
+template <typename scalar_t>
+__global__ void PaddedToPackedKernelD1(
+    const scalar_t* __restrict__ inputs_padded,
+    const int64_t* __restrict__ first_idxs,
+    scalar_t* __restrict__ inputs_packed,
+    const size_t batch_size,
+    const size_t max_size,
+    const size_t num_inputs) {
+  // Batch elements split evenly across blocks (num blocks = batch_size) and
+  // values for each element split across threads in the block. Each thread adds
+  // the values of its respective input elements to the global inputs_packed
+  // tensor.
+  const size_t tid = threadIdx.x;
+  const size_t batch_idx = blockIdx.x;
+
+  const int64_t start = first_idxs[batch_idx];
+  const int64_t end =
+      batch_idx + 1 < batch_size ? first_idxs[batch_idx + 1] : num_inputs;
+  const int num = end - start;
+  for (size_t f = tid; f < num; f += blockDim.x) {
+    inputs_packed[start + f] = inputs_padded[batch_idx * max_size + f];
+  }
+}
+
+at::Tensor PackedToPaddedCuda(
+    const at::Tensor inputs_packed,
+    const at::Tensor first_idxs,
+    const int64_t max_size) {
+  // Check inputs are on the same device
+  at::TensorArg inputs_packed_t{inputs_packed, "inputs_packed", 1},
+      first_idxs_t{first_idxs, "first_idxs", 2};
+  at::CheckedFrom c = "PackedToPaddedCuda";
+  at::checkAllSameGPU(c, {inputs_packed_t, first_idxs_t});
+
+  // Set the device for the kernel launch based on the device of the input
+  at::cuda::CUDAGuard device_guard(inputs_packed.device());
+  cudaStream_t stream = at::cuda::getCurrentCUDAStream();
+
+  const int64_t num_inputs = inputs_packed.size(0);
+  const int64_t batch_size = first_idxs.size(0);
+
+  TORCH_CHECK(
+      inputs_packed.dim() == 2, "inputs_packed must be a 2-dimensional tensor");
+  const int64_t D = inputs_packed.size(1);
+  at::Tensor inputs_padded =
+      at::zeros({batch_size, max_size, D}, inputs_packed.options());
+
+  if (inputs_padded.numel() == 0) {
+    AT_CUDA_CHECK(cudaGetLastError());
+    return inputs_padded;
+  }
+
+  const int threads = 512;
+  const int blocks = batch_size;
+  if (D == 1) {
+    AT_DISPATCH_FLOATING_TYPES(
+        inputs_packed.scalar_type(), "packed_to_padded_d1_kernel", ([&] {
+          PackedToPaddedKernelD1<scalar_t><<<blocks, threads, 0, stream>>>(
+              inputs_packed.contiguous().data_ptr<scalar_t>(),
+              first_idxs.contiguous().data_ptr<int64_t>(),
+              inputs_padded.data_ptr<scalar_t>(),
+              batch_size,
+              max_size,
+              num_inputs);
+        }));
+  } else {
+    AT_DISPATCH_FLOATING_TYPES(
+        inputs_packed.scalar_type(), "packed_to_padded_kernel", ([&] {
+          PackedToPaddedKernel<scalar_t><<<blocks, threads, 0, stream>>>(
+              inputs_packed.contiguous().data_ptr<scalar_t>(),
+              first_idxs.contiguous().data_ptr<int64_t>(),
+              inputs_padded.data_ptr<scalar_t>(),
+              batch_size,
+              max_size,
+              num_inputs,
+              D);
+        }));
+  }
+
+  AT_CUDA_CHECK(cudaGetLastError());
+  return inputs_padded;
+}
+
+at::Tensor PaddedToPackedCuda(
+    const at::Tensor inputs_padded,
+    const at::Tensor first_idxs,
+    const int64_t num_inputs) {
+  // Check inputs are on the same device
+  at::TensorArg inputs_padded_t{inputs_padded, "inputs_padded", 1},
+      first_idxs_t{first_idxs, "first_idxs", 2};
+  at::CheckedFrom c = "PaddedToPackedCuda";
+  at::checkAllSameGPU(c, {inputs_padded_t, first_idxs_t});
+
+  // Set the device for the kernel launch based on the device of the input
+  at::cuda::CUDAGuard device_guard(inputs_padded.device());
+  cudaStream_t stream = at::cuda::getCurrentCUDAStream();
+
+  const int64_t batch_size = inputs_padded.size(0);
+  const int64_t max_size = inputs_padded.size(1);
+
+  TORCH_CHECK(batch_size == first_idxs.size(0), "sizes mismatch");
+  TORCH_CHECK(
+      inputs_padded.dim() == 3,
+      "inputs_padded  must be a 3-dimensional tensor");
+  const int64_t D = inputs_padded.size(2);
+
+  at::Tensor inputs_packed =
+      at::zeros({num_inputs, D}, inputs_padded.options());
+
+  if (inputs_packed.numel() == 0) {
+    AT_CUDA_CHECK(cudaGetLastError());
+    return inputs_packed;
+  }
+
+  const int threads = 512;
+  const int blocks = batch_size;
+
+  if (D == 1) {
+    AT_DISPATCH_FLOATING_TYPES(
+        inputs_padded.scalar_type(), "padded_to_packed_d1_kernel", ([&] {
+          PaddedToPackedKernelD1<scalar_t><<<blocks, threads, 0, stream>>>(
+              inputs_padded.contiguous().data_ptr<scalar_t>(),
+              first_idxs.contiguous().data_ptr<int64_t>(),
+              inputs_packed.data_ptr<scalar_t>(),
+              batch_size,
+              max_size,
+              num_inputs);
+        }));
+  } else {
+    AT_DISPATCH_FLOATING_TYPES(
+        inputs_padded.scalar_type(), "padded_to_packed_kernel", ([&] {
+          PaddedToPackedKernel<scalar_t><<<blocks, threads, 0, stream>>>(
+              inputs_padded.contiguous().data_ptr<scalar_t>(),
+              first_idxs.contiguous().data_ptr<int64_t>(),
+              inputs_packed.data_ptr<scalar_t>(),
+              batch_size,
+              max_size,
+              num_inputs,
+              D);
+        }));
+  }
+
+  AT_CUDA_CHECK(cudaGetLastError());
+  return inputs_packed;
+}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/packed_to_padded_tensor/packed_to_padded_tensor_cpu.cpp

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <torch/extension.h>
+
+at::Tensor PackedToPaddedCpu(
+    const at::Tensor inputs_packed,
+    const at::Tensor first_idxs,
+    const int64_t max_size) {
+  const int64_t num_inputs = inputs_packed.size(0);
+  const int64_t batch_size = first_idxs.size(0);
+
+  AT_ASSERTM(
+      inputs_packed.dim() == 2, "inputs_packed must be a 2-dimensional tensor");
+  const int64_t D = inputs_packed.size(1);
+
+  torch::Tensor inputs_padded =
+      torch::zeros({batch_size, max_size, D}, inputs_packed.options());
+
+  auto inputs_packed_a = inputs_packed.accessor<float, 2>();
+  auto first_idxs_a = first_idxs.accessor<int64_t, 1>();
+  auto inputs_padded_a = inputs_padded.accessor<float, 3>();
+
+  for (int b = 0; b < batch_size; ++b) {
+    const int64_t start = first_idxs_a[b];
+    const int64_t end = b + 1 < batch_size ? first_idxs_a[b + 1] : num_inputs;
+    const int64_t num = end - start;
+    for (int i = 0; i < num; ++i) {
+      for (int j = 0; j < D; ++j) {
+        inputs_padded_a[b][i][j] = inputs_packed_a[start + i][j];
+      }
+    }
+  }
+  return inputs_padded;
+}
+
+at::Tensor PaddedToPackedCpu(
+    const at::Tensor inputs_padded,
+    const at::Tensor first_idxs,
+    const int64_t num_inputs) {
+  const int64_t batch_size = inputs_padded.size(0);
+
+  AT_ASSERTM(
+      inputs_padded.dim() == 3, "inputs_padded must be a 3-dimensional tensor");
+  const int64_t D = inputs_padded.size(2);
+
+  torch::Tensor inputs_packed =
+      torch::zeros({num_inputs, D}, inputs_padded.options());
+
+  auto inputs_padded_a = inputs_padded.accessor<float, 3>();
+  auto first_idxs_a = first_idxs.accessor<int64_t, 1>();
+  auto inputs_packed_a = inputs_packed.accessor<float, 2>();
+
+  for (int b = 0; b < batch_size; ++b) {
+    const int64_t start = first_idxs_a[b];
+    const int64_t end = b + 1 < batch_size ? first_idxs_a[b + 1] : num_inputs;
+    const int64_t num = end - start;
+    for (int i = 0; i < num; ++i) {
+      for (int j = 0; j < D; ++j) {
+        inputs_packed_a[start + i][j] = inputs_padded_a[b][i][j];
+      }
+    }
+  }
+  return inputs_packed;
+}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/pulsar/constants.h

@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#ifndef PULSAR_NATIVE_CONSTANTS_H_
+#define PULSAR_NATIVE_CONSTANTS_H_
+
+#define EPS 1E-6
+#define FEPS 1E-6f
+#define MAX_FLOAT 3.4E38f
+#define MAX_INT 2147483647
+#define MAX_UINT 4294967295u
+#define MAX_USHORT 65535u
+
+#endif

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/pulsar/cuda/README.md

@@ -0,0 +1,5 @@
+# CUDA device compilation units
+
+This folder contains `.cu` files to create compilation units
+for device-specific functions. See `../include/README.md` for
+more information.

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/pulsar/cuda/commands.h

@@ -0,0 +1,505 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#ifndef PULSAR_NATIVE_CUDA_COMMANDS_H_
+#define PULSAR_NATIVE_CUDA_COMMANDS_H_
+
+// Definitions for GPU commands.
+#include <cooperative_groups.h>
+#include <cub/cub.cuh>
+namespace cg = cooperative_groups;
+
+#ifdef __DRIVER_TYPES_H__
+#ifndef DEVICE_RESET
+#define DEVICE_RESET cudaDeviceReset();
+#endif
+#else
+#ifndef DEVICE_RESET
+#define DEVICE_RESET
+#endif
+#endif
+
+#define HANDLECUDA(CMD) CMD
+// handleCudaError((CMD), __FILE__, __LINE__)
+inline void
+handleCudaError(const cudaError_t err, const char* file, const int line) {
+  if (err != cudaSuccess) {
+#ifndef __NVCC__
+    fprintf(
+        stderr,
+        "%s(%i) : getLastCudaError() CUDA error :"
+        " (%d) %s.\n",
+        file,
+        line,
+        static_cast<int>(err),
+        cudaGetErrorString(err));
+    DEVICE_RESET
+    exit(1);
+#endif
+  }
+}
+inline void
+getLastCudaError(const char* errorMessage, const char* file, const int line) {
+  cudaError_t err = cudaGetLastError();
+  if (cudaSuccess != err) {
+    fprintf(stderr, "Error: %s.", errorMessage);
+    handleCudaError(err, file, line);
+  }
+}
+
+#define ALIGN(VAL) __align__(VAL)
+#define SYNC() HANDLECUDE(cudaDeviceSynchronize())
+#define THREADFENCE_B() __threadfence_block()
+#define SHFL_SYNC(a, b, c) __shfl_sync((a), (b), (c))
+#define SHARED __shared__
+#define ACTIVEMASK() __activemask()
+#define BALLOT(mask, val) __ballot_sync((mask), val)
+/**
+ * Find the cumulative sum within a warp up to the current
+ * thread lane, with each mask thread contributing base.
+ */
+template <typename T>
+DEVICE T
+WARP_CUMSUM(const cg::coalesced_group& group, const uint& mask, const T& base) {
+  T ret = base;
+  T shfl_val;
+  shfl_val = __shfl_down_sync(mask, ret, 1u); // Deactivate the rightmost lane.
+  ret += (group.thread_rank() < 31) * shfl_val;
+  shfl_val = __shfl_down_sync(mask, ret, 2u);
+  ret += (group.thread_rank() < 30) * shfl_val;
+  shfl_val = __shfl_down_sync(mask, ret, 4u); // ...4
+  ret += (group.thread_rank() < 28) * shfl_val;
+  shfl_val = __shfl_down_sync(mask, ret, 8u); // ...8
+  ret += (group.thread_rank() < 24) * shfl_val;
+  shfl_val = __shfl_down_sync(mask, ret, 16u); // ...16
+  ret += (group.thread_rank() < 16) * shfl_val;
+  return ret;
+}
+
+template <typename T>
+DEVICE T
+WARP_MAX(const cg::coalesced_group& group, const uint& mask, const T& base) {
+  T ret = base;
+  ret = max(ret, __shfl_down_sync(mask, ret, 16u));
+  ret = max(ret, __shfl_down_sync(mask, ret, 8u));
+  ret = max(ret, __shfl_down_sync(mask, ret, 4u));
+  ret = max(ret, __shfl_down_sync(mask, ret, 2u));
+  ret = max(ret, __shfl_down_sync(mask, ret, 1u));
+  return ret;
+}
+
+template <typename T>
+DEVICE T
+WARP_SUM(const cg::coalesced_group& group, const uint& mask, const T& base) {
+  T ret = base;
+  ret = ret + __shfl_down_sync(mask, ret, 16u);
+  ret = ret + __shfl_down_sync(mask, ret, 8u);
+  ret = ret + __shfl_down_sync(mask, ret, 4u);
+  ret = ret + __shfl_down_sync(mask, ret, 2u);
+  ret = ret + __shfl_down_sync(mask, ret, 1u);
+  return ret;
+}
+
+INLINE DEVICE float3 WARP_SUM_FLOAT3(
+    const cg::coalesced_group& group,
+    const uint& mask,
+    const float3& base) {
+  float3 ret = base;
+  ret.x = WARP_SUM(group, mask, base.x);
+  ret.y = WARP_SUM(group, mask, base.y);
+  ret.z = WARP_SUM(group, mask, base.z);
+  return ret;
+}
+
+// Floating point.
+// #define FMUL(a, b) __fmul_rn((a), (b))
+#define FMUL(a, b) ((a) * (b))
+#define FDIV(a, b) __fdiv_rn((a), (b))
+// #define FSUB(a, b) __fsub_rn((a), (b))
+#define FSUB(a, b) ((a) - (b))
+#define FADD(a, b) __fadd_rn((a), (b))
+#define FSQRT(a) __fsqrt_rn(a)
+#define FEXP(a) fasterexp(a)
+#define FLN(a) fasterlog(a)
+#define FPOW(a, b) __powf((a), (b))
+#define FMAX(a, b) fmax((a), (b))
+#define FMIN(a, b) fmin((a), (b))
+#define FCEIL(a) ceilf(a)
+#define FFLOOR(a) floorf(a)
+#define FROUND(x) nearbyintf(x)
+#define FSATURATE(x) __saturatef(x)
+#define FABS(a) abs(a)
+#define IASF(a, loc) (loc) = __int_as_float(a)
+#define FASI(a, loc) (loc) = __float_as_int(a)
+#define FABSLEQAS(a, b, c) \
+  ((a) <= (b) ? FSUB((b), (a)) <= (c) : FSUB((a), (b)) < (c))
+/** Calculates x*y+z. */
+#define FMA(x, y, z) __fmaf_rn((x), (y), (z))
+#define I2F(a) __int2float_rn(a)
+#define FRCP(x) __frcp_rn(x)
+__device__ static float atomicMax(float* address, float val) {
+  int* address_as_i = (int*)address;
+  int old = *address_as_i, assumed;
+  do {
+    assumed = old;
+    old = ::atomicCAS(
+        address_as_i,
+        assumed,
+        __float_as_int(::fmaxf(val, __int_as_float(assumed))));
+  } while (assumed != old);
+  return __int_as_float(old);
+}
+__device__ static float atomicMin(float* address, float val) {
+  int* address_as_i = (int*)address;
+  int old = *address_as_i, assumed;
+  do {
+    assumed = old;
+    old = ::atomicCAS(
+        address_as_i,
+        assumed,
+        __float_as_int(::fminf(val, __int_as_float(assumed))));
+  } while (assumed != old);
+  return __int_as_float(old);
+}
+#define DMAX(a, b) FMAX(a, b)
+#define DMIN(a, b) FMIN(a, b)
+#define DSQRT(a) sqrt(a)
+#define DSATURATE(a) DMIN(1., DMAX(0., (a)))
+// half
+#define HADD(a, b) __hadd((a), (b))
+#define HSUB2(a, b) __hsub2((a), (b))
+#define HMUL2(a, b) __hmul2((a), (b))
+#define HSQRT(a) hsqrt(a)
+
+// uint.
+#define CLZ(VAL) __clz(VAL)
+#define POPC(a) __popc(a)
+//
+//
+//
+//
+//
+//
+//
+//
+//
+#define ATOMICADD(PTR, VAL) atomicAdd((PTR), (VAL))
+#define ATOMICADD_F3(PTR, VAL)   \
+  ATOMICADD(&((PTR)->x), VAL.x); \
+  ATOMICADD(&((PTR)->y), VAL.y); \
+  ATOMICADD(&((PTR)->z), VAL.z);
+#if (CUDART_VERSION >= 10000) && (__CUDA_ARCH__ >= 600)
+#define ATOMICADD_B(PTR, VAL) atomicAdd_block((PTR), (VAL))
+#else
+#define ATOMICADD_B(PTR, VAL) ATOMICADD(PTR, VAL)
+#endif
+//
+//
+//
+//
+// int.
+#define IMIN(a, b) min((a), (b))
+#define IMAX(a, b) max((a), (b))
+#define IABS(a) abs(a)
+
+// Checks.
+// like TORCH_CHECK_ARG in PyTorch > 1.10
+#define ARGCHECK(cond, argN, ...) \
+  TORCH_CHECK(cond, "invalid argument ", argN, ": ", __VA_ARGS__)
+
+// Math.
+#define NORM3DF(x, y, z) norm3df(x, y, z)
+#define RNORM3DF(x, y, z) rnorm3df(x, y, z)
+
+// High level.
+#define GET_SORT_WS_SIZE(RES_PTR, KEY_TYPE, VAL_TYPE, NUM_OBJECTS) \
+  cub::DeviceRadixSort::SortPairsDescending(                       \
+      (void*)NULL,                                                 \
+      *(RES_PTR),                                                  \
+      reinterpret_cast<KEY_TYPE*>(NULL),                           \
+      reinterpret_cast<KEY_TYPE*>(NULL),                           \
+      reinterpret_cast<VAL_TYPE*>(NULL),                           \
+      reinterpret_cast<VAL_TYPE*>(NULL),                           \
+      (NUM_OBJECTS));
+#define GET_REDUCE_WS_SIZE(RES_PTR, TYPE, REDUCE_OP, NUM_OBJECTS) \
+  {                                                               \
+    TYPE init = TYPE();                                           \
+    cub::DeviceReduce::Reduce(                                    \
+        (void*)NULL,                                              \
+        *(RES_PTR),                                               \
+        (TYPE*)NULL,                                              \
+        (TYPE*)NULL,                                              \
+        (NUM_OBJECTS),                                            \
+        (REDUCE_OP),                                              \
+        init);                                                    \
+  }
+#define GET_SELECT_WS_SIZE(                              \
+    RES_PTR, TYPE_SELECTOR, TYPE_SELECTION, NUM_OBJECTS) \
+  {                                                      \
+    cub::DeviceSelect::Flagged(                          \
+        (void*)NULL,                                     \
+        *(RES_PTR),                                      \
+        (TYPE_SELECTION*)NULL,                           \
+        (TYPE_SELECTOR*)NULL,                            \
+        (TYPE_SELECTION*)NULL,                           \
+        (int*)NULL,                                      \
+        (NUM_OBJECTS));                                  \
+  }
+#define GET_SUM_WS_SIZE(RES_PTR, TYPE_SUM, NUM_OBJECTS) \
+  {                                                     \
+    cub::DeviceReduce::Sum(                             \
+        (void*)NULL,                                    \
+        *(RES_PTR),                                     \
+        (TYPE_SUM*)NULL,                                \
+        (TYPE_SUM*)NULL,                                \
+        NUM_OBJECTS);                                   \
+  }
+#define GET_MM_WS_SIZE(RES_PTR, TYPE, NUM_OBJECTS)                         \
+  {                                                                        \
+    TYPE init = TYPE();                                                    \
+    cub::DeviceReduce::Max(                                                \
+        (void*)NULL, *(RES_PTR), (TYPE*)NULL, (TYPE*)NULL, (NUM_OBJECTS)); \
+  }
+#define SORT_DESCENDING(                                               \
+    TMPN1, SORT_PTR, SORTED_PTR, VAL_PTR, VAL_SORTED_PTR, NUM_OBJECTS) \
+  void* TMPN1 = NULL;                                                  \
+  size_t TMPN1##_bytes = 0;                                            \
+  cub::DeviceRadixSort::SortPairsDescending(                           \
+      TMPN1,                                                           \
+      TMPN1##_bytes,                                                   \
+      (SORT_PTR),                                                      \
+      (SORTED_PTR),                                                    \
+      (VAL_PTR),                                                       \
+      (VAL_SORTED_PTR),                                                \
+      (NUM_OBJECTS));                                                  \
+  HANDLECUDA(cudaMalloc(&TMPN1, TMPN1##_bytes));                       \
+  cub::DeviceRadixSort::SortPairsDescending(                           \
+      TMPN1,                                                           \
+      TMPN1##_bytes,                                                   \
+      (SORT_PTR),                                                      \
+      (SORTED_PTR),                                                    \
+      (VAL_PTR),                                                       \
+      (VAL_SORTED_PTR),                                                \
+      (NUM_OBJECTS));                                                  \
+  HANDLECUDA(cudaFree(TMPN1));
+#define SORT_DESCENDING_WS(                  \
+    TMPN1,                                   \
+    SORT_PTR,                                \
+    SORTED_PTR,                              \
+    VAL_PTR,                                 \
+    VAL_SORTED_PTR,                          \
+    NUM_OBJECTS,                             \
+    WORKSPACE_PTR,                           \
+    WORKSPACE_BYTES)                         \
+  cub::DeviceRadixSort::SortPairsDescending( \
+      (WORKSPACE_PTR),                       \
+      (WORKSPACE_BYTES),                     \
+      (SORT_PTR),                            \
+      (SORTED_PTR),                          \
+      (VAL_PTR),                             \
+      (VAL_SORTED_PTR),                      \
+      (NUM_OBJECTS));
+#define SORT_ASCENDING_WS(         \
+    SORT_PTR,                      \
+    SORTED_PTR,                    \
+    VAL_PTR,                       \
+    VAL_SORTED_PTR,                \
+    NUM_OBJECTS,                   \
+    WORKSPACE_PTR,                 \
+    WORKSPACE_BYTES,               \
+    STREAM)                        \
+  cub::DeviceRadixSort::SortPairs( \
+      (WORKSPACE_PTR),             \
+      (WORKSPACE_BYTES),           \
+      (SORT_PTR),                  \
+      (SORTED_PTR),                \
+      (VAL_PTR),                   \
+      (VAL_SORTED_PTR),            \
+      (NUM_OBJECTS),               \
+      0,                           \
+      sizeof(*(SORT_PTR)) * 8,     \
+      (STREAM));
+#define SUM_WS(                                                            \
+    SUM_PTR, OUT_PTR, NUM_OBJECTS, WORKSPACE_PTR, WORKSPACE_BYTES, STREAM) \
+  cub::DeviceReduce::Sum(                                                  \
+      (WORKSPACE_PTR),                                                     \
+      (WORKSPACE_BYTES),                                                   \
+      (SUM_PTR),                                                           \
+      (OUT_PTR),                                                           \
+      (NUM_OBJECTS),                                                       \
+      (STREAM));
+#define MIN_WS(                                                            \
+    MIN_PTR, OUT_PTR, NUM_OBJECTS, WORKSPACE_PTR, WORKSPACE_BYTES, STREAM) \
+  cub::DeviceReduce::Min(                                                  \
+      (WORKSPACE_PTR),                                                     \
+      (WORKSPACE_BYTES),                                                   \
+      (MIN_PTR),                                                           \
+      (OUT_PTR),                                                           \
+      (NUM_OBJECTS),                                                       \
+      (STREAM));
+#define MAX_WS(                                                            \
+    MAX_PTR, OUT_PTR, NUM_OBJECTS, WORKSPACE_PTR, WORKSPACE_BYTES, STREAM) \
+  cub::DeviceReduce::Min(                                                  \
+      (WORKSPACE_PTR),                                                     \
+      (WORKSPACE_BYTES),                                                   \
+      (MAX_PTR),                                                           \
+      (OUT_PTR),                                                           \
+      (NUM_OBJECTS),                                                       \
+      (STREAM));
+//
+//
+//
+// TODO: rewrite using nested contexts instead of temporary names.
+#define REDUCE(REDUCE_PTR, RESULT_PTR, NUM_ITEMS, REDUCE_OP, REDUCE_INIT) \
+  cub::DeviceReduce::Reduce(                                              \
+      TMPN1,                                                              \
+      TMPN1##_bytes,                                                      \
+      (REDUCE_PTR),                                                       \
+      (RESULT_PTR),                                                       \
+      (NUM_ITEMS),                                                        \
+      (REDUCE_OP),                                                        \
+      (REDUCE_INIT));                                                     \
+  HANDLECUDA(cudaMalloc(&TMPN1, TMPN1##_bytes));                          \
+  cub::DeviceReduce::Reduce(                                              \
+      TMPN1,                                                              \
+      TMPN1##_bytes,                                                      \
+      (REDUCE_PTR),                                                       \
+      (RESULT_PTR),                                                       \
+      (NUM_ITEMS),                                                        \
+      (REDUCE_OP),                                                        \
+      (REDUCE_INIT));                                                     \
+  HANDLECUDA(cudaFree(TMPN1));
+#define REDUCE_WS(           \
+    REDUCE_PTR,              \
+    RESULT_PTR,              \
+    NUM_ITEMS,               \
+    REDUCE_OP,               \
+    REDUCE_INIT,             \
+    WORKSPACE_PTR,           \
+    WORSPACE_BYTES,          \
+    STREAM)                  \
+  cub::DeviceReduce::Reduce( \
+      (WORKSPACE_PTR),       \
+      (WORSPACE_BYTES),      \
+      (REDUCE_PTR),          \
+      (RESULT_PTR),          \
+      (NUM_ITEMS),           \
+      (REDUCE_OP),           \
+      (REDUCE_INIT),         \
+      (STREAM));
+#define SELECT_FLAGS_WS(      \
+    FLAGS_PTR,                \
+    ITEM_PTR,                 \
+    OUT_PTR,                  \
+    NUM_SELECTED_PTR,         \
+    NUM_ITEMS,                \
+    WORKSPACE_PTR,            \
+    WORSPACE_BYTES,           \
+    STREAM)                   \
+  cub::DeviceSelect::Flagged( \
+      (WORKSPACE_PTR),        \
+      (WORSPACE_BYTES),       \
+      (ITEM_PTR),             \
+      (FLAGS_PTR),            \
+      (OUT_PTR),              \
+      (NUM_SELECTED_PTR),     \
+      (NUM_ITEMS),            \
+      stream = (STREAM));
+
+#define COPY_HOST_DEV(PTR_D, PTR_H, TYPE, SIZE) \
+  HANDLECUDA(cudaMemcpy(                        \
+      (PTR_D), (PTR_H), sizeof(TYPE) * (SIZE), cudaMemcpyHostToDevice))
+#define COPY_DEV_HOST(PTR_H, PTR_D, TYPE, SIZE) \
+  HANDLECUDA(cudaMemcpy(                        \
+      (PTR_H), (PTR_D), sizeof(TYPE) * (SIZE), cudaMemcpyDeviceToHost))
+#define COPY_DEV_DEV(PTR_T, PTR_S, TYPE, SIZE) \
+  HANDLECUDA(cudaMemcpy(                       \
+      (PTR_T), (PTR_S), sizeof(TYPE) * (SIZE), cudaMemcpyDeviceToDevice))
+//
+// We *must* use cudaMallocManaged for pointers on device that should
+// interact with pytorch. However, this comes at a significant speed penalty.
+// We're using plain CUDA pointers for the rendering operations and
+// explicitly copy results to managed pointers wrapped for pytorch (see
+// pytorch/util.h).
+#define MALLOC(VAR, TYPE, SIZE) cudaMalloc(&(VAR), sizeof(TYPE) * (SIZE))
+#define FREE(PTR) HANDLECUDA(cudaFree(PTR))
+#define MEMSET(VAR, VAL, TYPE, SIZE, STREAM) \
+  HANDLECUDA(cudaMemsetAsync((VAR), (VAL), sizeof(TYPE) * (SIZE), (STREAM)))
+
+#define LAUNCH_MAX_PARALLEL_1D(FUNC, N, STREAM, ...)                \
+  {                                                                 \
+    int64_t max_threads =                                           \
+        at::cuda::getCurrentDeviceProperties()->maxThreadsPerBlock; \
+    uint num_threads = min((N), max_threads);                       \
+    uint num_blocks = iDivCeil((N), num_threads);                   \
+    FUNC<<<num_blocks, num_threads, 0, (STREAM)>>>(__VA_ARGS__);    \
+  }
+#define LAUNCH_PARALLEL_1D(FUNC, N, TN, STREAM, ...)                   \
+  {                                                                    \
+    uint num_threads = min(static_cast<int>(N), static_cast<int>(TN)); \
+    uint num_blocks = iDivCeil((N), num_threads);                      \
+    FUNC<<<num_blocks, num_threads, 0, (STREAM)>>>(__VA_ARGS__);       \
+  }
+#define LAUNCH_MAX_PARALLEL_2D(FUNC, NX, NY, STREAM, ...)               \
+  {                                                                     \
+    int64_t max_threads =                                               \
+        at::cuda::getCurrentDeviceProperties()->maxThreadsPerBlock;     \
+    int64_t max_threads_sqrt = static_cast<int64_t>(sqrt(max_threads)); \
+    dim3 num_threads, num_blocks;                                       \
+    num_threads.x = min((NX), max_threads_sqrt);                        \
+    num_blocks.x = iDivCeil((NX), num_threads.x);                       \
+    num_threads.y = min((NY), max_threads_sqrt);                        \
+    num_blocks.y = iDivCeil((NY), num_threads.y);                       \
+    num_threads.z = 1;                                                  \
+    num_blocks.z = 1;                                                   \
+    FUNC<<<num_blocks, num_threads, 0, (STREAM)>>>(__VA_ARGS__);        \
+  }
+#define LAUNCH_PARALLEL_2D(FUNC, NX, NY, TX, TY, STREAM, ...)    \
+  {                                                              \
+    dim3 num_threads, num_blocks;                                \
+    num_threads.x = min((NX), (TX));                             \
+    num_blocks.x = iDivCeil((NX), num_threads.x);                \
+    num_threads.y = min((NY), (TY));                             \
+    num_blocks.y = iDivCeil((NY), num_threads.y);                \
+    num_threads.z = 1;                                           \
+    num_blocks.z = 1;                                            \
+    FUNC<<<num_blocks, num_threads, 0, (STREAM)>>>(__VA_ARGS__); \
+  }
+
+#define GET_PARALLEL_IDX_1D(VARNAME, N)                               \
+  const uint VARNAME = __mul24(blockIdx.x, blockDim.x) + threadIdx.x; \
+  if (VARNAME >= (N)) {                                               \
+    return;                                                           \
+  }
+#define GET_PARALLEL_IDS_2D(VAR_X, VAR_Y, WIDTH, HEIGHT)            \
+  const uint VAR_X = __mul24(blockIdx.x, blockDim.x) + threadIdx.x; \
+  const uint VAR_Y = __mul24(blockIdx.y, blockDim.y) + threadIdx.y; \
+  if (VAR_X >= (WIDTH) || VAR_Y >= (HEIGHT))                        \
+    return;
+#define END_PARALLEL()
+#define END_PARALLEL_NORET()
+#define END_PARALLEL_2D_NORET()
+#define END_PARALLEL_2D()
+#define RETURN_PARALLEL() return
+#define CHECKLAUNCH() C10_CUDA_CHECK(cudaGetLastError());
+#define ISONDEVICE true
+#define SYNCDEVICE() HANDLECUDA(cudaDeviceSynchronize())
+#define START_TIME(TN)                             \
+  cudaEvent_t __time_start_##TN, __time_stop_##TN; \
+  cudaEventCreate(&__time_start_##TN);             \
+  cudaEventCreate(&__time_stop_##TN);              \
+  cudaEventRecord(__time_start_##TN);
+#define STOP_TIME(TN) cudaEventRecord(__time_stop_##TN);
+#define GET_TIME(TN, TOPTR)               \
+  cudaEventSynchronize(__time_stop_##TN); \
+  cudaEventElapsedTime((TOPTR), __time_start_##TN, __time_stop_##TN);
+#define START_TIME_CU(TN) START_TIME(CN)
+#define STOP_TIME_CU(TN) STOP_TIME(TN)
+#define GET_TIME_CU(TN, TOPTR) GET_TIME(TN, TOPTR)
+
+#endif

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/pulsar/cuda/renderer.backward.gpu.cu

@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "../include/renderer.backward.instantiate.h"

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/pulsar/cuda/renderer.backward_dbg.gpu.cu

@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "../include/renderer.backward_dbg.instantiate.h"

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/pulsar/cuda/renderer.calc_gradients.gpu.cu

@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "../include/renderer.calc_gradients.instantiate.h"

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/pulsar/cuda/renderer.calc_signature.gpu.cu

@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "../include/renderer.calc_signature.instantiate.h"

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/pulsar/cuda/renderer.construct.gpu.cu

@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "../include/renderer.construct.instantiate.h"

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/pulsar/cuda/renderer.create_selector.gpu.cu

@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "../include/renderer.create_selector.instantiate.h"

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/pulsar/cuda/renderer.destruct.gpu.cu

@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "../include/renderer.destruct.instantiate.h"