Copy disabled (too large)
Download .txt
Showing preview only (18,874K chars total). Download the full file to get everything.
Repository: GimpelZhang/GaussianRPG
Branch: main
Commit: 86ac96d6ba37
Files: 1718
Total size: 31.7 MB
Directory structure:
gitextract_24ehzmat/
├── .gitignore
├── .idea/
│ ├── .gitignore
│ ├── inspectionProfiles/
│ │ └── profiles_settings.xml
│ ├── misc.xml
│ ├── modules.xml
│ ├── street_gaussians.iml
│ └── vcs.xml
├── README.md
├── configs/
│ ├── example/
│ │ ├── waymo_train_002.yaml
│ │ ├── waymo_train_002_1cam.yaml
│ │ ├── waymo_train_031.yaml
│ │ ├── waymo_train_124_1cam.yaml
│ │ └── waymo_train_149_1cam.yaml
│ └── experiments_waymo/
│ ├── waymo_val_006.yaml
│ ├── waymo_val_026.yaml
│ ├── waymo_val_090.yaml
│ ├── waymo_val_105.yaml
│ ├── waymo_val_108.yaml
│ ├── waymo_val_134.yaml
│ ├── waymo_val_150.yaml
│ └── waymo_val_181.yaml
├── lib/
│ ├── config/
│ │ ├── __init__.py
│ │ ├── config.py
│ │ └── yacs.py
│ ├── datasets/
│ │ ├── base_readers.py
│ │ ├── blender_readers.py
│ │ ├── colmap_readers.py
│ │ ├── dataset.py
│ │ └── waymo_full_readers.py
│ ├── models/
│ │ ├── __init__.py
│ │ ├── actor_pose.py
│ │ ├── camera_pose.py
│ │ ├── color_correction.py
│ │ ├── gaussian_model.py
│ │ ├── gaussian_model_actor.py
│ │ ├── gaussian_model_bkgd.py
│ │ ├── gaussian_model_sky.py
│ │ ├── gaussian_renderer.py
│ │ ├── network_gui.py
│ │ ├── scene.py
│ │ ├── sky_cubemap.py
│ │ ├── street_gaussian_model.py
│ │ └── street_gaussian_renderer.py
│ ├── utils/
│ │ ├── __init__.py
│ │ ├── box_utils.py
│ │ ├── camera_utils.py
│ │ ├── cfg_utils.py
│ │ ├── colmap_utils.py
│ │ ├── data_utils.py
│ │ ├── general_utils.py
│ │ ├── graphics_utils.py
│ │ ├── img_utils.py
│ │ ├── loss_utils.py
│ │ ├── lpipsPyTorch/
│ │ │ ├── __init__.py
│ │ │ └── modules/
│ │ │ ├── lpips.py
│ │ │ ├── networks.py
│ │ │ └── utils.py
│ │ ├── sem_utils.py
│ │ ├── sh_utils.py
│ │ ├── system_utils.py
│ │ ├── vq_utils.py
│ │ └── waymo_utils.py
│ └── visualizers/
│ ├── base_visualizer.py
│ └── street_gaussian_visualizer.py
├── make_ply.py
├── metrics.py
├── models/
│ ├── __init__.py
│ ├── common.py
│ ├── experimental.py
│ ├── export.py
│ ├── hub/
│ │ ├── anchors.yaml
│ │ ├── yolov3-spp.yaml
│ │ ├── yolov3-tiny.yaml
│ │ ├── yolov3.yaml
│ │ ├── yolov5-fpn.yaml
│ │ ├── yolov5-p2.yaml
│ │ ├── yolov5-p6.yaml
│ │ ├── yolov5-p7.yaml
│ │ ├── yolov5-panet.yaml
│ │ ├── yolov5l6.yaml
│ │ ├── yolov5m6.yaml
│ │ ├── yolov5s-transformer.yaml
│ │ ├── yolov5s6.yaml
│ │ └── yolov5x6.yaml
│ ├── yolo.py
│ ├── yolov5l.yaml
│ ├── yolov5m.yaml
│ ├── yolov5s.yaml
│ └── yolov5x.yaml
├── networks/
│ ├── __init__.py
│ ├── depth_decoder.py
│ ├── pose_cnn.py
│ ├── pose_decoder.py
│ └── resnet_encoder.py
├── nodes/
│ ├── rviz2/
│ │ └── gaussian_rpg.rviz
│ ├── scripts/
│ │ ├── simulator_launch.sh
│ │ ├── simulator_launch_hil.sh
│ │ └── simulator_launch_separate.sh
│ └── src/
│ ├── dummy_controllers/
│ │ ├── LICENSE
│ │ ├── dummy_controllers/
│ │ │ ├── AEB_controller.py
│ │ │ ├── __init__.py
│ │ │ └── object_detector.py
│ │ ├── package.xml
│ │ ├── resource/
│ │ │ └── dummy_controllers
│ │ ├── setup.cfg
│ │ ├── setup.py
│ │ └── test/
│ │ ├── test_copyright.py
│ │ ├── test_flake8.py
│ │ └── test_pep257.py
│ └── simulator/
│ ├── LICENSE
│ ├── package.xml
│ ├── resource/
│ │ └── simulator
│ ├── setup.cfg
│ ├── setup.py
│ ├── simulator/
│ │ ├── __init__.py
│ │ ├── evaluation.py
│ │ ├── groundtruth.py
│ │ ├── simulator.py
│ │ └── simulator_hil.py
│ └── test/
│ ├── test_copyright.py
│ ├── test_flake8.py
│ └── test_pep257.py
├── on_board/
│ └── nodes/
│ └── src/
│ └── dummy_controllers/
│ ├── LICENSE
│ ├── dummy_controllers/
│ │ ├── AEB_controller.py
│ │ ├── __init__.py
│ │ ├── object_detector.py
│ │ └── test_yolov5.py
│ ├── package.xml
│ ├── resource/
│ │ └── dummy_controllers
│ ├── setup.cfg
│ ├── setup.py
│ └── test/
│ ├── test_copyright.py
│ ├── test_flake8.py
│ └── test_pep257.py
├── render.py
├── render_lite.py
├── requirements.txt
├── script/
│ ├── convert.py
│ ├── kitti/
│ │ ├── colmap_kitti.py
│ │ ├── generate_dynamic_mask.py
│ │ ├── generate_semantic_mask.py
│ │ └── generate_sky_mask.py
│ ├── render_waymo_example.sh
│ ├── render_waymo_exp.sh
│ ├── test_gaussian_rasterization.py
│ ├── train_waymo_example.sh
│ ├── train_waymo_exp.sh
│ └── waymo/
│ ├── colmap_waymo_full.py
│ ├── generate_lidar_depth.py
│ ├── generate_mono_depth.py
│ ├── generate_mono_normal.py
│ ├── generate_sky_mask.py
│ ├── waymo_converter.py
│ └── waymo_splits/
│ ├── demo.txt
│ ├── more_examples.txt
│ ├── segment_list_train.txt
│ ├── segment_list_val.txt
│ ├── train_diverse.txt
│ ├── train_dynamic.txt
│ ├── train_static.txt
│ └── val_dynamic.txt
├── submodules/
│ ├── diff-gaussian-rasterization/
│ │ ├── .gitignore
│ │ ├── .gitmodules
│ │ ├── CMakeLists.txt
│ │ ├── LICENSE.md
│ │ ├── README.md
│ │ ├── cuda_rasterizer/
│ │ │ ├── auxiliary.h
│ │ │ ├── backward.cu
│ │ │ ├── backward.h
│ │ │ ├── config.h
│ │ │ ├── forward.cu
│ │ │ ├── forward.h
│ │ │ ├── rasterizer.h
│ │ │ ├── rasterizer_impl.cu
│ │ │ └── rasterizer_impl.h
│ │ ├── diff_gaussian_rasterization/
│ │ │ └── __init__.py
│ │ ├── ext.cpp
│ │ ├── rasterize_points.cu
│ │ ├── rasterize_points.h
│ │ ├── setup.py
│ │ └── third_party/
│ │ ├── glm/
│ │ │ ├── .appveyor.yml
│ │ │ ├── .gitignore
│ │ │ ├── .travis.yml
│ │ │ ├── CMakeLists.txt
│ │ │ ├── cmake/
│ │ │ │ └── cmake_uninstall.cmake.in
│ │ │ ├── copying.txt
│ │ │ ├── doc/
│ │ │ │ ├── api/
│ │ │ │ │ ├── a00001_source.html
│ │ │ │ │ ├── a00002_source.html
│ │ │ │ │ ├── a00003_source.html
│ │ │ │ │ ├── a00004_source.html
│ │ │ │ │ ├── a00005_source.html
│ │ │ │ │ ├── a00006_source.html
│ │ │ │ │ ├── a00007.html
│ │ │ │ │ ├── a00007_source.html
│ │ │ │ │ ├── a00008.html
│ │ │ │ │ ├── a00008_source.html
│ │ │ │ │ ├── a00009.html
│ │ │ │ │ ├── a00009_source.html
│ │ │ │ │ ├── a00010.html
│ │ │ │ │ ├── a00010_source.html
│ │ │ │ │ ├── a00011.html
│ │ │ │ │ ├── a00011_source.html
│ │ │ │ │ ├── a00012.html
│ │ │ │ │ ├── a00012_source.html
│ │ │ │ │ ├── a00013.html
│ │ │ │ │ ├── a00013_source.html
│ │ │ │ │ ├── a00014.html
│ │ │ │ │ ├── a00014_source.html
│ │ │ │ │ ├── a00015.html
│ │ │ │ │ ├── a00015_source.html
│ │ │ │ │ ├── a00016.html
│ │ │ │ │ ├── a00016_source.html
│ │ │ │ │ ├── a00017.html
│ │ │ │ │ ├── a00017_source.html
│ │ │ │ │ ├── a00018.html
│ │ │ │ │ ├── a00018_source.html
│ │ │ │ │ ├── a00019_source.html
│ │ │ │ │ ├── a00020_source.html
│ │ │ │ │ ├── a00021.html
│ │ │ │ │ ├── a00021_source.html
│ │ │ │ │ ├── a00022.html
│ │ │ │ │ ├── a00022_source.html
│ │ │ │ │ ├── a00023.html
│ │ │ │ │ ├── a00023_source.html
│ │ │ │ │ ├── a00024.html
│ │ │ │ │ ├── a00024_source.html
│ │ │ │ │ ├── a00025.html
│ │ │ │ │ ├── a00025_source.html
│ │ │ │ │ ├── a00026.html
│ │ │ │ │ ├── a00026_source.html
│ │ │ │ │ ├── a00027.html
│ │ │ │ │ ├── a00027_source.html
│ │ │ │ │ ├── a00028.html
│ │ │ │ │ ├── a00028_source.html
│ │ │ │ │ ├── a00029.html
│ │ │ │ │ ├── a00029_source.html
│ │ │ │ │ ├── a00030.html
│ │ │ │ │ ├── a00030_source.html
│ │ │ │ │ ├── a00031.html
│ │ │ │ │ ├── a00031_source.html
│ │ │ │ │ ├── a00032.html
│ │ │ │ │ ├── a00032_source.html
│ │ │ │ │ ├── a00033.html
│ │ │ │ │ ├── a00033_source.html
│ │ │ │ │ ├── a00034.html
│ │ │ │ │ ├── a00034_source.html
│ │ │ │ │ ├── a00035_source.html
│ │ │ │ │ ├── a00036.html
│ │ │ │ │ ├── a00036_source.html
│ │ │ │ │ ├── a00037.html
│ │ │ │ │ ├── a00037_source.html
│ │ │ │ │ ├── a00038.html
│ │ │ │ │ ├── a00038_source.html
│ │ │ │ │ ├── a00039.html
│ │ │ │ │ ├── a00039_source.html
│ │ │ │ │ ├── a00040.html
│ │ │ │ │ ├── a00040_source.html
│ │ │ │ │ ├── a00041.html
│ │ │ │ │ ├── a00041_source.html
│ │ │ │ │ ├── a00042.html
│ │ │ │ │ ├── a00042_source.html
│ │ │ │ │ ├── a00043.html
│ │ │ │ │ ├── a00043_source.html
│ │ │ │ │ ├── a00044.html
│ │ │ │ │ ├── a00044_source.html
│ │ │ │ │ ├── a00045.html
│ │ │ │ │ ├── a00045_source.html
│ │ │ │ │ ├── a00046.html
│ │ │ │ │ ├── a00046_source.html
│ │ │ │ │ ├── a00047_source.html
│ │ │ │ │ ├── a00048.html
│ │ │ │ │ ├── a00048_source.html
│ │ │ │ │ ├── a00049.html
│ │ │ │ │ ├── a00049_source.html
│ │ │ │ │ ├── a00050.html
│ │ │ │ │ ├── a00050_source.html
│ │ │ │ │ ├── a00051.html
│ │ │ │ │ ├── a00051_source.html
│ │ │ │ │ ├── a00052.html
│ │ │ │ │ ├── a00052_source.html
│ │ │ │ │ ├── a00053.html
│ │ │ │ │ ├── a00053_source.html
│ │ │ │ │ ├── a00054.html
│ │ │ │ │ ├── a00054_source.html
│ │ │ │ │ ├── a00055.html
│ │ │ │ │ ├── a00055_source.html
│ │ │ │ │ ├── a00056.html
│ │ │ │ │ ├── a00056_source.html
│ │ │ │ │ ├── a00057.html
│ │ │ │ │ ├── a00057_source.html
│ │ │ │ │ ├── a00058.html
│ │ │ │ │ ├── a00058_source.html
│ │ │ │ │ ├── a00059.html
│ │ │ │ │ ├── a00059_source.html
│ │ │ │ │ ├── a00060.html
│ │ │ │ │ ├── a00060_source.html
│ │ │ │ │ ├── a00061.html
│ │ │ │ │ ├── a00061_source.html
│ │ │ │ │ ├── a00062.html
│ │ │ │ │ ├── a00062_source.html
│ │ │ │ │ ├── a00063.html
│ │ │ │ │ ├── a00063_source.html
│ │ │ │ │ ├── a00064.html
│ │ │ │ │ ├── a00064_source.html
│ │ │ │ │ ├── a00065.html
│ │ │ │ │ ├── a00065_source.html
│ │ │ │ │ ├── a00066.html
│ │ │ │ │ ├── a00066_source.html
│ │ │ │ │ ├── a00067.html
│ │ │ │ │ ├── a00067_source.html
│ │ │ │ │ ├── a00068.html
│ │ │ │ │ ├── a00068_source.html
│ │ │ │ │ ├── a00069.html
│ │ │ │ │ ├── a00069_source.html
│ │ │ │ │ ├── a00070.html
│ │ │ │ │ ├── a00070_source.html
│ │ │ │ │ ├── a00071.html
│ │ │ │ │ ├── a00071_source.html
│ │ │ │ │ ├── a00072.html
│ │ │ │ │ ├── a00072_source.html
│ │ │ │ │ ├── a00073.html
│ │ │ │ │ ├── a00073_source.html
│ │ │ │ │ ├── a00074.html
│ │ │ │ │ ├── a00074_source.html
│ │ │ │ │ ├── a00075.html
│ │ │ │ │ ├── a00075_source.html
│ │ │ │ │ ├── a00076.html
│ │ │ │ │ ├── a00076_source.html
│ │ │ │ │ ├── a00077.html
│ │ │ │ │ ├── a00077_source.html
│ │ │ │ │ ├── a00078.html
│ │ │ │ │ ├── a00078_source.html
│ │ │ │ │ ├── a00079.html
│ │ │ │ │ ├── a00079_source.html
│ │ │ │ │ ├── a00080.html
│ │ │ │ │ ├── a00080_source.html
│ │ │ │ │ ├── a00081.html
│ │ │ │ │ ├── a00081_source.html
│ │ │ │ │ ├── a00082.html
│ │ │ │ │ ├── a00082_source.html
│ │ │ │ │ ├── a00083.html
│ │ │ │ │ ├── a00083_source.html
│ │ │ │ │ ├── a00084.html
│ │ │ │ │ ├── a00084_source.html
│ │ │ │ │ ├── a00085.html
│ │ │ │ │ ├── a00085_source.html
│ │ │ │ │ ├── a00086.html
│ │ │ │ │ ├── a00086_source.html
│ │ │ │ │ ├── a00087.html
│ │ │ │ │ ├── a00087_source.html
│ │ │ │ │ ├── a00088.html
│ │ │ │ │ ├── a00088_source.html
│ │ │ │ │ ├── a00089.html
│ │ │ │ │ ├── a00089_source.html
│ │ │ │ │ ├── a00090.html
│ │ │ │ │ ├── a00090_source.html
│ │ │ │ │ ├── a00091.html
│ │ │ │ │ ├── a00091_source.html
│ │ │ │ │ ├── a00092.html
│ │ │ │ │ ├── a00092_source.html
│ │ │ │ │ ├── a00093.html
│ │ │ │ │ ├── a00093_source.html
│ │ │ │ │ ├── a00094.html
│ │ │ │ │ ├── a00094_source.html
│ │ │ │ │ ├── a00095_source.html
│ │ │ │ │ ├── a00096.html
│ │ │ │ │ ├── a00096_source.html
│ │ │ │ │ ├── a00097.html
│ │ │ │ │ ├── a00097_source.html
│ │ │ │ │ ├── a00098.html
│ │ │ │ │ ├── a00098_source.html
│ │ │ │ │ ├── a00099.html
│ │ │ │ │ ├── a00099_source.html
│ │ │ │ │ ├── a00100.html
│ │ │ │ │ ├── a00100_source.html
│ │ │ │ │ ├── a00101.html
│ │ │ │ │ ├── a00101_source.html
│ │ │ │ │ ├── a00102.html
│ │ │ │ │ ├── a00102_source.html
│ │ │ │ │ ├── a00103.html
│ │ │ │ │ ├── a00103_source.html
│ │ │ │ │ ├── a00104.html
│ │ │ │ │ ├── a00104_source.html
│ │ │ │ │ ├── a00105.html
│ │ │ │ │ ├── a00105_source.html
│ │ │ │ │ ├── a00106.html
│ │ │ │ │ ├── a00106_source.html
│ │ │ │ │ ├── a00107.html
│ │ │ │ │ ├── a00107_source.html
│ │ │ │ │ ├── a00108.html
│ │ │ │ │ ├── a00108_source.html
│ │ │ │ │ ├── a00109.html
│ │ │ │ │ ├── a00109_source.html
│ │ │ │ │ ├── a00110.html
│ │ │ │ │ ├── a00110_source.html
│ │ │ │ │ ├── a00111.html
│ │ │ │ │ ├── a00111_source.html
│ │ │ │ │ ├── a00112.html
│ │ │ │ │ ├── a00112_source.html
│ │ │ │ │ ├── a00113.html
│ │ │ │ │ ├── a00113_source.html
│ │ │ │ │ ├── a00114.html
│ │ │ │ │ ├── a00114_source.html
│ │ │ │ │ ├── a00115.html
│ │ │ │ │ ├── a00115_source.html
│ │ │ │ │ ├── a00116.html
│ │ │ │ │ ├── a00116_source.html
│ │ │ │ │ ├── a00117.html
│ │ │ │ │ ├── a00117_source.html
│ │ │ │ │ ├── a00118.html
│ │ │ │ │ ├── a00118_source.html
│ │ │ │ │ ├── a00119.html
│ │ │ │ │ ├── a00119_source.html
│ │ │ │ │ ├── a00120.html
│ │ │ │ │ ├── a00120_source.html
│ │ │ │ │ ├── a00121.html
│ │ │ │ │ ├── a00121_source.html
│ │ │ │ │ ├── a00122.html
│ │ │ │ │ ├── a00122_source.html
│ │ │ │ │ ├── a00123.html
│ │ │ │ │ ├── a00123_source.html
│ │ │ │ │ ├── a00124_source.html
│ │ │ │ │ ├── a00125.html
│ │ │ │ │ ├── a00125_source.html
│ │ │ │ │ ├── a00126.html
│ │ │ │ │ ├── a00126_source.html
│ │ │ │ │ ├── a00127.html
│ │ │ │ │ ├── a00127_source.html
│ │ │ │ │ ├── a00128.html
│ │ │ │ │ ├── a00128_source.html
│ │ │ │ │ ├── a00129.html
│ │ │ │ │ ├── a00129_source.html
│ │ │ │ │ ├── a00130.html
│ │ │ │ │ ├── a00130_source.html
│ │ │ │ │ ├── a00131.html
│ │ │ │ │ ├── a00131_source.html
│ │ │ │ │ ├── a00132.html
│ │ │ │ │ ├── a00132_source.html
│ │ │ │ │ ├── a00133.html
│ │ │ │ │ ├── a00133_source.html
│ │ │ │ │ ├── a00134.html
│ │ │ │ │ ├── a00134_source.html
│ │ │ │ │ ├── a00135.html
│ │ │ │ │ ├── a00135_source.html
│ │ │ │ │ ├── a00136.html
│ │ │ │ │ ├── a00136_source.html
│ │ │ │ │ ├── a00137.html
│ │ │ │ │ ├── a00137_source.html
│ │ │ │ │ ├── a00138.html
│ │ │ │ │ ├── a00138_source.html
│ │ │ │ │ ├── a00139.html
│ │ │ │ │ ├── a00139_source.html
│ │ │ │ │ ├── a00140.html
│ │ │ │ │ ├── a00140_source.html
│ │ │ │ │ ├── a00141.html
│ │ │ │ │ ├── a00141_source.html
│ │ │ │ │ ├── a00142.html
│ │ │ │ │ ├── a00142_source.html
│ │ │ │ │ ├── a00143.html
│ │ │ │ │ ├── a00143_source.html
│ │ │ │ │ ├── a00144.html
│ │ │ │ │ ├── a00144_source.html
│ │ │ │ │ ├── a00145.html
│ │ │ │ │ ├── a00145_source.html
│ │ │ │ │ ├── a00146.html
│ │ │ │ │ ├── a00146_source.html
│ │ │ │ │ ├── a00147.html
│ │ │ │ │ ├── a00147_source.html
│ │ │ │ │ ├── a00148.html
│ │ │ │ │ ├── a00148_source.html
│ │ │ │ │ ├── a00149.html
│ │ │ │ │ ├── a00149_source.html
│ │ │ │ │ ├── a00150.html
│ │ │ │ │ ├── a00150_source.html
│ │ │ │ │ ├── a00151.html
│ │ │ │ │ ├── a00151_source.html
│ │ │ │ │ ├── a00152.html
│ │ │ │ │ ├── a00152_source.html
│ │ │ │ │ ├── a00153_source.html
│ │ │ │ │ ├── a00154.html
│ │ │ │ │ ├── a00154_source.html
│ │ │ │ │ ├── a00155.html
│ │ │ │ │ ├── a00155_source.html
│ │ │ │ │ ├── a00156.html
│ │ │ │ │ ├── a00156_source.html
│ │ │ │ │ ├── a00157.html
│ │ │ │ │ ├── a00157_source.html
│ │ │ │ │ ├── a00158.html
│ │ │ │ │ ├── a00158_source.html
│ │ │ │ │ ├── a00159.html
│ │ │ │ │ ├── a00159_source.html
│ │ │ │ │ ├── a00160.html
│ │ │ │ │ ├── a00160_source.html
│ │ │ │ │ ├── a00161.html
│ │ │ │ │ ├── a00161_source.html
│ │ │ │ │ ├── a00162.html
│ │ │ │ │ ├── a00162_source.html
│ │ │ │ │ ├── a00163_source.html
│ │ │ │ │ ├── a00164_source.html
│ │ │ │ │ ├── a00165.html
│ │ │ │ │ ├── a00165_source.html
│ │ │ │ │ ├── a00166.html
│ │ │ │ │ ├── a00166_source.html
│ │ │ │ │ ├── a00167.html
│ │ │ │ │ ├── a00167_source.html
│ │ │ │ │ ├── a00168.html
│ │ │ │ │ ├── a00168_source.html
│ │ │ │ │ ├── a00169.html
│ │ │ │ │ ├── a00169_source.html
│ │ │ │ │ ├── a00170.html
│ │ │ │ │ ├── a00170_source.html
│ │ │ │ │ ├── a00171.html
│ │ │ │ │ ├── a00171_source.html
│ │ │ │ │ ├── a00172.html
│ │ │ │ │ ├── a00172_source.html
│ │ │ │ │ ├── a00173.html
│ │ │ │ │ ├── a00173_source.html
│ │ │ │ │ ├── a00174.html
│ │ │ │ │ ├── a00174_source.html
│ │ │ │ │ ├── a00175.html
│ │ │ │ │ ├── a00175_source.html
│ │ │ │ │ ├── a00176.html
│ │ │ │ │ ├── a00176_source.html
│ │ │ │ │ ├── a00177.html
│ │ │ │ │ ├── a00177_source.html
│ │ │ │ │ ├── a00178.html
│ │ │ │ │ ├── a00178_source.html
│ │ │ │ │ ├── a00179.html
│ │ │ │ │ ├── a00179_source.html
│ │ │ │ │ ├── a00180.html
│ │ │ │ │ ├── a00180_source.html
│ │ │ │ │ ├── a00181.html
│ │ │ │ │ ├── a00181_source.html
│ │ │ │ │ ├── a00182.html
│ │ │ │ │ ├── a00182_source.html
│ │ │ │ │ ├── a00183.html
│ │ │ │ │ ├── a00183_source.html
│ │ │ │ │ ├── a00184.html
│ │ │ │ │ ├── a00184_source.html
│ │ │ │ │ ├── a00185.html
│ │ │ │ │ ├── a00185_source.html
│ │ │ │ │ ├── a00186.html
│ │ │ │ │ ├── a00186_source.html
│ │ │ │ │ ├── a00187.html
│ │ │ │ │ ├── a00187_source.html
│ │ │ │ │ ├── a00188.html
│ │ │ │ │ ├── a00188_source.html
│ │ │ │ │ ├── a00189.html
│ │ │ │ │ ├── a00189_source.html
│ │ │ │ │ ├── a00190.html
│ │ │ │ │ ├── a00190_source.html
│ │ │ │ │ ├── a00191.html
│ │ │ │ │ ├── a00191_source.html
│ │ │ │ │ ├── a00192.html
│ │ │ │ │ ├── a00192_source.html
│ │ │ │ │ ├── a00193.html
│ │ │ │ │ ├── a00193_source.html
│ │ │ │ │ ├── a00194.html
│ │ │ │ │ ├── a00194_source.html
│ │ │ │ │ ├── a00195.html
│ │ │ │ │ ├── a00195_source.html
│ │ │ │ │ ├── a00196.html
│ │ │ │ │ ├── a00196_source.html
│ │ │ │ │ ├── a00197.html
│ │ │ │ │ ├── a00197_source.html
│ │ │ │ │ ├── a00198.html
│ │ │ │ │ ├── a00198_source.html
│ │ │ │ │ ├── a00199.html
│ │ │ │ │ ├── a00199_source.html
│ │ │ │ │ ├── a00200.html
│ │ │ │ │ ├── a00200_source.html
│ │ │ │ │ ├── a00201.html
│ │ │ │ │ ├── a00201_source.html
│ │ │ │ │ ├── a00202.html
│ │ │ │ │ ├── a00202_source.html
│ │ │ │ │ ├── a00203.html
│ │ │ │ │ ├── a00203_source.html
│ │ │ │ │ ├── a00204.html
│ │ │ │ │ ├── a00204_source.html
│ │ │ │ │ ├── a00205.html
│ │ │ │ │ ├── a00205_source.html
│ │ │ │ │ ├── a00206.html
│ │ │ │ │ ├── a00206_source.html
│ │ │ │ │ ├── a00207.html
│ │ │ │ │ ├── a00207_source.html
│ │ │ │ │ ├── a00208.html
│ │ │ │ │ ├── a00208_source.html
│ │ │ │ │ ├── a00209.html
│ │ │ │ │ ├── a00209_source.html
│ │ │ │ │ ├── a00210.html
│ │ │ │ │ ├── a00210_source.html
│ │ │ │ │ ├── a00211.html
│ │ │ │ │ ├── a00211_source.html
│ │ │ │ │ ├── a00212.html
│ │ │ │ │ ├── a00212_source.html
│ │ │ │ │ ├── a00213.html
│ │ │ │ │ ├── a00213_source.html
│ │ │ │ │ ├── a00214.html
│ │ │ │ │ ├── a00214_source.html
│ │ │ │ │ ├── a00215.html
│ │ │ │ │ ├── a00215_source.html
│ │ │ │ │ ├── a00216.html
│ │ │ │ │ ├── a00216_source.html
│ │ │ │ │ ├── a00217.html
│ │ │ │ │ ├── a00217_source.html
│ │ │ │ │ ├── a00218.html
│ │ │ │ │ ├── a00218_source.html
│ │ │ │ │ ├── a00219.html
│ │ │ │ │ ├── a00219_source.html
│ │ │ │ │ ├── a00220.html
│ │ │ │ │ ├── a00220_source.html
│ │ │ │ │ ├── a00221.html
│ │ │ │ │ ├── a00221_source.html
│ │ │ │ │ ├── a00222.html
│ │ │ │ │ ├── a00222_source.html
│ │ │ │ │ ├── a00223.html
│ │ │ │ │ ├── a00223_source.html
│ │ │ │ │ ├── a00224.html
│ │ │ │ │ ├── a00224_source.html
│ │ │ │ │ ├── a00225.html
│ │ │ │ │ ├── a00225_source.html
│ │ │ │ │ ├── a00226.html
│ │ │ │ │ ├── a00226_source.html
│ │ │ │ │ ├── a00227.html
│ │ │ │ │ ├── a00227_source.html
│ │ │ │ │ ├── a00228.html
│ │ │ │ │ ├── a00228_source.html
│ │ │ │ │ ├── a00229.html
│ │ │ │ │ ├── a00229_source.html
│ │ │ │ │ ├── a00230.html
│ │ │ │ │ ├── a00230_source.html
│ │ │ │ │ ├── a00231.html
│ │ │ │ │ ├── a00231_source.html
│ │ │ │ │ ├── a00232.html
│ │ │ │ │ ├── a00232_source.html
│ │ │ │ │ ├── a00233.html
│ │ │ │ │ ├── a00233_source.html
│ │ │ │ │ ├── a00234.html
│ │ │ │ │ ├── a00234_source.html
│ │ │ │ │ ├── a00235.html
│ │ │ │ │ ├── a00235_source.html
│ │ │ │ │ ├── a00241.html
│ │ │ │ │ ├── a00242.html
│ │ │ │ │ ├── a00243.html
│ │ │ │ │ ├── a00244.html
│ │ │ │ │ ├── a00245.html
│ │ │ │ │ ├── a00246.html
│ │ │ │ │ ├── a00247.html
│ │ │ │ │ ├── a00248.html
│ │ │ │ │ ├── a00249.html
│ │ │ │ │ ├── a00250.html
│ │ │ │ │ ├── a00251.html
│ │ │ │ │ ├── a00252.html
│ │ │ │ │ ├── a00253.html
│ │ │ │ │ ├── a00254.html
│ │ │ │ │ ├── a00255.html
│ │ │ │ │ ├── a00256.html
│ │ │ │ │ ├── a00257.html
│ │ │ │ │ ├── a00258.html
│ │ │ │ │ ├── a00259.html
│ │ │ │ │ ├── a00260.html
│ │ │ │ │ ├── a00261.html
│ │ │ │ │ ├── a00262.html
│ │ │ │ │ ├── a00263.html
│ │ │ │ │ ├── a00264.html
│ │ │ │ │ ├── a00265.html
│ │ │ │ │ ├── a00266.html
│ │ │ │ │ ├── a00267.html
│ │ │ │ │ ├── a00268.html
│ │ │ │ │ ├── a00269.html
│ │ │ │ │ ├── a00270.html
│ │ │ │ │ ├── a00271.html
│ │ │ │ │ ├── a00272.html
│ │ │ │ │ ├── a00273.html
│ │ │ │ │ ├── a00274.html
│ │ │ │ │ ├── a00275.html
│ │ │ │ │ ├── a00276.html
│ │ │ │ │ ├── a00277.html
│ │ │ │ │ ├── a00278.html
│ │ │ │ │ ├── a00279.html
│ │ │ │ │ ├── a00280.html
│ │ │ │ │ ├── a00281.html
│ │ │ │ │ ├── a00282.html
│ │ │ │ │ ├── a00283.html
│ │ │ │ │ ├── a00284.html
│ │ │ │ │ ├── a00285.html
│ │ │ │ │ ├── a00286.html
│ │ │ │ │ ├── a00287.html
│ │ │ │ │ ├── a00288.html
│ │ │ │ │ ├── a00289.html
│ │ │ │ │ ├── a00290.html
│ │ │ │ │ ├── a00291.html
│ │ │ │ │ ├── a00292.html
│ │ │ │ │ ├── a00293.html
│ │ │ │ │ ├── a00294.html
│ │ │ │ │ ├── a00295.html
│ │ │ │ │ ├── a00296.html
│ │ │ │ │ ├── a00297.html
│ │ │ │ │ ├── a00298.html
│ │ │ │ │ ├── a00299.html
│ │ │ │ │ ├── a00300.html
│ │ │ │ │ ├── a00301.html
│ │ │ │ │ ├── a00302.html
│ │ │ │ │ ├── a00303.html
│ │ │ │ │ ├── a00304.html
│ │ │ │ │ ├── a00305.html
│ │ │ │ │ ├── a00306.html
│ │ │ │ │ ├── a00307.html
│ │ │ │ │ ├── a00308.html
│ │ │ │ │ ├── a00309.html
│ │ │ │ │ ├── a00310.html
│ │ │ │ │ ├── a00311.html
│ │ │ │ │ ├── a00312.html
│ │ │ │ │ ├── a00313.html
│ │ │ │ │ ├── a00314.html
│ │ │ │ │ ├── a00315.html
│ │ │ │ │ ├── a00316.html
│ │ │ │ │ ├── a00317.html
│ │ │ │ │ ├── a00318.html
│ │ │ │ │ ├── a00319.html
│ │ │ │ │ ├── a00320.html
│ │ │ │ │ ├── a00321.html
│ │ │ │ │ ├── a00322.html
│ │ │ │ │ ├── a00323.html
│ │ │ │ │ ├── a00324.html
│ │ │ │ │ ├── a00325.html
│ │ │ │ │ ├── a00326.html
│ │ │ │ │ ├── a00327.html
│ │ │ │ │ ├── a00328.html
│ │ │ │ │ ├── a00329.html
│ │ │ │ │ ├── a00330.html
│ │ │ │ │ ├── a00331.html
│ │ │ │ │ ├── a00332.html
│ │ │ │ │ ├── a00333.html
│ │ │ │ │ ├── a00334.html
│ │ │ │ │ ├── a00335.html
│ │ │ │ │ ├── a00336.html
│ │ │ │ │ ├── a00337.html
│ │ │ │ │ ├── a00338.html
│ │ │ │ │ ├── a00339.html
│ │ │ │ │ ├── a00340.html
│ │ │ │ │ ├── a00341.html
│ │ │ │ │ ├── a00342.html
│ │ │ │ │ ├── a00343.html
│ │ │ │ │ ├── a00344.html
│ │ │ │ │ ├── a00345.html
│ │ │ │ │ ├── a00346.html
│ │ │ │ │ ├── a00347.html
│ │ │ │ │ ├── a00348.html
│ │ │ │ │ ├── a00349.html
│ │ │ │ │ ├── a00350.html
│ │ │ │ │ ├── a00351.html
│ │ │ │ │ ├── a00352.html
│ │ │ │ │ ├── a00353.html
│ │ │ │ │ ├── a00354.html
│ │ │ │ │ ├── a00355.html
│ │ │ │ │ ├── a00356.html
│ │ │ │ │ ├── a00357.html
│ │ │ │ │ ├── a00358.html
│ │ │ │ │ ├── a00359.html
│ │ │ │ │ ├── a00360.html
│ │ │ │ │ ├── a00361.html
│ │ │ │ │ ├── a00362.html
│ │ │ │ │ ├── a00363.html
│ │ │ │ │ ├── a00364.html
│ │ │ │ │ ├── a00365.html
│ │ │ │ │ ├── a00366.html
│ │ │ │ │ ├── a00367.html
│ │ │ │ │ ├── a00368.html
│ │ │ │ │ ├── a00369.html
│ │ │ │ │ ├── a00370.html
│ │ │ │ │ ├── a00371.html
│ │ │ │ │ ├── a00372.html
│ │ │ │ │ ├── a00373.html
│ │ │ │ │ ├── a00374.html
│ │ │ │ │ ├── dir_033f5edb0915b828d2c46ed4804e5503.html
│ │ │ │ │ ├── dir_3a581ba30d25676e4b797b1f96d53b45.html
│ │ │ │ │ ├── dir_44e5e654415abd9ca6fdeaddaff8565e.html
│ │ │ │ │ ├── dir_4c6bd29c73fa4e5a2509e1c15f846751.html
│ │ │ │ │ ├── dir_5189610d3ba09ec39b766fb99b34cd93.html
│ │ │ │ │ ├── dir_6b66465792d005310484819a0eb0b0d3.html
│ │ │ │ │ ├── dir_9e5fe034a00e89334fd5186c3e7db156.html
│ │ │ │ │ ├── dir_a8bee7be44182a33f3820393ae0b105d.html
│ │ │ │ │ ├── dir_cef2d71d502cb69a9252bca2297d9549.html
│ │ │ │ │ ├── dir_d9496f0844b48bc7e53b5af8c99b9ab2.html
│ │ │ │ │ ├── dir_f35778ec600a1b9bbc4524e62e226aa2.html
│ │ │ │ │ ├── doxygen.css
│ │ │ │ │ ├── dynsections.js
│ │ │ │ │ ├── files.html
│ │ │ │ │ ├── index.html
│ │ │ │ │ ├── jquery.js
│ │ │ │ │ ├── modules.html
│ │ │ │ │ ├── search/
│ │ │ │ │ │ ├── all_0.html
│ │ │ │ │ │ ├── all_0.js
│ │ │ │ │ │ ├── all_1.html
│ │ │ │ │ │ ├── all_1.js
│ │ │ │ │ │ ├── all_10.html
│ │ │ │ │ │ ├── all_10.js
│ │ │ │ │ │ ├── all_11.html
│ │ │ │ │ │ ├── all_11.js
│ │ │ │ │ │ ├── all_12.html
│ │ │ │ │ │ ├── all_12.js
│ │ │ │ │ │ ├── all_13.html
│ │ │ │ │ │ ├── all_13.js
│ │ │ │ │ │ ├── all_14.html
│ │ │ │ │ │ ├── all_14.js
│ │ │ │ │ │ ├── all_15.html
│ │ │ │ │ │ ├── all_15.js
│ │ │ │ │ │ ├── all_16.html
│ │ │ │ │ │ ├── all_16.js
│ │ │ │ │ │ ├── all_2.html
│ │ │ │ │ │ ├── all_2.js
│ │ │ │ │ │ ├── all_3.html
│ │ │ │ │ │ ├── all_3.js
│ │ │ │ │ │ ├── all_4.html
│ │ │ │ │ │ ├── all_4.js
│ │ │ │ │ │ ├── all_5.html
│ │ │ │ │ │ ├── all_5.js
│ │ │ │ │ │ ├── all_6.html
│ │ │ │ │ │ ├── all_6.js
│ │ │ │ │ │ ├── all_7.html
│ │ │ │ │ │ ├── all_7.js
│ │ │ │ │ │ ├── all_8.html
│ │ │ │ │ │ ├── all_8.js
│ │ │ │ │ │ ├── all_9.html
│ │ │ │ │ │ ├── all_9.js
│ │ │ │ │ │ ├── all_a.html
│ │ │ │ │ │ ├── all_a.js
│ │ │ │ │ │ ├── all_b.html
│ │ │ │ │ │ ├── all_b.js
│ │ │ │ │ │ ├── all_c.html
│ │ │ │ │ │ ├── all_c.js
│ │ │ │ │ │ ├── all_d.html
│ │ │ │ │ │ ├── all_d.js
│ │ │ │ │ │ ├── all_e.html
│ │ │ │ │ │ ├── all_e.js
│ │ │ │ │ │ ├── all_f.html
│ │ │ │ │ │ ├── all_f.js
│ │ │ │ │ │ ├── files_0.html
│ │ │ │ │ │ ├── files_0.js
│ │ │ │ │ │ ├── files_1.html
│ │ │ │ │ │ ├── files_1.js
│ │ │ │ │ │ ├── files_10.html
│ │ │ │ │ │ ├── files_10.js
│ │ │ │ │ │ ├── files_11.html
│ │ │ │ │ │ ├── files_11.js
│ │ │ │ │ │ ├── files_12.html
│ │ │ │ │ │ ├── files_12.js
│ │ │ │ │ │ ├── files_13.html
│ │ │ │ │ │ ├── files_13.js
│ │ │ │ │ │ ├── files_14.html
│ │ │ │ │ │ ├── files_14.js
│ │ │ │ │ │ ├── files_2.html
│ │ │ │ │ │ ├── files_2.js
│ │ │ │ │ │ ├── files_3.html
│ │ │ │ │ │ ├── files_3.js
│ │ │ │ │ │ ├── files_4.html
│ │ │ │ │ │ ├── files_4.js
│ │ │ │ │ │ ├── files_5.html
│ │ │ │ │ │ ├── files_5.js
│ │ │ │ │ │ ├── files_6.html
│ │ │ │ │ │ ├── files_6.js
│ │ │ │ │ │ ├── files_7.html
│ │ │ │ │ │ ├── files_7.js
│ │ │ │ │ │ ├── files_8.html
│ │ │ │ │ │ ├── files_8.js
│ │ │ │ │ │ ├── files_9.html
│ │ │ │ │ │ ├── files_9.js
│ │ │ │ │ │ ├── files_a.html
│ │ │ │ │ │ ├── files_a.js
│ │ │ │ │ │ ├── files_b.html
│ │ │ │ │ │ ├── files_b.js
│ │ │ │ │ │ ├── files_c.html
│ │ │ │ │ │ ├── files_c.js
│ │ │ │ │ │ ├── files_d.html
│ │ │ │ │ │ ├── files_d.js
│ │ │ │ │ │ ├── files_e.html
│ │ │ │ │ │ ├── files_e.js
│ │ │ │ │ │ ├── files_f.html
│ │ │ │ │ │ ├── files_f.js
│ │ │ │ │ │ ├── functions_0.html
│ │ │ │ │ │ ├── functions_0.js
│ │ │ │ │ │ ├── functions_1.html
│ │ │ │ │ │ ├── functions_1.js
│ │ │ │ │ │ ├── functions_10.html
│ │ │ │ │ │ ├── functions_10.js
│ │ │ │ │ │ ├── functions_11.html
│ │ │ │ │ │ ├── functions_11.js
│ │ │ │ │ │ ├── functions_12.html
│ │ │ │ │ │ ├── functions_12.js
│ │ │ │ │ │ ├── functions_13.html
│ │ │ │ │ │ ├── functions_13.js
│ │ │ │ │ │ ├── functions_14.html
│ │ │ │ │ │ ├── functions_14.js
│ │ │ │ │ │ ├── functions_15.html
│ │ │ │ │ │ ├── functions_15.js
│ │ │ │ │ │ ├── functions_16.html
│ │ │ │ │ │ ├── functions_16.js
│ │ │ │ │ │ ├── functions_2.html
│ │ │ │ │ │ ├── functions_2.js
│ │ │ │ │ │ ├── functions_3.html
│ │ │ │ │ │ ├── functions_3.js
│ │ │ │ │ │ ├── functions_4.html
│ │ │ │ │ │ ├── functions_4.js
│ │ │ │ │ │ ├── functions_5.html
│ │ │ │ │ │ ├── functions_5.js
│ │ │ │ │ │ ├── functions_6.html
│ │ │ │ │ │ ├── functions_6.js
│ │ │ │ │ │ ├── functions_7.html
│ │ │ │ │ │ ├── functions_7.js
│ │ │ │ │ │ ├── functions_8.html
│ │ │ │ │ │ ├── functions_8.js
│ │ │ │ │ │ ├── functions_9.html
│ │ │ │ │ │ ├── functions_9.js
│ │ │ │ │ │ ├── functions_a.html
│ │ │ │ │ │ ├── functions_a.js
│ │ │ │ │ │ ├── functions_b.html
│ │ │ │ │ │ ├── functions_b.js
│ │ │ │ │ │ ├── functions_c.html
│ │ │ │ │ │ ├── functions_c.js
│ │ │ │ │ │ ├── functions_d.html
│ │ │ │ │ │ ├── functions_d.js
│ │ │ │ │ │ ├── functions_e.html
│ │ │ │ │ │ ├── functions_e.js
│ │ │ │ │ │ ├── functions_f.html
│ │ │ │ │ │ ├── functions_f.js
│ │ │ │ │ │ ├── groups_0.html
│ │ │ │ │ │ ├── groups_0.js
│ │ │ │ │ │ ├── groups_1.html
│ │ │ │ │ │ ├── groups_1.js
│ │ │ │ │ │ ├── groups_2.html
│ │ │ │ │ │ ├── groups_2.js
│ │ │ │ │ │ ├── groups_3.html
│ │ │ │ │ │ ├── groups_3.js
│ │ │ │ │ │ ├── groups_4.html
│ │ │ │ │ │ ├── groups_4.js
│ │ │ │ │ │ ├── groups_5.html
│ │ │ │ │ │ ├── groups_5.js
│ │ │ │ │ │ ├── groups_6.html
│ │ │ │ │ │ ├── groups_6.js
│ │ │ │ │ │ ├── groups_7.html
│ │ │ │ │ │ ├── groups_7.js
│ │ │ │ │ │ ├── groups_8.html
│ │ │ │ │ │ ├── groups_8.js
│ │ │ │ │ │ ├── groups_9.html
│ │ │ │ │ │ ├── groups_9.js
│ │ │ │ │ │ ├── nomatches.html
│ │ │ │ │ │ ├── pages_0.html
│ │ │ │ │ │ ├── pages_0.js
│ │ │ │ │ │ ├── search.css
│ │ │ │ │ │ ├── search.js
│ │ │ │ │ │ ├── searchdata.js
│ │ │ │ │ │ ├── typedefs_0.html
│ │ │ │ │ │ ├── typedefs_0.js
│ │ │ │ │ │ ├── typedefs_1.html
│ │ │ │ │ │ ├── typedefs_1.js
│ │ │ │ │ │ ├── typedefs_2.html
│ │ │ │ │ │ ├── typedefs_2.js
│ │ │ │ │ │ ├── typedefs_3.html
│ │ │ │ │ │ ├── typedefs_3.js
│ │ │ │ │ │ ├── typedefs_4.html
│ │ │ │ │ │ ├── typedefs_4.js
│ │ │ │ │ │ ├── typedefs_5.html
│ │ │ │ │ │ ├── typedefs_5.js
│ │ │ │ │ │ ├── typedefs_6.html
│ │ │ │ │ │ ├── typedefs_6.js
│ │ │ │ │ │ ├── typedefs_7.html
│ │ │ │ │ │ ├── typedefs_7.js
│ │ │ │ │ │ ├── typedefs_8.html
│ │ │ │ │ │ ├── typedefs_8.js
│ │ │ │ │ │ ├── typedefs_9.html
│ │ │ │ │ │ ├── typedefs_9.js
│ │ │ │ │ │ ├── typedefs_a.html
│ │ │ │ │ │ ├── typedefs_a.js
│ │ │ │ │ │ ├── typedefs_b.html
│ │ │ │ │ │ ├── typedefs_b.js
│ │ │ │ │ │ ├── typedefs_c.html
│ │ │ │ │ │ ├── typedefs_c.js
│ │ │ │ │ │ ├── typedefs_d.html
│ │ │ │ │ │ └── typedefs_d.js
│ │ │ │ │ └── tabs.css
│ │ │ │ ├── man.doxy
│ │ │ │ └── theme/
│ │ │ │ └── doxygen.css
│ │ │ ├── glm/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── common.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ ├── _features.hpp
│ │ │ │ │ ├── _fixes.hpp
│ │ │ │ │ ├── _noise.hpp
│ │ │ │ │ ├── _swizzle.hpp
│ │ │ │ │ ├── _swizzle_func.hpp
│ │ │ │ │ ├── _vectorize.hpp
│ │ │ │ │ ├── compute_common.hpp
│ │ │ │ │ ├── compute_vector_relational.hpp
│ │ │ │ │ ├── func_common.inl
│ │ │ │ │ ├── func_common_simd.inl
│ │ │ │ │ ├── func_exponential.inl
│ │ │ │ │ ├── func_exponential_simd.inl
│ │ │ │ │ ├── func_geometric.inl
│ │ │ │ │ ├── func_geometric_simd.inl
│ │ │ │ │ ├── func_integer.inl
│ │ │ │ │ ├── func_integer_simd.inl
│ │ │ │ │ ├── func_matrix.inl
│ │ │ │ │ ├── func_matrix_simd.inl
│ │ │ │ │ ├── func_packing.inl
│ │ │ │ │ ├── func_packing_simd.inl
│ │ │ │ │ ├── func_trigonometric.inl
│ │ │ │ │ ├── func_trigonometric_simd.inl
│ │ │ │ │ ├── func_vector_relational.inl
│ │ │ │ │ ├── func_vector_relational_simd.inl
│ │ │ │ │ ├── glm.cpp
│ │ │ │ │ ├── qualifier.hpp
│ │ │ │ │ ├── setup.hpp
│ │ │ │ │ ├── type_float.hpp
│ │ │ │ │ ├── type_half.hpp
│ │ │ │ │ ├── type_half.inl
│ │ │ │ │ ├── type_mat2x2.hpp
│ │ │ │ │ ├── type_mat2x2.inl
│ │ │ │ │ ├── type_mat2x3.hpp
│ │ │ │ │ ├── type_mat2x3.inl
│ │ │ │ │ ├── type_mat2x4.hpp
│ │ │ │ │ ├── type_mat2x4.inl
│ │ │ │ │ ├── type_mat3x2.hpp
│ │ │ │ │ ├── type_mat3x2.inl
│ │ │ │ │ ├── type_mat3x3.hpp
│ │ │ │ │ ├── type_mat3x3.inl
│ │ │ │ │ ├── type_mat3x4.hpp
│ │ │ │ │ ├── type_mat3x4.inl
│ │ │ │ │ ├── type_mat4x2.hpp
│ │ │ │ │ ├── type_mat4x2.inl
│ │ │ │ │ ├── type_mat4x3.hpp
│ │ │ │ │ ├── type_mat4x3.inl
│ │ │ │ │ ├── type_mat4x4.hpp
│ │ │ │ │ ├── type_mat4x4.inl
│ │ │ │ │ ├── type_mat4x4_simd.inl
│ │ │ │ │ ├── type_quat.hpp
│ │ │ │ │ ├── type_quat.inl
│ │ │ │ │ ├── type_quat_simd.inl
│ │ │ │ │ ├── type_vec1.hpp
│ │ │ │ │ ├── type_vec1.inl
│ │ │ │ │ ├── type_vec2.hpp
│ │ │ │ │ ├── type_vec2.inl
│ │ │ │ │ ├── type_vec3.hpp
│ │ │ │ │ ├── type_vec3.inl
│ │ │ │ │ ├── type_vec4.hpp
│ │ │ │ │ ├── type_vec4.inl
│ │ │ │ │ └── type_vec4_simd.inl
│ │ │ │ ├── exponential.hpp
│ │ │ │ ├── ext/
│ │ │ │ │ ├── _matrix_vectorize.hpp
│ │ │ │ │ ├── matrix_clip_space.hpp
│ │ │ │ │ ├── matrix_clip_space.inl
│ │ │ │ │ ├── matrix_common.hpp
│ │ │ │ │ ├── matrix_common.inl
│ │ │ │ │ ├── matrix_double2x2.hpp
│ │ │ │ │ ├── matrix_double2x2_precision.hpp
│ │ │ │ │ ├── matrix_double2x3.hpp
│ │ │ │ │ ├── matrix_double2x3_precision.hpp
│ │ │ │ │ ├── matrix_double2x4.hpp
│ │ │ │ │ ├── matrix_double2x4_precision.hpp
│ │ │ │ │ ├── matrix_double3x2.hpp
│ │ │ │ │ ├── matrix_double3x2_precision.hpp
│ │ │ │ │ ├── matrix_double3x3.hpp
│ │ │ │ │ ├── matrix_double3x3_precision.hpp
│ │ │ │ │ ├── matrix_double3x4.hpp
│ │ │ │ │ ├── matrix_double3x4_precision.hpp
│ │ │ │ │ ├── matrix_double4x2.hpp
│ │ │ │ │ ├── matrix_double4x2_precision.hpp
│ │ │ │ │ ├── matrix_double4x3.hpp
│ │ │ │ │ ├── matrix_double4x3_precision.hpp
│ │ │ │ │ ├── matrix_double4x4.hpp
│ │ │ │ │ ├── matrix_double4x4_precision.hpp
│ │ │ │ │ ├── matrix_float2x2.hpp
│ │ │ │ │ ├── matrix_float2x2_precision.hpp
│ │ │ │ │ ├── matrix_float2x3.hpp
│ │ │ │ │ ├── matrix_float2x3_precision.hpp
│ │ │ │ │ ├── matrix_float2x4.hpp
│ │ │ │ │ ├── matrix_float2x4_precision.hpp
│ │ │ │ │ ├── matrix_float3x2.hpp
│ │ │ │ │ ├── matrix_float3x2_precision.hpp
│ │ │ │ │ ├── matrix_float3x3.hpp
│ │ │ │ │ ├── matrix_float3x3_precision.hpp
│ │ │ │ │ ├── matrix_float3x4.hpp
│ │ │ │ │ ├── matrix_float3x4_precision.hpp
│ │ │ │ │ ├── matrix_float4x2.hpp
│ │ │ │ │ ├── matrix_float4x2_precision.hpp
│ │ │ │ │ ├── matrix_float4x3.hpp
│ │ │ │ │ ├── matrix_float4x3_precision.hpp
│ │ │ │ │ ├── matrix_float4x4.hpp
│ │ │ │ │ ├── matrix_float4x4_precision.hpp
│ │ │ │ │ ├── matrix_int2x2.hpp
│ │ │ │ │ ├── matrix_int2x2_sized.hpp
│ │ │ │ │ ├── matrix_int2x3.hpp
│ │ │ │ │ ├── matrix_int2x3_sized.hpp
│ │ │ │ │ ├── matrix_int2x4.hpp
│ │ │ │ │ ├── matrix_int2x4_sized.hpp
│ │ │ │ │ ├── matrix_int3x2.hpp
│ │ │ │ │ ├── matrix_int3x2_sized.hpp
│ │ │ │ │ ├── matrix_int3x3.hpp
│ │ │ │ │ ├── matrix_int3x3_sized.hpp
│ │ │ │ │ ├── matrix_int3x4.hpp
│ │ │ │ │ ├── matrix_int3x4_sized.hpp
│ │ │ │ │ ├── matrix_int4x2.hpp
│ │ │ │ │ ├── matrix_int4x2_sized.hpp
│ │ │ │ │ ├── matrix_int4x3.hpp
│ │ │ │ │ ├── matrix_int4x3_sized.hpp
│ │ │ │ │ ├── matrix_int4x4.hpp
│ │ │ │ │ ├── matrix_int4x4_sized.hpp
│ │ │ │ │ ├── matrix_integer.hpp
│ │ │ │ │ ├── matrix_integer.inl
│ │ │ │ │ ├── matrix_projection.hpp
│ │ │ │ │ ├── matrix_projection.inl
│ │ │ │ │ ├── matrix_relational.hpp
│ │ │ │ │ ├── matrix_relational.inl
│ │ │ │ │ ├── matrix_transform.hpp
│ │ │ │ │ ├── matrix_transform.inl
│ │ │ │ │ ├── matrix_uint2x2.hpp
│ │ │ │ │ ├── matrix_uint2x2_sized.hpp
│ │ │ │ │ ├── matrix_uint2x3.hpp
│ │ │ │ │ ├── matrix_uint2x3_sized.hpp
│ │ │ │ │ ├── matrix_uint2x4.hpp
│ │ │ │ │ ├── matrix_uint2x4_sized.hpp
│ │ │ │ │ ├── matrix_uint3x2.hpp
│ │ │ │ │ ├── matrix_uint3x2_sized.hpp
│ │ │ │ │ ├── matrix_uint3x3.hpp
│ │ │ │ │ ├── matrix_uint3x3_sized.hpp
│ │ │ │ │ ├── matrix_uint3x4.hpp
│ │ │ │ │ ├── matrix_uint3x4_sized.hpp
│ │ │ │ │ ├── matrix_uint4x2.hpp
│ │ │ │ │ ├── matrix_uint4x2_sized.hpp
│ │ │ │ │ ├── matrix_uint4x3.hpp
│ │ │ │ │ ├── matrix_uint4x3_sized.hpp
│ │ │ │ │ ├── matrix_uint4x4.hpp
│ │ │ │ │ ├── matrix_uint4x4_sized.hpp
│ │ │ │ │ ├── quaternion_common.hpp
│ │ │ │ │ ├── quaternion_common.inl
│ │ │ │ │ ├── quaternion_common_simd.inl
│ │ │ │ │ ├── quaternion_double.hpp
│ │ │ │ │ ├── quaternion_double_precision.hpp
│ │ │ │ │ ├── quaternion_exponential.hpp
│ │ │ │ │ ├── quaternion_exponential.inl
│ │ │ │ │ ├── quaternion_float.hpp
│ │ │ │ │ ├── quaternion_float_precision.hpp
│ │ │ │ │ ├── quaternion_geometric.hpp
│ │ │ │ │ ├── quaternion_geometric.inl
│ │ │ │ │ ├── quaternion_relational.hpp
│ │ │ │ │ ├── quaternion_relational.inl
│ │ │ │ │ ├── quaternion_transform.hpp
│ │ │ │ │ ├── quaternion_transform.inl
│ │ │ │ │ ├── quaternion_trigonometric.hpp
│ │ │ │ │ ├── quaternion_trigonometric.inl
│ │ │ │ │ ├── scalar_common.hpp
│ │ │ │ │ ├── scalar_common.inl
│ │ │ │ │ ├── scalar_constants.hpp
│ │ │ │ │ ├── scalar_constants.inl
│ │ │ │ │ ├── scalar_int_sized.hpp
│ │ │ │ │ ├── scalar_integer.hpp
│ │ │ │ │ ├── scalar_integer.inl
│ │ │ │ │ ├── scalar_packing.hpp
│ │ │ │ │ ├── scalar_packing.inl
│ │ │ │ │ ├── scalar_reciprocal.hpp
│ │ │ │ │ ├── scalar_reciprocal.inl
│ │ │ │ │ ├── scalar_relational.hpp
│ │ │ │ │ ├── scalar_relational.inl
│ │ │ │ │ ├── scalar_uint_sized.hpp
│ │ │ │ │ ├── scalar_ulp.hpp
│ │ │ │ │ ├── scalar_ulp.inl
│ │ │ │ │ ├── vector_bool1.hpp
│ │ │ │ │ ├── vector_bool1_precision.hpp
│ │ │ │ │ ├── vector_bool2.hpp
│ │ │ │ │ ├── vector_bool2_precision.hpp
│ │ │ │ │ ├── vector_bool3.hpp
│ │ │ │ │ ├── vector_bool3_precision.hpp
│ │ │ │ │ ├── vector_bool4.hpp
│ │ │ │ │ ├── vector_bool4_precision.hpp
│ │ │ │ │ ├── vector_common.hpp
│ │ │ │ │ ├── vector_common.inl
│ │ │ │ │ ├── vector_double1.hpp
│ │ │ │ │ ├── vector_double1_precision.hpp
│ │ │ │ │ ├── vector_double2.hpp
│ │ │ │ │ ├── vector_double2_precision.hpp
│ │ │ │ │ ├── vector_double3.hpp
│ │ │ │ │ ├── vector_double3_precision.hpp
│ │ │ │ │ ├── vector_double4.hpp
│ │ │ │ │ ├── vector_double4_precision.hpp
│ │ │ │ │ ├── vector_float1.hpp
│ │ │ │ │ ├── vector_float1_precision.hpp
│ │ │ │ │ ├── vector_float2.hpp
│ │ │ │ │ ├── vector_float2_precision.hpp
│ │ │ │ │ ├── vector_float3.hpp
│ │ │ │ │ ├── vector_float3_precision.hpp
│ │ │ │ │ ├── vector_float4.hpp
│ │ │ │ │ ├── vector_float4_precision.hpp
│ │ │ │ │ ├── vector_int1.hpp
│ │ │ │ │ ├── vector_int1_sized.hpp
│ │ │ │ │ ├── vector_int2.hpp
│ │ │ │ │ ├── vector_int2_sized.hpp
│ │ │ │ │ ├── vector_int3.hpp
│ │ │ │ │ ├── vector_int3_sized.hpp
│ │ │ │ │ ├── vector_int4.hpp
│ │ │ │ │ ├── vector_int4_sized.hpp
│ │ │ │ │ ├── vector_integer.hpp
│ │ │ │ │ ├── vector_integer.inl
│ │ │ │ │ ├── vector_packing.hpp
│ │ │ │ │ ├── vector_packing.inl
│ │ │ │ │ ├── vector_reciprocal.hpp
│ │ │ │ │ ├── vector_reciprocal.inl
│ │ │ │ │ ├── vector_relational.hpp
│ │ │ │ │ ├── vector_relational.inl
│ │ │ │ │ ├── vector_uint1.hpp
│ │ │ │ │ ├── vector_uint1_sized.hpp
│ │ │ │ │ ├── vector_uint2.hpp
│ │ │ │ │ ├── vector_uint2_sized.hpp
│ │ │ │ │ ├── vector_uint3.hpp
│ │ │ │ │ ├── vector_uint3_sized.hpp
│ │ │ │ │ ├── vector_uint4.hpp
│ │ │ │ │ ├── vector_uint4_sized.hpp
│ │ │ │ │ ├── vector_ulp.hpp
│ │ │ │ │ └── vector_ulp.inl
│ │ │ │ ├── ext.hpp
│ │ │ │ ├── fwd.hpp
│ │ │ │ ├── geometric.hpp
│ │ │ │ ├── glm.hpp
│ │ │ │ ├── gtc/
│ │ │ │ │ ├── bitfield.hpp
│ │ │ │ │ ├── bitfield.inl
│ │ │ │ │ ├── color_space.hpp
│ │ │ │ │ ├── color_space.inl
│ │ │ │ │ ├── constants.hpp
│ │ │ │ │ ├── constants.inl
│ │ │ │ │ ├── epsilon.hpp
│ │ │ │ │ ├── epsilon.inl
│ │ │ │ │ ├── integer.hpp
│ │ │ │ │ ├── integer.inl
│ │ │ │ │ ├── matrix_access.hpp
│ │ │ │ │ ├── matrix_access.inl
│ │ │ │ │ ├── matrix_integer.hpp
│ │ │ │ │ ├── matrix_inverse.hpp
│ │ │ │ │ ├── matrix_inverse.inl
│ │ │ │ │ ├── matrix_transform.hpp
│ │ │ │ │ ├── matrix_transform.inl
│ │ │ │ │ ├── noise.hpp
│ │ │ │ │ ├── noise.inl
│ │ │ │ │ ├── packing.hpp
│ │ │ │ │ ├── packing.inl
│ │ │ │ │ ├── quaternion.hpp
│ │ │ │ │ ├── quaternion.inl
│ │ │ │ │ ├── quaternion_simd.inl
│ │ │ │ │ ├── random.hpp
│ │ │ │ │ ├── random.inl
│ │ │ │ │ ├── reciprocal.hpp
│ │ │ │ │ ├── round.hpp
│ │ │ │ │ ├── round.inl
│ │ │ │ │ ├── type_aligned.hpp
│ │ │ │ │ ├── type_precision.hpp
│ │ │ │ │ ├── type_precision.inl
│ │ │ │ │ ├── type_ptr.hpp
│ │ │ │ │ ├── type_ptr.inl
│ │ │ │ │ ├── ulp.hpp
│ │ │ │ │ ├── ulp.inl
│ │ │ │ │ └── vec1.hpp
│ │ │ │ ├── gtx/
│ │ │ │ │ ├── associated_min_max.hpp
│ │ │ │ │ ├── associated_min_max.inl
│ │ │ │ │ ├── bit.hpp
│ │ │ │ │ ├── bit.inl
│ │ │ │ │ ├── closest_point.hpp
│ │ │ │ │ ├── closest_point.inl
│ │ │ │ │ ├── color_encoding.hpp
│ │ │ │ │ ├── color_encoding.inl
│ │ │ │ │ ├── color_space.hpp
│ │ │ │ │ ├── color_space.inl
│ │ │ │ │ ├── color_space_YCoCg.hpp
│ │ │ │ │ ├── color_space_YCoCg.inl
│ │ │ │ │ ├── common.hpp
│ │ │ │ │ ├── common.inl
│ │ │ │ │ ├── compatibility.hpp
│ │ │ │ │ ├── compatibility.inl
│ │ │ │ │ ├── component_wise.hpp
│ │ │ │ │ ├── component_wise.inl
│ │ │ │ │ ├── dual_quaternion.hpp
│ │ │ │ │ ├── dual_quaternion.inl
│ │ │ │ │ ├── easing.hpp
│ │ │ │ │ ├── easing.inl
│ │ │ │ │ ├── euler_angles.hpp
│ │ │ │ │ ├── euler_angles.inl
│ │ │ │ │ ├── extend.hpp
│ │ │ │ │ ├── extend.inl
│ │ │ │ │ ├── extended_min_max.hpp
│ │ │ │ │ ├── extended_min_max.inl
│ │ │ │ │ ├── exterior_product.hpp
│ │ │ │ │ ├── exterior_product.inl
│ │ │ │ │ ├── fast_exponential.hpp
│ │ │ │ │ ├── fast_exponential.inl
│ │ │ │ │ ├── fast_square_root.hpp
│ │ │ │ │ ├── fast_square_root.inl
│ │ │ │ │ ├── fast_trigonometry.hpp
│ │ │ │ │ ├── fast_trigonometry.inl
│ │ │ │ │ ├── float_notmalize.inl
│ │ │ │ │ ├── functions.hpp
│ │ │ │ │ ├── functions.inl
│ │ │ │ │ ├── gradient_paint.hpp
│ │ │ │ │ ├── gradient_paint.inl
│ │ │ │ │ ├── handed_coordinate_space.hpp
│ │ │ │ │ ├── handed_coordinate_space.inl
│ │ │ │ │ ├── hash.hpp
│ │ │ │ │ ├── hash.inl
│ │ │ │ │ ├── integer.hpp
│ │ │ │ │ ├── integer.inl
│ │ │ │ │ ├── intersect.hpp
│ │ │ │ │ ├── intersect.inl
│ │ │ │ │ ├── io.hpp
│ │ │ │ │ ├── io.inl
│ │ │ │ │ ├── log_base.hpp
│ │ │ │ │ ├── log_base.inl
│ │ │ │ │ ├── matrix_cross_product.hpp
│ │ │ │ │ ├── matrix_cross_product.inl
│ │ │ │ │ ├── matrix_decompose.hpp
│ │ │ │ │ ├── matrix_decompose.inl
│ │ │ │ │ ├── matrix_factorisation.hpp
│ │ │ │ │ ├── matrix_factorisation.inl
│ │ │ │ │ ├── matrix_interpolation.hpp
│ │ │ │ │ ├── matrix_interpolation.inl
│ │ │ │ │ ├── matrix_major_storage.hpp
│ │ │ │ │ ├── matrix_major_storage.inl
│ │ │ │ │ ├── matrix_operation.hpp
│ │ │ │ │ ├── matrix_operation.inl
│ │ │ │ │ ├── matrix_query.hpp
│ │ │ │ │ ├── matrix_query.inl
│ │ │ │ │ ├── matrix_transform_2d.hpp
│ │ │ │ │ ├── matrix_transform_2d.inl
│ │ │ │ │ ├── mixed_product.hpp
│ │ │ │ │ ├── mixed_product.inl
│ │ │ │ │ ├── norm.hpp
│ │ │ │ │ ├── norm.inl
│ │ │ │ │ ├── normal.hpp
│ │ │ │ │ ├── normal.inl
│ │ │ │ │ ├── normalize_dot.hpp
│ │ │ │ │ ├── normalize_dot.inl
│ │ │ │ │ ├── number_precision.hpp
│ │ │ │ │ ├── number_precision.inl
│ │ │ │ │ ├── optimum_pow.hpp
│ │ │ │ │ ├── optimum_pow.inl
│ │ │ │ │ ├── orthonormalize.hpp
│ │ │ │ │ ├── orthonormalize.inl
│ │ │ │ │ ├── pca.hpp
│ │ │ │ │ ├── pca.inl
│ │ │ │ │ ├── perpendicular.hpp
│ │ │ │ │ ├── perpendicular.inl
│ │ │ │ │ ├── polar_coordinates.hpp
│ │ │ │ │ ├── polar_coordinates.inl
│ │ │ │ │ ├── projection.hpp
│ │ │ │ │ ├── projection.inl
│ │ │ │ │ ├── quaternion.hpp
│ │ │ │ │ ├── quaternion.inl
│ │ │ │ │ ├── range.hpp
│ │ │ │ │ ├── raw_data.hpp
│ │ │ │ │ ├── raw_data.inl
│ │ │ │ │ ├── rotate_normalized_axis.hpp
│ │ │ │ │ ├── rotate_normalized_axis.inl
│ │ │ │ │ ├── rotate_vector.hpp
│ │ │ │ │ ├── rotate_vector.inl
│ │ │ │ │ ├── scalar_multiplication.hpp
│ │ │ │ │ ├── scalar_relational.hpp
│ │ │ │ │ ├── scalar_relational.inl
│ │ │ │ │ ├── spline.hpp
│ │ │ │ │ ├── spline.inl
│ │ │ │ │ ├── std_based_type.hpp
│ │ │ │ │ ├── std_based_type.inl
│ │ │ │ │ ├── string_cast.hpp
│ │ │ │ │ ├── string_cast.inl
│ │ │ │ │ ├── texture.hpp
│ │ │ │ │ ├── texture.inl
│ │ │ │ │ ├── transform.hpp
│ │ │ │ │ ├── transform.inl
│ │ │ │ │ ├── transform2.hpp
│ │ │ │ │ ├── transform2.inl
│ │ │ │ │ ├── type_aligned.hpp
│ │ │ │ │ ├── type_aligned.inl
│ │ │ │ │ ├── type_trait.hpp
│ │ │ │ │ ├── type_trait.inl
│ │ │ │ │ ├── vec_swizzle.hpp
│ │ │ │ │ ├── vector_angle.hpp
│ │ │ │ │ ├── vector_angle.inl
│ │ │ │ │ ├── vector_query.hpp
│ │ │ │ │ ├── vector_query.inl
│ │ │ │ │ ├── wrap.hpp
│ │ │ │ │ └── wrap.inl
│ │ │ │ ├── integer.hpp
│ │ │ │ ├── mat2x2.hpp
│ │ │ │ ├── mat2x3.hpp
│ │ │ │ ├── mat2x4.hpp
│ │ │ │ ├── mat3x2.hpp
│ │ │ │ ├── mat3x3.hpp
│ │ │ │ ├── mat3x4.hpp
│ │ │ │ ├── mat4x2.hpp
│ │ │ │ ├── mat4x3.hpp
│ │ │ │ ├── mat4x4.hpp
│ │ │ │ ├── matrix.hpp
│ │ │ │ ├── packing.hpp
│ │ │ │ ├── simd/
│ │ │ │ │ ├── common.h
│ │ │ │ │ ├── exponential.h
│ │ │ │ │ ├── geometric.h
│ │ │ │ │ ├── integer.h
│ │ │ │ │ ├── matrix.h
│ │ │ │ │ ├── neon.h
│ │ │ │ │ ├── packing.h
│ │ │ │ │ ├── platform.h
│ │ │ │ │ ├── trigonometric.h
│ │ │ │ │ └── vector_relational.h
│ │ │ │ ├── trigonometric.hpp
│ │ │ │ ├── vec2.hpp
│ │ │ │ ├── vec3.hpp
│ │ │ │ ├── vec4.hpp
│ │ │ │ └── vector_relational.hpp
│ │ │ ├── manual.md
│ │ │ ├── readme.md
│ │ │ ├── test/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── bug/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ └── bug_ms_vec_static.cpp
│ │ │ │ ├── cmake/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ └── test_find_glm.cpp
│ │ │ │ ├── core/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── core_cpp_constexpr.cpp
│ │ │ │ │ ├── core_cpp_defaulted_ctor.cpp
│ │ │ │ │ ├── core_force_aligned_gentypes.cpp
│ │ │ │ │ ├── core_force_arch_unknown.cpp
│ │ │ │ │ ├── core_force_compiler_unknown.cpp
│ │ │ │ │ ├── core_force_ctor_init.cpp
│ │ │ │ │ ├── core_force_cxx03.cpp
│ │ │ │ │ ├── core_force_cxx98.cpp
│ │ │ │ │ ├── core_force_cxx_unknown.cpp
│ │ │ │ │ ├── core_force_depth_zero_to_one.cpp
│ │ │ │ │ ├── core_force_explicit_ctor.cpp
│ │ │ │ │ ├── core_force_inline.cpp
│ │ │ │ │ ├── core_force_left_handed.cpp
│ │ │ │ │ ├── core_force_platform_unknown.cpp
│ │ │ │ │ ├── core_force_pure.cpp
│ │ │ │ │ ├── core_force_quat_xyzw.cpp
│ │ │ │ │ ├── core_force_size_t_length.cpp
│ │ │ │ │ ├── core_force_unrestricted_gentype.cpp
│ │ │ │ │ ├── core_force_xyzw_only.cpp
│ │ │ │ │ ├── core_func_common.cpp
│ │ │ │ │ ├── core_func_exponential.cpp
│ │ │ │ │ ├── core_func_geometric.cpp
│ │ │ │ │ ├── core_func_integer.cpp
│ │ │ │ │ ├── core_func_integer_bit_count.cpp
│ │ │ │ │ ├── core_func_integer_find_lsb.cpp
│ │ │ │ │ ├── core_func_integer_find_msb.cpp
│ │ │ │ │ ├── core_func_matrix.cpp
│ │ │ │ │ ├── core_func_noise.cpp
│ │ │ │ │ ├── core_func_packing.cpp
│ │ │ │ │ ├── core_func_swizzle.cpp
│ │ │ │ │ ├── core_func_trigonometric.cpp
│ │ │ │ │ ├── core_func_vector_relational.cpp
│ │ │ │ │ ├── core_setup_force_cxx98.cpp
│ │ │ │ │ ├── core_setup_force_size_t_length.cpp
│ │ │ │ │ ├── core_setup_message.cpp
│ │ │ │ │ ├── core_setup_platform_unknown.cpp
│ │ │ │ │ ├── core_setup_precision.cpp
│ │ │ │ │ ├── core_type_aligned.cpp
│ │ │ │ │ ├── core_type_cast.cpp
│ │ │ │ │ ├── core_type_ctor.cpp
│ │ │ │ │ ├── core_type_int.cpp
│ │ │ │ │ ├── core_type_length.cpp
│ │ │ │ │ ├── core_type_mat2x2.cpp
│ │ │ │ │ ├── core_type_mat2x3.cpp
│ │ │ │ │ ├── core_type_mat2x4.cpp
│ │ │ │ │ ├── core_type_mat3x2.cpp
│ │ │ │ │ ├── core_type_mat3x3.cpp
│ │ │ │ │ ├── core_type_mat3x4.cpp
│ │ │ │ │ ├── core_type_mat4x2.cpp
│ │ │ │ │ ├── core_type_mat4x3.cpp
│ │ │ │ │ ├── core_type_mat4x4.cpp
│ │ │ │ │ ├── core_type_vec1.cpp
│ │ │ │ │ ├── core_type_vec2.cpp
│ │ │ │ │ ├── core_type_vec3.cpp
│ │ │ │ │ └── core_type_vec4.cpp
│ │ │ │ ├── ext/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── ext_matrix_clip_space.cpp
│ │ │ │ │ ├── ext_matrix_common.cpp
│ │ │ │ │ ├── ext_matrix_int2x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_int2x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_int2x4_sized.cpp
│ │ │ │ │ ├── ext_matrix_int3x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_int3x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_int3x4_sized.cpp
│ │ │ │ │ ├── ext_matrix_int4x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_int4x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_int4x4_sized.cpp
│ │ │ │ │ ├── ext_matrix_integer.cpp
│ │ │ │ │ ├── ext_matrix_projection.cpp
│ │ │ │ │ ├── ext_matrix_relational.cpp
│ │ │ │ │ ├── ext_matrix_transform.cpp
│ │ │ │ │ ├── ext_matrix_uint2x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint2x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint2x4_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint3x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint3x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint3x4_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint4x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint4x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint4x4_sized.cpp
│ │ │ │ │ ├── ext_quaternion_common.cpp
│ │ │ │ │ ├── ext_quaternion_exponential.cpp
│ │ │ │ │ ├── ext_quaternion_geometric.cpp
│ │ │ │ │ ├── ext_quaternion_relational.cpp
│ │ │ │ │ ├── ext_quaternion_transform.cpp
│ │ │ │ │ ├── ext_quaternion_trigonometric.cpp
│ │ │ │ │ ├── ext_quaternion_type.cpp
│ │ │ │ │ ├── ext_scalar_common.cpp
│ │ │ │ │ ├── ext_scalar_constants.cpp
│ │ │ │ │ ├── ext_scalar_int_sized.cpp
│ │ │ │ │ ├── ext_scalar_integer.cpp
│ │ │ │ │ ├── ext_scalar_packing.cpp
│ │ │ │ │ ├── ext_scalar_reciprocal.cpp
│ │ │ │ │ ├── ext_scalar_relational.cpp
│ │ │ │ │ ├── ext_scalar_uint_sized.cpp
│ │ │ │ │ ├── ext_scalar_ulp.cpp
│ │ │ │ │ ├── ext_vec1.cpp
│ │ │ │ │ ├── ext_vector_bool1.cpp
│ │ │ │ │ ├── ext_vector_common.cpp
│ │ │ │ │ ├── ext_vector_iec559.cpp
│ │ │ │ │ ├── ext_vector_int1_sized.cpp
│ │ │ │ │ ├── ext_vector_int2_sized.cpp
│ │ │ │ │ ├── ext_vector_int3_sized.cpp
│ │ │ │ │ ├── ext_vector_int4_sized.cpp
│ │ │ │ │ ├── ext_vector_integer.cpp
│ │ │ │ │ ├── ext_vector_integer_sized.cpp
│ │ │ │ │ ├── ext_vector_packing.cpp
│ │ │ │ │ ├── ext_vector_reciprocal.cpp
│ │ │ │ │ ├── ext_vector_relational.cpp
│ │ │ │ │ ├── ext_vector_uint1_sized.cpp
│ │ │ │ │ ├── ext_vector_uint2_sized.cpp
│ │ │ │ │ ├── ext_vector_uint3_sized.cpp
│ │ │ │ │ ├── ext_vector_uint4_sized.cpp
│ │ │ │ │ └── ext_vector_ulp.cpp
│ │ │ │ ├── glm.cppcheck
│ │ │ │ ├── gtc/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── gtc_bitfield.cpp
│ │ │ │ │ ├── gtc_color_space.cpp
│ │ │ │ │ ├── gtc_constants.cpp
│ │ │ │ │ ├── gtc_epsilon.cpp
│ │ │ │ │ ├── gtc_integer.cpp
│ │ │ │ │ ├── gtc_matrix_access.cpp
│ │ │ │ │ ├── gtc_matrix_integer.cpp
│ │ │ │ │ ├── gtc_matrix_inverse.cpp
│ │ │ │ │ ├── gtc_matrix_transform.cpp
│ │ │ │ │ ├── gtc_noise.cpp
│ │ │ │ │ ├── gtc_packing.cpp
│ │ │ │ │ ├── gtc_quaternion.cpp
│ │ │ │ │ ├── gtc_random.cpp
│ │ │ │ │ ├── gtc_reciprocal.cpp
│ │ │ │ │ ├── gtc_round.cpp
│ │ │ │ │ ├── gtc_type_aligned.cpp
│ │ │ │ │ ├── gtc_type_precision.cpp
│ │ │ │ │ ├── gtc_type_ptr.cpp
│ │ │ │ │ ├── gtc_ulp.cpp
│ │ │ │ │ ├── gtc_user_defined_types.cpp
│ │ │ │ │ └── gtc_vec1.cpp
│ │ │ │ ├── gtx/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── gtx.cpp
│ │ │ │ │ ├── gtx_associated_min_max.cpp
│ │ │ │ │ ├── gtx_closest_point.cpp
│ │ │ │ │ ├── gtx_color_encoding.cpp
│ │ │ │ │ ├── gtx_color_space.cpp
│ │ │ │ │ ├── gtx_color_space_YCoCg.cpp
│ │ │ │ │ ├── gtx_common.cpp
│ │ │ │ │ ├── gtx_compatibility.cpp
│ │ │ │ │ ├── gtx_component_wise.cpp
│ │ │ │ │ ├── gtx_dual_quaternion.cpp
│ │ │ │ │ ├── gtx_easing.cpp
│ │ │ │ │ ├── gtx_euler_angle.cpp
│ │ │ │ │ ├── gtx_extend.cpp
│ │ │ │ │ ├── gtx_extended_min_max.cpp
│ │ │ │ │ ├── gtx_extented_min_max.cpp
│ │ │ │ │ ├── gtx_exterior_product.cpp
│ │ │ │ │ ├── gtx_fast_exponential.cpp
│ │ │ │ │ ├── gtx_fast_square_root.cpp
│ │ │ │ │ ├── gtx_fast_trigonometry.cpp
│ │ │ │ │ ├── gtx_functions.cpp
│ │ │ │ │ ├── gtx_gradient_paint.cpp
│ │ │ │ │ ├── gtx_handed_coordinate_space.cpp
│ │ │ │ │ ├── gtx_hash.cpp
│ │ │ │ │ ├── gtx_int_10_10_10_2.cpp
│ │ │ │ │ ├── gtx_integer.cpp
│ │ │ │ │ ├── gtx_intersect.cpp
│ │ │ │ │ ├── gtx_io.cpp
│ │ │ │ │ ├── gtx_load.cpp
│ │ │ │ │ ├── gtx_log_base.cpp
│ │ │ │ │ ├── gtx_matrix_cross_product.cpp
│ │ │ │ │ ├── gtx_matrix_decompose.cpp
│ │ │ │ │ ├── gtx_matrix_factorisation.cpp
│ │ │ │ │ ├── gtx_matrix_interpolation.cpp
│ │ │ │ │ ├── gtx_matrix_major_storage.cpp
│ │ │ │ │ ├── gtx_matrix_operation.cpp
│ │ │ │ │ ├── gtx_matrix_query.cpp
│ │ │ │ │ ├── gtx_matrix_transform_2d.cpp
│ │ │ │ │ ├── gtx_mixed_product.cpp
│ │ │ │ │ ├── gtx_norm.cpp
│ │ │ │ │ ├── gtx_normal.cpp
│ │ │ │ │ ├── gtx_normalize_dot.cpp
│ │ │ │ │ ├── gtx_number_precision.cpp
│ │ │ │ │ ├── gtx_optimum_pow.cpp
│ │ │ │ │ ├── gtx_orthonormalize.cpp
│ │ │ │ │ ├── gtx_pca.cpp
│ │ │ │ │ ├── gtx_perpendicular.cpp
│ │ │ │ │ ├── gtx_polar_coordinates.cpp
│ │ │ │ │ ├── gtx_projection.cpp
│ │ │ │ │ ├── gtx_quaternion.cpp
│ │ │ │ │ ├── gtx_random.cpp
│ │ │ │ │ ├── gtx_range.cpp
│ │ │ │ │ ├── gtx_rotate_normalized_axis.cpp
│ │ │ │ │ ├── gtx_rotate_vector.cpp
│ │ │ │ │ ├── gtx_scalar_multiplication.cpp
│ │ │ │ │ ├── gtx_scalar_relational.cpp
│ │ │ │ │ ├── gtx_simd_mat4.cpp
│ │ │ │ │ ├── gtx_simd_vec4.cpp
│ │ │ │ │ ├── gtx_spline.cpp
│ │ │ │ │ ├── gtx_string_cast.cpp
│ │ │ │ │ ├── gtx_texture.cpp
│ │ │ │ │ ├── gtx_type_aligned.cpp
│ │ │ │ │ ├── gtx_type_trait.cpp
│ │ │ │ │ ├── gtx_vec_swizzle.cpp
│ │ │ │ │ ├── gtx_vector_angle.cpp
│ │ │ │ │ ├── gtx_vector_query.cpp
│ │ │ │ │ └── gtx_wrap.cpp
│ │ │ │ └── perf/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── perf_matrix_div.cpp
│ │ │ │ ├── perf_matrix_inverse.cpp
│ │ │ │ ├── perf_matrix_mul.cpp
│ │ │ │ ├── perf_matrix_mul_vector.cpp
│ │ │ │ ├── perf_matrix_transpose.cpp
│ │ │ │ └── perf_vector_mul_matrix.cpp
│ │ │ └── util/
│ │ │ ├── autoexp.txt
│ │ │ └── glm.natvis
│ │ └── stbi_image_write.h
│ ├── simple-knn/
│ │ ├── dist/
│ │ │ └── simple_knn-0.0.0-py3.7-linux-x86_64.egg
│ │ ├── ext.cpp
│ │ ├── setup.py
│ │ ├── simple_knn/
│ │ │ └── .gitkeep
│ │ ├── simple_knn.cu
│ │ ├── simple_knn.egg-info/
│ │ │ ├── PKG-INFO
│ │ │ ├── SOURCES.txt
│ │ │ ├── dependency_links.txt
│ │ │ └── top_level.txt
│ │ ├── simple_knn.h
│ │ ├── spatial.cu
│ │ └── spatial.h
│ └── simple-waymo-open-dataset-reader/
│ ├── LICENSE
│ ├── README.md
│ ├── examples/
│ │ ├── count_frames.py
│ │ ├── extract_merged_pointclouds.py
│ │ ├── groundtruth_extraction.py
│ │ ├── requirements.txt
│ │ ├── visualise_labels.py
│ │ ├── visualise_labels_and_lidar.py
│ │ └── visualise_pcl.py
│ ├── generate_proto.sh
│ ├── setup.py
│ ├── simple_waymo_open_dataset_reader/
│ │ ├── __init__.py
│ │ ├── dataset.proto
│ │ ├── dataset_pb2.py
│ │ ├── label.proto
│ │ ├── label_pb2.py
│ │ └── utils.py
│ └── simple_waymo_open_dataset_reader.egg-info/
│ ├── PKG-INFO
│ ├── SOURCES.txt
│ ├── dependency_links.txt
│ ├── requires.txt
│ └── top_level.txt
├── test_render_window.py
├── test_render_window_cv2.py
├── train.py
├── utils/
│ ├── __init__.py
│ ├── activations.py
│ ├── augmentations.py
│ ├── autoanchor.py
│ ├── autobatch.py
│ ├── aws/
│ │ ├── __init__.py
│ │ ├── mime.sh
│ │ ├── resume.py
│ │ └── userdata.sh
│ ├── callbacks.py
│ ├── dataloaders.py
│ ├── docker/
│ │ ├── Dockerfile
│ │ ├── Dockerfile-arm64
│ │ └── Dockerfile-cpu
│ ├── downloads.py
│ ├── flask_rest_api/
│ │ ├── README.md
│ │ ├── example_request.py
│ │ └── restapi.py
│ ├── general.py
│ ├── google_app_engine/
│ │ ├── Dockerfile
│ │ ├── additional_requirements.txt
│ │ └── app.yaml
│ ├── loggers/
│ │ ├── __init__.py
│ │ ├── clearml/
│ │ │ ├── README.md
│ │ │ ├── __init__.py
│ │ │ ├── clearml_utils.py
│ │ │ └── hpo.py
│ │ ├── comet/
│ │ │ ├── README.md
│ │ │ ├── __init__.py
│ │ │ ├── comet_utils.py
│ │ │ ├── hpo.py
│ │ │ └── optimizer_config.json
│ │ └── wandb/
│ │ ├── __init__.py
│ │ └── wandb_utils.py
│ ├── loss.py
│ ├── metrics.py
│ ├── plots.py
│ ├── segment/
│ │ ├── __init__.py
│ │ ├── augmentations.py
│ │ ├── dataloaders.py
│ │ ├── general.py
│ │ ├── loss.py
│ │ ├── metrics.py
│ │ └── plots.py
│ ├── torch_utils.py
│ └── triton.py
└── weights/
├── __init__.py
└── yolov5s.pt
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
*.pyc
.vscode
output
data
build
install
log
diff_rasterization/diff_rast.egg-info
diff_rasterization/dist
tensorboard_3d
screenshots
GroundingDINO/
================================================
FILE: .idea/.gitignore
================================================
# Default ignored files
/shelf/
/workspace.xml
================================================
FILE: .idea/inspectionProfiles/profiles_settings.xml
================================================
<component name="InspectionProjectProfileManager">
<settings>
<option name="USE_PROJECT_PROFILE" value="false" />
<version value="1.0" />
</settings>
</component>
================================================
FILE: .idea/misc.xml
================================================
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="Black">
<option name="sdkName" value="street-gaussian" />
</component>
<component name="ProjectRootManager" version="2" project-jdk-name="street-gaussian-ros (5)" project-jdk-type="Python SDK" />
</project>
================================================
FILE: .idea/modules.xml
================================================
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectModuleManager">
<modules>
<module fileurl="file://$PROJECT_DIR$/.idea/street_gaussians.iml" filepath="$PROJECT_DIR$/.idea/street_gaussians.iml" />
</modules>
</component>
</project>
================================================
FILE: .idea/street_gaussians.iml
================================================
<?xml version="1.0" encoding="UTF-8"?>
<module type="PYTHON_MODULE" version="4">
<component name="NewModuleRootManager">
<content url="file://$MODULE_DIR$">
<sourceFolder url="file://$MODULE_DIR$/GroundingDINO" isTestSource="false" />
</content>
<orderEntry type="jdk" jdkName="street-gaussian-ros (5)" jdkType="Python SDK" />
<orderEntry type="sourceFolder" forTests="false" />
</component>
<component name="PyDocumentationSettings">
<option name="format" value="PLAIN" />
<option name="myDocStringFormat" value="Plain" />
</component>
</module>
================================================
FILE: .idea/vcs.xml
================================================
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="VcsDirectoryMappings">
<mapping directory="" vcs="Git" />
</component>
</project>
================================================
FILE: README.md
================================================
# GaussianRPG: 3D Gaussian Rendering PlayGround
This is an open-source autonomous driving closed-loop simulator demo using 3D Gaussian Splatting tech. The whole project is base on the codes from this paper:
> [Street Gaussians: Modeling Dynamic Urban Scenes with Gaussian Splatting](https://arxiv.org/abs/2401.01339)
> Yunzhi Yan, Haotong Lin, Chenxu Zhou, Weijie Wang, Haiyang Sun, Kun Zhan, Xianpeng Lang, Xiaowei Zhou, Sida Peng
> ECCV 2024
In this project, a simulator has been developed. Street_Gaussians is responsible for rendering images based on the camera position. A dummy AEB controller applies YOLOv5 to recognize cars in the images and determine the distance, issuing braking commands when appropriate. The car dynamics component within the simulator adjusts the camera position according to the braking commands and provides this information to Street_Gaussians as the basis for rendering the next frame. For convenience, ROS2 serves as the middleware providing the framework for the simulator.
**GaussianRPG v2.0 is launched!!**
### Examples:
Waymo Scene 002:
Waymo Scene 124:
Waymo Scene 149:
### Installation
Environments of the repo:
*ubuntu 22.04*
*GeForce RTX 3090*
<details> <summary>Clone this repository</summary>
```
git clone https://github.com/GimpelZhang/GaussianRPG.git
```
</details>
<details> <summary>Set up the python environment</summary>
```
# First make sure there is g++-11 in your system, if not:
sudo apt install g++
# Install mamba to manage environments:
conda install mamba -c conda-forge
# Set conda environment
mamba create -n street-gaussian-ros python=3.8
mamba activate street-gaussian-ros
conda config --env --add channels conda-forge
conda config --env --add channels robostack-staging
conda config --env --remove channels defaults
# Install ROS2 humble:
mamba install ros-humble-desktop
mamba deactivate
mamba activate street-gaussian-ros
mamba install compilers cmake pkg-config make ninja colcon-common-extensions catkin_tools rosdep
pip install setuptools==58.2.0
# Install torch (corresponding to your CUDA version)
pip install torch==2.1.2+cu118 torchvision==0.16.2+cu118 --extra-index-url https://download.pytorch.org/whl/cu118
# Install requirements
pip install -r requirements.txt
conda install ninja
# Install submodules
# Because of the ROS2 env, g++ is in version 12 in this conda env.
# So next we can link to the g++-11 in our system directly:
CC=/usr/bin/gcc CXX=/usr/bin/g++ pip install ./submodules/diff-gaussian-rasterization
CC=/usr/bin/gcc CXX=/usr/bin/g++ pip install ./submodules/simple-knn
CC=/usr/bin/gcc CXX=/usr/bin/g++ pip install ./submodules/simple-waymo-open-dataset-reader
CC=/usr/bin/gcc CXX=/usr/bin/g++ python script/test_gaussian_rasterization.py
# Build ROS2 nodes:
cd nodes
colcon build
# Further, if you want to train or to render using Street_Gaussians in this street-gaussian-ros conda env,
# don't forget to add the g++-11 path before every command:
CC=/usr/bin/gcc CXX=/usr/bin/g++ python train.py --config configs/xxxx.yaml
CC=/usr/bin/gcc CXX=/usr/bin/g++ python render.py --config configs/xxxx.yaml mode {evaluate, trajectory}
```
</details>
<details> <summary>Prepare Waymo Open Dataset and others to run the simulator.</summary>
To run the GaussianRPG simulator, a trained Street_Gaussians model is needed. To render Street_Gaussians models, the training data folders are also needed.
I provide all the data for the **examples** including: Waymo scene training data, trained outputs, and some **special files** inside them.
| baidunetdisk | google drive |
|-------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------|
| [LINK](https://pan.baidu.com/s/1iGVjyEuZL5WBPI6ItpP5uQ)<br/> code: pcx4 | [LINK](https://drive.google.com/drive/folders/159TYBUJvSUl8B6StR_2oFsM0wnXvN7B2)<br/> (Only including scene 149 training data) |
First prepare the Waymo training data:
```
data
└── waymo
└── training
└── 002
└── 124
└── 149
```
Then prepare the trained outputs:
```
output
└── waymo_full_exp
└── waymo_train_002_1cam
└── waymo_train_124_1cam
└── waymo_train_149_1cam
```
What are the **special files**?
1. Modified objects tracking info:
Files like ./data/waymo/training/002/track/track_info.txt are modified so that novel motions are involved: the front cars can make AEB scenes.
**So if you want to train your own models using the data I provide, you can use the "track_info_original.txt" files instead in track folders. (rename "track_info_original.txt" -> "track_info.txt")**
2. Camera poses trajectory files:
Files like ./output/waymo_full_exp/waymo_train_002_1cam/trajectory/ours_50000/cams_tape.json: camera poses for Street_Gaussians to render.
If you want to prepare more Waymo scenes other than the examples, you can follow the procedure below:
1. Prepare the Waymo Open Dataset and train the models following the README in the original Street_Gaussian repo. (Codes in GaussianRPG can be used to complete the training as well.)
2. Use the **render_lite.py** script in GaussianRPG to make the cams_tape.json files:
```
CC=/usr/bin/gcc CXX=/usr/bin/g++ python render_lite.py --config configs/example/XXXX.yaml mode trajectory
```
3. Pick up the car that you want to edit and modify its pose in the track_info.txt. (A lot of manual work here. No tools for picking/edition yet.)
4. Modify the config yaml file. (Config yaml files for the examples are provided)
</details>
### Run the gaussian_rpg simulator
#### 1. Separate perception mode:
Set the parameter "separate_perception" in the config yaml file to "true". Then:
```
cd nodes
# scene 002:
./scripts/simulator_launch_separate.sh ../output/waymo_full_exp/waymo_train_002_1cam/trajectory/ours_50000/cams_tape.json ../data/waymo/trai
ning/002/track/track_info.txt 98 6 waymo_train_002_1cam.yaml 10.0 2.0 24.0
# scene 124:
./scripts/simulator_launch_separate.sh ../output/waymo_full_exp/waymo_train_124_1cam/trajectory/ours_50000/cams_tape.json ../data/waymo/trai
ning/124/track/track_info.txt 0 57 waymo_train_124_1cam.yaml 7.0 2.0 20.0
# scene 149:
./scripts/simulator_launch_separate.sh ../output/waymo_full_exp/waymo_train_149_1cam/trajectory/ours_50000/cams_tape.json ../data/waymo/trai
ning/149/track/track_info.txt 10 21 waymo_train_149_1cam.yaml 8.0 2.0 21.0
```
In this mode, the simulator ROS2 node "gaussian_rpg" publishes the rendered image directly through ROS2 Image topic. The YOLOv5 perception module runs separately in the node "object_detector" which subscribes the Image topic. The rqt_graph below shows the framework of this mode.
The ROS2 Image topic construction process in python is very slow, which makes the system running at about 1.15Hz. If we don't pass the image through rostopic, the system is able to run in a higher speed.
#### 2. Not separate perception mode:
Set the parameter "separate_perception" in the config yaml file to "false". Then:
```
cd nodes
# scene 002:
./scripts/simulator_launch.sh ../output/waymo_full_exp/waymo_train_002_1cam/trajectory/ours_50000/cams_tape.json ../data/waymo/trai
ning/002/track/track_info.txt 98 6 waymo_train_002_1cam.yaml 10.0 2.0 24.0
# scene 124:
./scripts/simulator_launch.sh ../output/waymo_full_exp/waymo_train_124_1cam/trajectory/ours_50000/cams_tape.json ../data/waymo/trai
ning/124/track/track_info.txt 0 57 waymo_train_124_1cam.yaml 7.0 2.0 20.0
# scene 149:
./scripts/simulator_launch.sh ../output/waymo_full_exp/waymo_train_149_1cam/trajectory/ours_50000/cams_tape.json ../data/waymo/trai
ning/149/track/track_info.txt 10 21 waymo_train_149_1cam.yaml 8.0 2.0 21.0
```
In this mode, the YOLOv5 perception module is inside the gaussian_rpg node. The rendered result of Street_Gaussians runs directly into YOLOv5 model, which makes the system running about 5-6Hz. The rqt_graph is below:
Note that I didn't implement any optimization in the whole python YOLOv5 perception process, so the simulator system is not running at expected "real-time" speed (images in Waymo dataset have frequency 10Hz). However, the rendering speed of Street_Gaussians itself is much higher than that of GaussianRPG (>20-30Hz on 3090).
Therefore, I believe that with well-designed software engineering, gaussian splatting based simulator in future will definitely become a real-time test bench for Software-In-Loop simulation, or even Hardware-In-Loop simulation.
#### Arguments:
Here are the definitions of the shell script arguments:
```
$1: camera pose trajectory file path.
$2: objects tracking info file path.
$3: start frame id for the scene, the 1st element in "selected_frames" in the config yaml file.
$4: the track_id of the cipv front car in the track_info.txt file.
$5: config yaml file name.
$6: the simulation time (s).
$7: the collision distance threshold (m).
$8: the braking distance threshold (m), in dummy controller, there is no TTC concept, so the braking distance is made as an argument.
```
### GaussianRPG v2.0
A hardware-in-the-loop simulation system demo is developed based on the v1.0 software-in-the-loop GaussianRPG and an D-Robotics RDK X5 suite.
```
cd nodes
# scene 002:
./scripts/simulator_launch_hil.sh ../output/waymo_full_exp/waymo_train_002_1cam/trajectory/ours_50000/cams_tape.json ../data/waymo/training/002/track/track_info.txt 98 6 waymo_train_002_1cam.yaml 10.0 2.0 25.0
# scene 124:
./scripts/simulator_launch_hil.sh ../output/waymo_full_exp/waymo_train_124_1cam/trajectory/ours_50000/cams_tape.json ../data/waymo/training/124/track/track_info.txt 0 57 waymo_train_124_1cam.yaml 7.0 2.0 20.0
# scene 149:
./scripts/simulator_launch_hil.sh ../output/waymo_full_exp/waymo_train_149_1cam/trajectory/ours_50000/cams_tape.json ../data/waymo/training/149/track/track_info.txt 10 21 waymo_train_149_1cam.yaml 7.5 2.0 21.0
```
More details about the system are on the wiki page: [Hardware in the loop](https://github.com/GimpelZhang/GaussianRPG/wiki/Hardware-in-the-loop)
### Acknowledgments
The original Street_Gaussians work: [Street Gaussians](https://github.com/zju3dv/street_gaussians).
The whole YOLOv5 objects and distance detection module comes from: [yolov5_Distance_Detect](https://github.com/genqiaolynn/yolov5_Distance_Detect).
================================================
FILE: configs/example/waymo_train_002.yaml
================================================
task: waymo_full_exp
source_path: ./data/waymo/training/002
exp_name: waymo_train_002
data:
split_test: -1
split_train: 1
type: Waymo
white_background: false
selected_frames: [98, 198]
cameras: [0, 1, 2]
extent: 10
use_colmap: true
filter_colmap: true
model:
gaussian:
sh_degree: 1
fourier_dim: 5
fourier_scale: 1.
flip_prob: 0.5
nsg:
include_bkgd: true
include_obj: true
include_sky: true
opt_track: true
train:
iterations: 50000
test_iterations: [7000, 30000, 50000]
save_iterations: [50000]
checkpoint_iterations: [50000]
optim:
prune_box_interval: 100
densification_interval: 100
densify_from_iter: 500
densify_grad_threshold_bkgd: 0.0006
densify_grad_abs_bkgd: True
densify_grad_threshold_obj: 0.0002
densify_grad_abs_obj: False
densify_grad_threshold: 0.0002
densify_until_iter: 25000
feature_lr: 0.0025
max_screen_size: 20
min_opacity: 0.005
opacity_lr: 0.05
opacity_reset_interval: 3000
percent_big_ws: 0.1
percent_dense: 0.01
position_lr_delay_mult: 0.01
position_lr_final: 1.6e-06
position_lr_init: 0.00016
position_lr_max_steps: 50000
rotation_lr: 0.001
scaling_lr: 0.005
semantic_lr: 0.01
lambda_dssim: 0.2
lambda_sky: 0.05
lambda_sky_scale: [1, 1, 0]
lambda_mask: 0.1
lambda_reg: 0.1
lambda_depth_lidar: 0.1
track_position_lr_delay_mult: 0.01
track_position_lr_init: 0.005
track_position_lr_final: 5.0e-5
track_position_max_steps: 30000
track_rotation_lr_delay_mult: 0.01
track_rotation_lr_init: 0.001
track_rotation_lr_final: 1.0e-5
track_rotation_max_steps: 30000
render:
fps: 24
concat_cameras: [1, 0, 2]
================================================
FILE: configs/example/waymo_train_002_1cam.yaml
================================================
task: waymo_full_exp
main_workspace: /home/junchuan/nerf/street_gaussians
source_path: /home/junchuan/nerf/street_gaussians/data/waymo/training/002
exp_name: waymo_train_002_1cam
traj_file_path: /home/junchuan/nerf/street_gaussians/output/waymo_full_exp/waymo_train_002_1cam/trajectory/ours_50000/cams_tape.json
separate_perception: true
yolov5_weights_path: /home/junchuan/nerf/street_gaussians/weights/yolov5s.pt
data:
split_test: -1
split_train: 1
type: Waymo
white_background: false
selected_frames: [98, 198]
cameras: [0]
extent: 10
use_colmap: true
filter_colmap: true
model:
gaussian:
sh_degree: 1
fourier_dim: 5
fourier_scale: 1.
flip_prob: 0.5
nsg:
include_bkgd: true
include_obj: true
include_sky: true
opt_track: true
train:
iterations: 50000
test_iterations: [7000, 30000, 50000]
save_iterations: [50000]
checkpoint_iterations: [50000]
optim:
prune_box_interval: 100
densification_interval: 100
densify_from_iter: 500
densify_grad_threshold_bkgd: 0.0006
densify_grad_abs_bkgd: True
densify_grad_threshold_obj: 0.0002
densify_grad_abs_obj: False
densify_grad_threshold: 0.0002
densify_until_iter: 25000
feature_lr: 0.0025
max_screen_size: 20
min_opacity: 0.005
opacity_lr: 0.05
opacity_reset_interval: 3000
percent_big_ws: 0.1
percent_dense: 0.01
position_lr_delay_mult: 0.01
position_lr_final: 1.6e-06
position_lr_init: 0.00016
position_lr_max_steps: 50000
rotation_lr: 0.001
scaling_lr: 0.005
semantic_lr: 0.01
lambda_dssim: 0.2
lambda_sky: 0.05
lambda_sky_scale: [1, 1, 0]
lambda_mask: 0.1
lambda_reg: 0.1
lambda_depth_lidar: 0.1
track_position_lr_delay_mult: 0.01
track_position_lr_init: 0.005
track_position_lr_final: 5.0e-5
track_position_max_steps: 30000
track_rotation_lr_delay_mult: 0.01
track_rotation_lr_init: 0.001
track_rotation_lr_final: 1.0e-5
track_rotation_max_steps: 30000
render:
fps: 24
concat_cameras: [0]
================================================
FILE: configs/example/waymo_train_031.yaml
================================================
task: waymo_full_exp
source_path: ./data/waymo/training/031
exp_name: waymo_train_031
data:
split_test: -1
split_train: 1
type: Waymo
white_background: false
selected_frames: [0, 198]
cameras: [0, 1, 2]
extent: 10
use_colmap: true
filter_colmap: true
box_scale: 1.5
model:
gaussian:
sh_degree: 1
fourier_dim: 5
fourier_scale: 1.
flip_prob: 0.
nsg:
include_bkgd: true
include_obj: true
include_sky: true
opt_track: true
train:
iterations: 50000
test_iterations: [7000, 30000, 50000]
save_iterations: [50000]
checkpoint_iterations: [50000]
optim:
prune_box_interval: 100
densification_interval: 100
densify_from_iter: 500
densify_grad_threshold_bkgd: 0.0006
densify_grad_abs_bkgd: True
densify_grad_threshold_obj: 0.0002
densify_grad_abs_obj: False
densify_until_iter: 25000
feature_lr: 0.0025
max_screen_size: 20
min_opacity: 0.005
opacity_lr: 0.05
opacity_reset_interval: 3000
percent_big_ws: 0.1
percent_dense: 0.01
position_lr_delay_mult: 0.01
position_lr_final: 1.6e-06
position_lr_init: 0.00016
position_lr_max_steps: 50000
rotation_lr: 0.001
scaling_lr: 0.005
semantic_lr: 0.01
lambda_dssim: 0.2
lambda_sky: 0.05
lambda_mask: 0.1
lambda_reg: 0.1
lambda_depth_lidar: 0.1
track_position_lr_delay_mult: 0.01
track_position_lr_init: 0.005
track_position_lr_final: 5.0e-5
track_position_max_steps: 30000
track_rotation_lr_delay_mult: 0.01
track_rotation_lr_init: 0.001
track_rotation_lr_final: 1.0e-5
track_rotation_max_steps: 30000
render:
fps: 24
concat_cameras: [1, 0, 2]
================================================
FILE: configs/example/waymo_train_124_1cam.yaml
================================================
task: waymo_full_exp
main_workspace: /home/junchuan/nerf/street_gaussians
source_path: /home/junchuan/nerf/street_gaussians/data/waymo/training/124
exp_name: waymo_train_124_1cam
traj_file_path: /home/junchuan/nerf/street_gaussians/output/waymo_full_exp/waymo_train_124_1cam/trajectory/ours_50000/cams_tape.json
separate_perception: false
yolov5_weights_path: /home/junchuan/nerf/street_gaussians/weights/yolov5s.pt
data:
split_test: -1
split_train: 1
type: Waymo
white_background: false
selected_frames: [0, 105]
cameras: [0]
extent: 10
use_colmap: true
filter_colmap: true
model:
gaussian:
sh_degree: 1
fourier_dim: 5
fourier_scale: 1.
flip_prob: 0.5
nsg:
include_bkgd: true
include_obj: true
include_sky: true
opt_track: true
train:
iterations: 50000
test_iterations: [7000, 30000, 50000]
save_iterations: [50000]
checkpoint_iterations: [50000]
optim:
prune_box_interval: 100
densification_interval: 100
densify_from_iter: 500
densify_grad_threshold_bkgd: 0.0006
densify_grad_abs_bkgd: True
densify_grad_threshold_obj: 0.0002
densify_grad_abs_obj: False
densify_grad_threshold: 0.0002
densify_until_iter: 25000
feature_lr: 0.0025
max_screen_size: 20
min_opacity: 0.005
opacity_lr: 0.05
opacity_reset_interval: 3000
percent_big_ws: 0.1
percent_dense: 0.01
position_lr_delay_mult: 0.01
position_lr_final: 1.6e-06
position_lr_init: 0.00016
position_lr_max_steps: 50000
rotation_lr: 0.001
scaling_lr: 0.005
semantic_lr: 0.01
lambda_dssim: 0.2
lambda_sky: 0.05
lambda_sky_scale: [1, 1, 0]
lambda_mask: 0.1
lambda_reg: 0.1
lambda_depth_lidar: 0.1
track_position_lr_delay_mult: 0.01
track_position_lr_init: 0.005
track_position_lr_final: 5.0e-5
track_position_max_steps: 30000
track_rotation_lr_delay_mult: 0.01
track_rotation_lr_init: 0.001
track_rotation_lr_final: 1.0e-5
track_rotation_max_steps: 30000
render:
fps: 24
concat_cameras: [0]
================================================
FILE: configs/example/waymo_train_149_1cam.yaml
================================================
task: waymo_full_exp
main_workspace: /home/junchuan/nerf/street_gaussians
source_path: /home/junchuan/nerf/street_gaussians/data/waymo/training/149
exp_name: waymo_train_149_1cam
traj_file_path: /home/junchuan/nerf/street_gaussians/output/waymo_full_exp/waymo_train_149_1cam/trajectory/ours_50000/cams_tape.json
separate_perception: false
yolov5_weights_path: /home/junchuan/nerf/street_gaussians/weights/yolov5s.pt
data:
split_test: -1
split_train: 1
type: Waymo
white_background: false
selected_frames: [10, 112]
cameras: [0]
extent: 10
use_colmap: true
filter_colmap: true
model:
gaussian:
sh_degree: 1
fourier_dim: 5
fourier_scale: 1.
flip_prob: 0.5
nsg:
include_bkgd: true
include_obj: true
include_sky: true
opt_track: true
train:
iterations: 50000
test_iterations: [7000, 30000, 50000]
save_iterations: [50000]
checkpoint_iterations: [50000]
optim:
prune_box_interval: 100
densification_interval: 100
densify_from_iter: 500
densify_grad_threshold_bkgd: 0.0006
densify_grad_abs_bkgd: True
densify_grad_threshold_obj: 0.0002
densify_grad_abs_obj: False
densify_grad_threshold: 0.0002
densify_until_iter: 25000
feature_lr: 0.0025
max_screen_size: 20
min_opacity: 0.005
opacity_lr: 0.05
opacity_reset_interval: 3000
percent_big_ws: 0.1
percent_dense: 0.01
position_lr_delay_mult: 0.01
position_lr_final: 1.6e-06
position_lr_init: 0.00016
position_lr_max_steps: 50000
rotation_lr: 0.001
scaling_lr: 0.005
semantic_lr: 0.01
lambda_dssim: 0.2
lambda_sky: 0.05
lambda_sky_scale: [1, 1, 0]
lambda_mask: 0.1
lambda_reg: 0.1
lambda_depth_lidar: 0.1
track_position_lr_delay_mult: 0.01
track_position_lr_init: 0.005
track_position_lr_final: 5.0e-5
track_position_max_steps: 30000
track_rotation_lr_delay_mult: 0.01
track_rotation_lr_init: 0.001
track_rotation_lr_final: 1.0e-5
track_rotation_max_steps: 30000
render:
fps: 24
concat_cameras: [0]
================================================
FILE: configs/experiments_waymo/waymo_val_006.yaml
================================================
task: waymo_exp
source_path: ./data/waymo/validation/006
exp_name: waymo_val_006
data:
split_train: -1
split_test: 4
type: Waymo
white_background: true
selected_frames: [0, 85]
cameras: [0]
use_tracker: true
extent: 20
use_colmap: true
model:
gaussian:
sh_degree: 1
fourier_dim: 5
fourier_scale: 1.
nsg:
include_bkgd: true
include_obj: true
include_sky: false
opt_track: true
train:
iterations: 30000
test_iterations: [7000, 30000]
checkpoint_iterations: [30000]
optim:
prune_box_interval: 100
densification_interval: 100
densify_from_iter: 500
densify_grad_threshold: 0.0002
densify_until_iter: 15000
feature_lr: 0.0025
max_screen_size: 20
min_opacity: 0.005
opacity_lr: 0.05
opacity_reset_interval: 3000
percent_big_ws: 0.1
percent_dense: 0.01
position_lr_delay_mult: 0.01
position_lr_final: 1.6e-06
position_lr_init: 0.00016
position_lr_max_steps: 30000
rotation_lr: 0.001
scaling_lr: 0.005
semantic_lr: 0.01
lambda_dssim: 0.2
lambda_mask: 0.1
lambda_reg: 0.1
lambda_depth_lidar: 0.
lambda_l1: 3.
track_position_lr_delay_mult: 0.01
track_position_lr_init: 0.005
track_position_lr_final: 5.0e-5
track_position_max_steps: 30000
track_rotation_lr_delay_mult: 0.01
track_rotation_lr_init: 0.001
track_rotation_lr_final: 1.0e-5
track_rotation_max_steps: 30000
render:
fps: 30
================================================
FILE: configs/experiments_waymo/waymo_val_026.yaml
================================================
task: waymo_exp
source_path: ./data/waymo/validation/026
exp_name: waymo_val_026
data:
split_train: -1
split_test: 4
type: Waymo
white_background: false
selected_frames: [0, 100]
cameras: [0]
use_tracker: true
extent: 20
use_colmap: true
box_scale: 2.0
model:
gaussian:
sh_degree: 1
fourier_dim: 5
fourier_scale: 1.
nsg:
include_bkgd: true
include_obj: true
include_sky: true
opt_track: true
sky:
resolution: 1024
white_background: true
train:
iterations: 30000
test_iterations: [7000, 30000]
checkpoint_iterations: [30000]
optim:
prune_box_interval: 100
densification_interval: 100
densify_from_iter: 500
densify_grad_threshold: 0.0002
densify_until_iter: 15000
feature_lr: 0.0025
max_screen_size: 20
min_opacity: 0.005
opacity_lr: 0.05
opacity_reset_interval: 3000
percent_big_ws: 0.1
percent_dense: 0.01
position_lr_delay_mult: 0.01
position_lr_final: 1.6e-06
position_lr_init: 0.00016
position_lr_max_steps: 30000
rotation_lr: 0.001
scaling_lr: 0.005
semantic_lr: 0.01
lambda_dssim: 0.2
lambda_sky: 0.05
lambda_mask: 0.1
lambda_reg: 0.1
lambda_depth_lidar: 0.01
lambda_l1: 3.
track_position_lr_delay_mult: 0.01
track_position_lr_init: 0.005
track_position_lr_final: 5.0e-5
track_position_max_steps: 30000
track_rotation_lr_delay_mult: 0.01
track_rotation_lr_init: 0.001
track_rotation_lr_final: 1.0e-5
track_rotation_max_steps: 30000
render:
fps: 30
================================================
FILE: configs/experiments_waymo/waymo_val_090.yaml
================================================
task: waymo_exp
source_path: ./data/waymo/validation/090
exp_name: waymo_val_090
data:
split_train: -1
split_test: 4
type: Waymo
white_background: false
selected_frames: [0, 102]
cameras: [0]
use_tracker: true
extent: 20
use_colmap: true
model:
gaussian:
sh_degree: 1
fourier_dim: 5
fourier_scale: 1.
nsg:
include_bkgd: true
include_obj: true
include_sky: true
opt_track: true
sky:
resolution: 1024
white_background: true
train:
iterations: 30000
test_iterations: [7000, 30000]
checkpoint_iterations: [30000]
optim:
prune_box_interval: 100
densification_interval: 100
densify_from_iter: 500
densify_grad_threshold: 0.0002
densify_until_iter: 15000
feature_lr: 0.0025
max_screen_size: 20
min_opacity: 0.005
opacity_lr: 0.05
opacity_reset_interval: 3000
percent_big_ws: 0.1
percent_dense: 0.01
position_lr_delay_mult: 0.01
position_lr_final: 1.6e-06
position_lr_init: 0.00016
position_lr_max_steps: 30000
rotation_lr: 0.001
scaling_lr: 0.005
semantic_lr: 0.01
lambda_dssim: 0.2
lambda_sky: 0.05
lambda_mask: 0.1
lambda_reg: 0.1
lambda_depth_lidar: 0.01
lambda_l1: 3.
track_position_lr_delay_mult: 0.01
track_position_lr_init: 0.005
track_position_lr_final: 5.0e-5
track_position_max_steps: 30000
track_rotation_lr_delay_mult: 0.01
track_rotation_lr_init: 0.001
track_rotation_lr_final: 1.0e-5
track_rotation_max_steps: 30000
render:
fps: 30
================================================
FILE: configs/experiments_waymo/waymo_val_105.yaml
================================================
task: waymo_exp
source_path: ./data/waymo/validation/105
exp_name: waymo_val_105
data:
split_train: -1
split_test: 4
type: Waymo
white_background: false
selected_frames: [20, 186]
cameras: [0]
use_tracker: true
extent: 20
use_colmap: true
model:
gaussian:
sh_degree: 1
fourier_dim: 5
fourier_scale: 1.
nsg:
include_bkgd: true
include_obj: true
include_sky: true
opt_track: true
sky:
resolution: 1024
white_background: true
train:
iterations: 30000
test_iterations: [7000, 30000]
checkpoint_iterations: [30000]
optim:
prune_box_interval: 100
densification_interval: 100
densify_from_iter: 500
densify_grad_threshold: 0.0002
densify_until_iter: 15000
feature_lr: 0.0025
max_screen_size: 20
min_opacity: 0.005
opacity_lr: 0.05
opacity_reset_interval: 3000
percent_big_ws: 0.1
percent_dense: 0.01
position_lr_delay_mult: 0.01
position_lr_final: 1.6e-06
position_lr_init: 0.00016
position_lr_max_steps: 30000
rotation_lr: 0.001
scaling_lr: 0.005
semantic_lr: 0.01
lambda_dssim: 0.2
lambda_sky: 0.05
lambda_mask: 0.1
lambda_reg: 0.1
lambda_depth_lidar: 0.01
lambda_l1: 3.
track_position_lr_delay_mult: 0.01
track_position_lr_init: 0.005
track_position_lr_final: 5.0e-5
track_position_max_steps: 30000
track_rotation_lr_delay_mult: 0.01
track_rotation_lr_init: 0.001
track_rotation_lr_final: 1.0e-5
track_rotation_max_steps: 30000
render:
fps: 30
================================================
FILE: configs/experiments_waymo/waymo_val_108.yaml
================================================
task: waymo_exp
source_path: ./data/waymo/validation/108
exp_name: waymo_val_108
data:
split_train: -1
split_test: 4
type: Waymo
white_background: false
selected_frames: [20, 115]
cameras: [0]
use_tracker: true
extent: 20
use_colmap: true
model:
gaussian:
sh_degree: 1
fourier_dim: 5
fourier_scale: 1.
nsg:
include_bkgd: true
include_obj: true
include_sky: true
opt_track: true
sky:
resolution: 1024
white_background: true
train:
iterations: 30000
test_iterations: [7000, 30000]
checkpoint_iterations: [30000]
optim:
prune_box_interval: 100
densification_interval: 100
densify_from_iter: 500
# densify_grad_threshold_bkgd: 0.0006
# densify_grad_abs_bkgd: True
densify_grad_threshold: 0.0002
densify_until_iter: 15000
feature_lr: 0.0025
max_screen_size: 20
min_opacity: 0.005
opacity_lr: 0.05
opacity_reset_interval: 3000
percent_big_ws: 0.1
percent_dense: 0.01
position_lr_delay_mult: 0.01
position_lr_final: 1.6e-06
position_lr_init: 0.00016
position_lr_max_steps: 30000
rotation_lr: 0.001
scaling_lr: 0.005
semantic_lr: 0.01
lambda_dssim: 0.2
lambda_sky: 0.05
lambda_mask: 0.1
lambda_reg: 0.1
lambda_depth_lidar: 0.01
lambda_l1: 3.
track_position_lr_delay_mult: 0.01
track_position_lr_init: 0.005
track_position_lr_final: 5.0e-5
track_position_max_steps: 30000
track_rotation_lr_delay_mult: 0.01
track_rotation_lr_init: 0.001
track_rotation_lr_final: 1.0e-5
track_rotation_max_steps: 30000
render:
fps: 30
================================================
FILE: configs/experiments_waymo/waymo_val_134.yaml
================================================
task: waymo_exp
source_path: ./data/waymo/validation/134
exp_name: waymo_val_134
data:
split_train: -1
split_test: 4
type: Waymo
white_background: false
selected_frames: [106, 198]
cameras: [0]
use_tracker: true
extent: 20
use_colmap: true
model:
gaussian:
sh_degree: 1
fourier_dim: 5
fourier_scale: 1.
nsg:
include_bkgd: true
include_obj: true
include_sky: false
opt_track: true
train:
iterations: 30000
test_iterations: [7000, 30000]
checkpoint_iterations: [30000]
optim:
prune_box_interval: 100
densification_interval: 100
densify_from_iter: 500
densify_grad_threshold: 0.0002
densify_until_iter: 15000
feature_lr: 0.0025
max_screen_size: 20
min_opacity: 0.005
opacity_lr: 0.05
opacity_reset_interval: 3000
percent_big_ws: 0.1
percent_dense: 0.01
position_lr_delay_mult: 0.01
position_lr_final: 1.6e-06
position_lr_init: 0.00016
position_lr_max_steps: 30000
rotation_lr: 0.001
scaling_lr: 0.005
semantic_lr: 0.01
lambda_dssim: 0.2
lambda_sky: 0.05
lambda_mask: 0.1
lambda_reg: 0.1
lambda_depth_lidar: 0.01
lambda_l1: 3.
track_position_lr_delay_mult: 0.01
track_position_lr_init: 0.005
track_position_lr_final: 5.0e-5
track_position_max_steps: 30000
track_rotation_lr_delay_mult: 0.01
track_rotation_lr_init: 0.001
track_rotation_lr_final: 1.0e-5
track_rotation_max_steps: 30000
render:
fps: 30
================================================
FILE: configs/experiments_waymo/waymo_val_150.yaml
================================================
task: waymo_exp
source_path: ./data/waymo/validation/150
exp_name: waymo_val_150
data:
split_train: -1
split_test: 4
type: Waymo
white_background: false
selected_frames: [96, 197]
cameras: [0]
use_tracker: true
extent: 20
use_colmap: true
box_scale: 1.5
model:
gaussian:
sh_degree: 1
fourier_dim: 5
fourier_scale: 1.
nsg:
include_bkgd: true
include_obj: true
include_sky: true
opt_track: true
sky:
resolution: 1024
white_background: true
train:
iterations: 30000
test_iterations: [7000, 30000]
checkpoint_iterations: [30000]
optim:
prune_box_interval: 100
densification_interval: 100
densify_from_iter: 500
# densify_grad_threshold_bkgd: 0.0006
# densify_grad_abs_bkgd: True
densify_grad_threshold: 0.0002
densify_until_iter: 15000
feature_lr: 0.0025
max_screen_size: 20
min_opacity: 0.005
opacity_lr: 0.05
opacity_reset_interval: 3000
percent_big_ws: 0.1
percent_dense: 0.01
position_lr_delay_mult: 0.01
position_lr_final: 1.6e-06
position_lr_init: 0.00016
position_lr_max_steps: 30000
rotation_lr: 0.001
scaling_lr: 0.005
semantic_lr: 0.01
lambda_dssim: 0.2
lambda_sky: 0.05
lambda_mask: 0.1
lambda_reg: 0.1
lambda_depth_lidar: 0.01
lambda_l1: 3.
track_position_lr_delay_mult: 0.01
track_position_lr_init: 0.005
track_position_lr_final: 5.0e-5
track_position_max_steps: 30000
track_rotation_lr_delay_mult: 0.01
track_rotation_lr_init: 0.001
track_rotation_lr_final: 1.0e-5
track_rotation_max_steps: 30000
render:
fps: 30
================================================
FILE: configs/experiments_waymo/waymo_val_181.yaml
================================================
task: waymo_exp
source_path: ./data/waymo/validation/181
exp_name: waymo_val_181
data:
split_train: -1
split_test: 4
type: Waymo
white_background: true
selected_frames: [0, 160]
cameras: [0]
use_tracker: true
extent: 20
use_colmap: true
model:
gaussian:
sh_degree: 1
fourier_dim: 5
fourier_scale: 1.
nsg:
include_bkgd: true
include_obj: true
include_sky: false
opt_track: true
train:
iterations: 30000
test_iterations: [7000, 30000]
checkpoint_iterations: [30000]
optim:
prune_box_interval: 100
densification_interval: 100
densify_from_iter: 500
densify_grad_threshold: 0.0002
densify_until_iter: 15000
feature_lr: 0.0025
max_screen_size: 20
min_opacity: 0.005
opacity_lr: 0.05
opacity_reset_interval: 3000
percent_big_ws: 0.1
percent_dense: 0.01
position_lr_delay_mult: 0.01
position_lr_final: 1.6e-06
position_lr_init: 0.00016
position_lr_max_steps: 30000
rotation_lr: 0.001
scaling_lr: 0.005
semantic_lr: 0.01
lambda_dssim: 0.2
lambda_mask: 0.1
lambda_reg: 0.1
lambda_depth_lidar: 0.01
lambda_l1: 3.
track_position_lr_delay_mult: 0.01
track_position_lr_init: 0.005
track_position_lr_final: 5.0e-5
track_position_max_steps: 30000
track_rotation_lr_delay_mult: 0.01
track_rotation_lr_init: 0.001
track_rotation_lr_final: 1.0e-5
track_rotation_max_steps: 30000
render:
fps: 30
================================================
FILE: lib/config/__init__.py
================================================
from .config import cfg, args
================================================
FILE: lib/config/config.py
================================================
from .yacs import CfgNode as CN
import argparse
import os
import numpy as np
from lib.utils.cfg_utils import make_cfg
cfg = CN()
cfg.workspace = os.environ['PWD']
cfg.loaded_iter = -1
cfg.ip = '127.0.0.1'
cfg.port = 6009
cfg.data_device = 'cuda'
cfg.mode = 'train'
cfg.task = 'hello' # task folder name
cfg.exp_name = 'test' # experiment folder name
cfg.gpus = [0] # list of gpus to use
cfg.debug = False
cfg.resume = True # If set to True, resume training from the last checkpoint.
cfg.source_path = ''
cfg.model_path = ''
cfg.record_dir = None
cfg.resolution = -1
cfg.resolution_scales = [1]
cfg.eval = CN()
cfg.eval.skip_train = False
cfg.eval.skip_test = False
cfg.eval.eval_train = False
cfg.eval.eval_test = True
cfg.eval.quiet = False
cfg.train = CN()
cfg.train.debug_from = -1
cfg.train.detect_anomaly = False
cfg.train.test_iterations = [7000, 30000]
cfg.train.save_iterations = [7000, 30000]
cfg.train.iterations = 30000
cfg.train.quiet = False
cfg.train.checkpoint_iterations = [30000]
cfg.train.start_checkpoint = None
cfg.train.importance_sampling = False
cfg.optim = CN()
# learning rate
cfg.optim.position_lr_init = 0.00016 # position_lr_init_{bkgd, obj ...}, similar to the following
cfg.optim.position_lr_final = 0.0000016
cfg.optim.position_lr_delay_mult = 0.01
cfg.optim.position_lr_max_steps = 30000
cfg.optim.feature_lr = 0.0025
cfg.optim.opacity_lr = 0.05
cfg.optim.scaling_lr = 0.005
cfg.optim.rotation_lr = 0.001
# densification and pruning
cfg.optim.percent_dense = 0.01
cfg.optim.densification_interval = 100
cfg.optim.opacity_reset_interval = 3000
cfg.optim.densify_from_iter = 500
cfg.optim.densify_until_iter = 15000
cfg.optim.densify_grad_threshold = 0.0002 # densify_grad_threshold_{bkgd, obj ...}
cfg.optim.densify_grad_abs_bkgd = False # densification strategy from AbsGS
cfg.optim.densify_grad_abs_obj = False
cfg.optim.max_screen_size = 20
cfg.optim.min_opacity = 0.005
cfg.optim.percent_big_ws = 0.1
# loss weight
cfg.optim.lambda_l1 = 1.
cfg.optim.lambda_dssim = 0.2
cfg.optim.lambda_sky = 0.
cfg.optim.lambda_sky_scale = []
cfg.optim.lambda_semantic = 0.
cfg.optim.lambda_reg = 0.
cfg.optim.lambda_depth_lidar = 0.
cfg.optim.lambda_depth_mono = 0.
cfg.optim.lambda_normal_mono = 0.
cfg.optim.lambda_color_correction = 0.
cfg.optim.lambda_pose_correction = 0.
cfg.optim.lambda_scale_flatten = 0.
cfg.optim.lambda_opacity_sparse = 0.
cfg.model = CN()
cfg.model.gaussian = CN()
cfg.model.gaussian.sh_degree = 3
cfg.model.gaussian.fourier_dim = 1 # fourier spherical harmonics dimension
cfg.model.gaussian.fourier_scale = 1.
cfg.model.gaussian.flip_prob = 0. # symmetry prior for rigid objects, flip gaussians with this probability during training
cfg.model.gaussian.semantic_mode = 'logits'
cfg.model.nsg = CN()
cfg.model.nsg.include_bkgd = True # include background
cfg.model.nsg.include_obj = True # include object
cfg.model.nsg.include_sky = False # include sky cubemap
cfg.model.nsg.opt_track = True # tracklets optimization
cfg.model.sky = CN()
cfg.model.sky.resolution = 1024
cfg.model.sky.white_background = True
#### Note: We have not fully tested this.
cfg.model.use_color_correction = False # If set to True, learn transformation matrixs for appearance embedding
cfg.model.color_correction = CN()
cfg.model.color_correction.mode = 'image' # If set to 'image', learn separate embedding for each image. If set to 'sensor', learn a single embedding for all images captured by one camera senosor.
cfg.model.color_correction.use_mlp = False # If set to True, regress embedding from extrinsic by a mlp. Otherwise, define the embedding explicitly.
cfg.model.color_correction.use_sky = False # If set to True, using spparate embedding for background and sky
# Alternative choice from GOF: https://github.com/autonomousvision/gaussian-opacity-fields/blob/main/scene/appearance_network.py
cfg.model.use_pose_correction = False # If set to True, use pose correction for camera poses.
cfg.model.pose_correction = CN()
cfg.model.pose_correction.mode = 'image' # If set to 'image', learn separate correction matrix for each image. If set to 'frame', learn a single correction matrix for all images corresponding to the same frame timestamp.
####
cfg.data = CN()
cfg.data.white_background = False # If set to True, use white background. Should be False when using sky cubemap.
cfg.data.use_colmap_pose = False # If set to True, use colmap to recalibrate camera poses as input (rigid bundle adjustment now).
cfg.data.filter_colmap = False # If set to True, filter out SfM points by camera poses.
cfg.data.box_scale = 1.0 # Scale the bounding box by this factor.
cfg.data.split_test = -1
cfg.data.shuffle = True
cfg.data.eval = True
cfg.data.type = 'Colmap'
cfg.data.images = 'images'
cfg.data.use_semantic = False
cfg.data.use_mono_depth = False
cfg.data.use_mono_normal = False
cfg.data.use_colmap = True
# data.load_pcd_from: Load the initialization point cloud from a previous experiment without generation.
# data.extent: radius of the scene, we recommend 10 - 20 meters.
# data.sphere_scale: Scale the sphere radius by this factor.
# data.regenerate_pcd: Regenerate the initialization point cloud.
cfg.render = CN()
cfg.render.convert_SHs_python = False
cfg.render.compute_cov3D_python = False
cfg.render.debug = False
cfg.render.scaling_modifier = 1.0
cfg.render.fps = 24
cfg.render.render_normal = False
cfg.render.save_video = True
cfg.render.save_image = True
cfg.render.coord = 'world' # ['world', 'vehicle']
cfg.render.concat_cameras = []
cfg.viewer = CN()
cfg.viewer.frame_id = 0 # Select the frame_id (start from 0) to save for viewer
parser = argparse.ArgumentParser()
parser.add_argument("--config", default="configs/default.yaml", type=str)
parser.add_argument("--mode", type=str, default="")
parser.add_argument('--det', type=str, default='')
parser.add_argument('--local_rank', type=int, default=0)
parser.add_argument("opts", default=None, nargs=argparse.REMAINDER)
args = parser.parse_args()
cfg = make_cfg(cfg, args)
================================================
FILE: lib/config/yacs.py
================================================
# Copyright (c) 2018-present, Facebook, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
##############################################################################
"""YACS -- Yet Another Configuration System is designed to be a simple
configuration management system for academic and industrial research
projects.
See README.md for usage and examples.
"""
import copy
import io
import logging
import os
import sys
from ast import literal_eval
import yaml
# Flag for py2 and py3 compatibility to use when separate code paths are necessary
# When _PY2 is False, we assume Python 3 is in use
_PY2 = sys.version_info.major == 2
# Filename extensions for loading configs from files
_YAML_EXTS = {"", ".yaml", ".yml"}
_PY_EXTS = {".py"}
# py2 and py3 compatibility for checking file object type
# We simply use this to infer py2 vs py3
if _PY2:
_FILE_TYPES = (file, io.IOBase)
else:
_FILE_TYPES = (io.IOBase,)
# CfgNodes can only contain a limited set of valid types
_VALID_TYPES = {tuple, list, str, int, float, bool, type(None)}
# py2 allow for str and unicode
if _PY2:
_VALID_TYPES = _VALID_TYPES.union({unicode}) # noqa: F821
# Utilities for importing modules from file paths
if _PY2:
# imp is available in both py2 and py3 for now, but is deprecated in py3
import imp
else:
import importlib.util
logger = logging.getLogger(__name__)
class CfgNode(dict):
"""
CfgNode represents an internal node in the configuration tree. It's a simple
dict-like container that allows for attribute-based access to keys.
"""
IMMUTABLE = "__immutable__"
DEPRECATED_KEYS = "__deprecated_keys__"
RENAMED_KEYS = "__renamed_keys__"
NEW_ALLOWED = "__new_allowed__"
def __init__(self, init_dict=None, key_list=None, new_allowed=True):
"""
Args:
init_dict (dict): the possibly-nested dictionary to initailize the CfgNode.
key_list (list[str]): a list of names which index this CfgNode from the root.
Currently only used for logging purposes.
new_allowed (bool): whether adding new key is allowed when merging with
other configs.
"""
# Recursively convert nested dictionaries in init_dict into CfgNodes
init_dict = {} if init_dict is None else init_dict
key_list = [] if key_list is None else key_list
init_dict = self._create_config_tree_from_dict(init_dict, key_list)
super(CfgNode, self).__init__(init_dict)
# Manage if the CfgNode is frozen or not
self.__dict__[CfgNode.IMMUTABLE] = False
# Deprecated options
# If an option is removed from the code and you don't want to break existing
# yaml configs, you can add the full config key as a string to the set below.
self.__dict__[CfgNode.DEPRECATED_KEYS] = set()
# Renamed options
# If you rename a config option, record the mapping from the old name to the new
# name in the dictionary below. Optionally, if the type also changed, you can
# make the value a tuple that specifies first the renamed key and then
# instructions for how to edit the config file.
self.__dict__[CfgNode.RENAMED_KEYS] = {
# 'EXAMPLE.OLD.KEY': 'EXAMPLE.NEW.KEY', # Dummy example to follow
# 'EXAMPLE.OLD.KEY': ( # A more complex example to follow
# 'EXAMPLE.NEW.KEY',
# "Also convert to a tuple, e.g., 'foo' -> ('foo',) or "
# + "'foo:bar' -> ('foo', 'bar')"
# ),
}
# Allow new attributes after initialisation
self.__dict__[CfgNode.NEW_ALLOWED] = new_allowed
@classmethod
def _create_config_tree_from_dict(cls, dic, key_list):
"""
Create a configuration tree using the given dict.
Any dict-like objects inside dict will be treated as a new CfgNode.
Args:
dic (dict):
key_list (list[str]): a list of names which index this CfgNode from the root.
Currently only used for logging purposes.
"""
dic = copy.deepcopy(dic)
for k, v in dic.items():
if isinstance(v, dict):
# Convert dict to CfgNode
dic[k] = cls(v, key_list=key_list + [k])
else:
# Check for valid leaf type or nested CfgNode
_assert_with_logging(
_valid_type(v, allow_cfg_node=False),
"Key {} with value {} is not a valid type; valid types: {}".format(
".".join(key_list + [str(k)]), type(v), _VALID_TYPES
),
)
return dic
def __getattr__(self, name):
if name in self:
return self[name]
else:
raise AttributeError(name)
def __setattr__(self, name, value):
if self.is_frozen():
raise AttributeError(
"Attempted to set {} to {}, but CfgNode is immutable".format(
name, value
)
)
_assert_with_logging(
name not in self.__dict__,
"Invalid attempt to modify internal CfgNode state: {}".format(name),
)
_assert_with_logging(
_valid_type(value, allow_cfg_node=True),
"Invalid type {} for key {}; valid types = {}".format(
type(value), name, _VALID_TYPES
),
)
self[name] = value
def __str__(self):
def _indent(s_, num_spaces):
s = s_.split("\n")
if len(s) == 1:
return s_
first = s.pop(0)
s = [(num_spaces * " ") + line for line in s]
s = "\n".join(s)
s = first + "\n" + s
return s
r = ""
s = []
for k, v in sorted(self.items()):
seperator = "\n" if isinstance(v, CfgNode) else " "
attr_str = "{}:{}{}".format(str(k), seperator, str(v))
attr_str = _indent(attr_str, 2)
s.append(attr_str)
r += "\n".join(s)
return r
def __repr__(self):
return "{}({})".format(self.__class__.__name__, super(CfgNode, self).__repr__())
def dump(self, **kwargs):
"""Dump to a string."""
def convert_to_dict(cfg_node, key_list):
if not isinstance(cfg_node, CfgNode):
_assert_with_logging(
_valid_type(cfg_node),
"Key {} with value {} is not a valid type; valid types: {}".format(
".".join(key_list), type(cfg_node), _VALID_TYPES
),
)
return cfg_node
else:
cfg_dict = dict(cfg_node)
for k, v in cfg_dict.items():
cfg_dict[k] = convert_to_dict(v, key_list + [k])
return cfg_dict
self_as_dict = convert_to_dict(self, [])
return yaml.safe_dump(self_as_dict, **kwargs)
def merge_from_file(self, cfg_filename):
"""Load a yaml config file and merge it this CfgNode."""
with open(cfg_filename, "r") as f:
cfg = self.load_cfg(f)
self.merge_from_other_cfg(cfg)
def merge_from_other_cfg(self, cfg_other):
"""Merge `cfg_other` into this CfgNode."""
_merge_a_into_b(cfg_other, self, self, [])
def merge_from_list(self, cfg_list):
"""Merge config (keys, values) in a list (e.g., from command line) into
this CfgNode. For example, `cfg_list = ['FOO.BAR', 0.5]`.
"""
_assert_with_logging(
len(cfg_list) % 2 == 0,
"Override list has odd length: {}; it must be a list of pairs".format(
cfg_list
),
)
root = self
for full_key, v in zip(cfg_list[0::2], cfg_list[1::2]):
if root.key_is_deprecated(full_key):
continue
if root.key_is_renamed(full_key):
root.raise_key_rename_error(full_key)
key_list = full_key.split(".")
d = self
for subkey in key_list[:-1]:
_assert_with_logging(
subkey in d, "Non-existent key: {}".format(full_key)
)
d = d[subkey]
subkey = key_list[-1]
value = self._decode_cfg_value(v)
if subkey in d:
value = _check_and_coerce_cfg_value_type(value, d[subkey], subkey, full_key)
d[subkey] = value
def freeze(self):
"""Make this CfgNode and all of its children immutable."""
self._immutable(True)
def defrost(self):
"""Make this CfgNode and all of its children mutable."""
self._immutable(False)
def is_frozen(self):
"""Return mutability."""
return self.__dict__[CfgNode.IMMUTABLE]
def _immutable(self, is_immutable):
"""Set immutability to is_immutable and recursively apply the setting
to all nested CfgNodes.
"""
self.__dict__[CfgNode.IMMUTABLE] = is_immutable
# Recursively set immutable state
for v in self.__dict__.values():
if isinstance(v, CfgNode):
v._immutable(is_immutable)
for v in self.values():
if isinstance(v, CfgNode):
v._immutable(is_immutable)
def clone(self):
"""Recursively copy this CfgNode."""
return copy.deepcopy(self)
def register_deprecated_key(self, key):
"""Register key (e.g. `FOO.BAR`) a deprecated option. When merging deprecated
keys a warning is generated and the key is ignored.
"""
_assert_with_logging(
key not in self.__dict__[CfgNode.DEPRECATED_KEYS],
"key {} is already registered as a deprecated key".format(key),
)
self.__dict__[CfgNode.DEPRECATED_KEYS].add(key)
def register_renamed_key(self, old_name, new_name, message=None):
"""Register a key as having been renamed from `old_name` to `new_name`.
When merging a renamed key, an exception is thrown alerting to user to
the fact that the key has been renamed.
"""
_assert_with_logging(
old_name not in self.__dict__[CfgNode.RENAMED_KEYS],
"key {} is already registered as a renamed cfg key".format(old_name),
)
value = new_name
if message:
value = (new_name, message)
self.__dict__[CfgNode.RENAMED_KEYS][old_name] = value
def key_is_deprecated(self, full_key):
"""Test if a key is deprecated."""
if full_key in self.__dict__[CfgNode.DEPRECATED_KEYS]:
logger.warning("Deprecated config key (ignoring): {}".format(full_key))
return True
return False
def key_is_renamed(self, full_key):
"""Test if a key is renamed."""
return full_key in self.__dict__[CfgNode.RENAMED_KEYS]
def raise_key_rename_error(self, full_key):
new_key = self.__dict__[CfgNode.RENAMED_KEYS][full_key]
if isinstance(new_key, tuple):
msg = " Note: " + new_key[1]
new_key = new_key[0]
else:
msg = ""
raise KeyError(
"Key {} was renamed to {}; please update your config.{}".format(
full_key, new_key, msg
)
)
def is_new_allowed(self):
return self.__dict__[CfgNode.NEW_ALLOWED]
def set_new_allowed(self, is_new_allowed):
"""
Set this config (and recursively its subconfigs) to allow merging
new keys from other configs.
"""
self.__dict__[CfgNode.NEW_ALLOWED] = is_new_allowed
# Recursively set new_allowed state
for v in self.__dict__.values():
if isinstance(v, CfgNode):
v.set_new_allowed(is_new_allowed)
for v in self.values():
if isinstance(v, CfgNode):
v.set_new_allowed(is_new_allowed)
@classmethod
def load_cfg(cls, cfg_file_obj_or_str):
"""
Load a cfg.
Args:
cfg_file_obj_or_str (str or file):
Supports loading from:
- A file object backed by a YAML file
- A file object backed by a Python source file that exports an attribute
"cfg" that is either a dict or a CfgNode
- A string that can be parsed as valid YAML
"""
_assert_with_logging(
isinstance(cfg_file_obj_or_str, _FILE_TYPES + (str,)),
"Expected first argument to be of type {} or {}, but it was {}".format(
_FILE_TYPES, str, type(cfg_file_obj_or_str)
),
)
if isinstance(cfg_file_obj_or_str, str):
return cls._load_cfg_from_yaml_str(cfg_file_obj_or_str)
elif isinstance(cfg_file_obj_or_str, _FILE_TYPES):
return cls._load_cfg_from_file(cfg_file_obj_or_str)
else:
raise NotImplementedError("Impossible to reach here (unless there's a bug)")
@classmethod
def _load_cfg_from_file(cls, file_obj):
"""Load a config from a YAML file or a Python source file."""
_, file_extension = os.path.splitext(file_obj.name)
if file_extension in _YAML_EXTS:
return cls._load_cfg_from_yaml_str(file_obj.read())
elif file_extension in _PY_EXTS:
return cls._load_cfg_py_source(file_obj.name)
else:
raise Exception(
"Attempt to load from an unsupported file type {}; "
"only {} are supported".format(file_obj, _YAML_EXTS.union(_PY_EXTS))
)
@classmethod
def _load_cfg_from_yaml_str(cls, str_obj):
"""Load a config from a YAML string encoding."""
cfg_as_dict = yaml.safe_load(str_obj)
return cls(cfg_as_dict)
@classmethod
def _load_cfg_py_source(cls, filename):
"""Load a config from a Python source file."""
module = _load_module_from_file("yacs.config.override", filename)
_assert_with_logging(
hasattr(module, "cfg"),
"Python module from file {} must have 'cfg' attr".format(filename),
)
VALID_ATTR_TYPES = {dict, CfgNode}
_assert_with_logging(
type(module.cfg) in VALID_ATTR_TYPES,
"Imported module 'cfg' attr must be in {} but is {} instead".format(
VALID_ATTR_TYPES, type(module.cfg)
),
)
return cls(module.cfg)
@classmethod
def _decode_cfg_value(cls, value):
"""
Decodes a raw config value (e.g., from a yaml config files or command
line argument) into a Python object.
If the value is a dict, it will be interpreted as a new CfgNode.
If the value is a str, it will be evaluated as literals.
Otherwise it is returned as-is.
"""
# Configs parsed from raw yaml will contain dictionary keys that need to be
# converted to CfgNode objects
if isinstance(value, dict):
return cls(value)
# All remaining processing is only applied to strings
if not isinstance(value, str):
return value
# Try to interpret `value` as a:
# string, number, tuple, list, dict, boolean, or None
try:
value = literal_eval(value)
# The following two excepts allow v to pass through when it represents a
# string.
#
# Longer explanation:
# The type of v is always a string (before calling literal_eval), but
# sometimes it *represents* a string and other times a data structure, like
# a list. In the case that v represents a string, what we got back from the
# yaml parser is 'foo' *without quotes* (so, not '"foo"'). literal_eval is
# ok with '"foo"', but will raise a ValueError if given 'foo'. In other
# cases, like paths (v = 'foo/bar' and not v = '"foo/bar"'), literal_eval
# will raise a SyntaxError.
except ValueError:
pass
except SyntaxError:
pass
return value
load_cfg = (
CfgNode.load_cfg
) # keep this function in global scope for backward compatibility
def _valid_type(value, allow_cfg_node=False):
return (type(value) in _VALID_TYPES) or (
allow_cfg_node and isinstance(value, CfgNode)
)
def _merge_a_into_b(a, b, root, key_list):
"""Merge config dictionary a into config dictionary b, clobbering the
options in b whenever they are also specified in a.
"""
_assert_with_logging(
isinstance(a, CfgNode),
"`a` (cur type {}) must be an instance of {}".format(type(a), CfgNode),
)
_assert_with_logging(
isinstance(b, CfgNode),
"`b` (cur type {}) must be an instance of {}".format(type(b), CfgNode),
)
for k, v_ in a.items():
full_key = ".".join(key_list + [k])
v = copy.deepcopy(v_)
v = b._decode_cfg_value(v)
if k in b:
v = _check_and_coerce_cfg_value_type(v, b[k], k, full_key)
# Recursively merge dicts
if isinstance(v, CfgNode):
try:
_merge_a_into_b(v, b[k], root, key_list + [k])
except BaseException:
raise
else:
b[k] = v
elif b.is_new_allowed():
b[k] = v
else:
if root.key_is_deprecated(full_key):
continue
elif root.key_is_renamed(full_key):
root.raise_key_rename_error(full_key)
else:
raise KeyError("Non-existent config key: {}".format(full_key))
def _check_and_coerce_cfg_value_type(replacement, original, key, full_key):
"""Checks that `replacement`, which is intended to replace `original` is of
the right type. The type is correct if it matches exactly or is one of a few
cases in which the type can be easily coerced.
"""
original_type = type(original)
replacement_type = type(replacement)
# The types must match (with some exceptions)
if replacement_type == original_type:
return replacement
# If either of them is None, allow type conversion to one of the valid types
if (replacement_type == type(None) and original_type in _VALID_TYPES) or (
original_type == type(None) and replacement_type in _VALID_TYPES
):
return replacement
# Cast replacement from from_type to to_type if the replacement and original
# types match from_type and to_type
def conditional_cast(from_type, to_type):
if replacement_type == from_type and original_type == to_type:
return True, to_type(replacement)
else:
return False, None
# Conditionally casts
# list <-> tuple
casts = [(tuple, list), (list, tuple)]
# For py2: allow converting from str (bytes) to a unicode string
try:
casts.append((str, unicode)) # noqa: F821
except Exception:
pass
for (from_type, to_type) in casts:
converted, converted_value = conditional_cast(from_type, to_type)
if converted:
return converted_value
raise ValueError(
"Type mismatch ({} vs. {}) with values ({} vs. {}) for config "
"key: {}".format(
original_type, replacement_type, original, replacement, full_key
)
)
def _assert_with_logging(cond, msg):
if not cond:
logger.debug(msg)
assert cond, msg
def _load_module_from_file(name, filename):
if _PY2:
module = imp.load_source(name, filename)
else:
spec = importlib.util.spec_from_file_location(name, filename)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
return module
================================================
FILE: lib/datasets/base_readers.py
================================================
import numpy as np
from typing import NamedTuple
from lib.utils.graphics_utils import getWorld2View2, focal2fov, fov2focal, BasicPointCloud
from plyfile import PlyData, PlyElement
class CameraInfo(NamedTuple):
uid: int
R: np.array
T: np.array
FovY: np.array
FovX: np.array
K: np.array
image: np.array
image_path: str
image_name: str
width: int
height: int
metadata: dict = dict()
mask: np.array = None
acc_mask: np.array = None
class SceneInfo(NamedTuple):
point_cloud: BasicPointCloud
train_cameras: list
test_cameras: list
nerf_normalization: dict
ply_path: str
metadata: dict = dict()
novel_view_cameras: list = None
def getNerfppNorm(cam_info):
def get_center_and_diag(cam_centers):
cam_centers = np.hstack(cam_centers)
avg_cam_center = np.mean(cam_centers, axis=1, keepdims=True)
center = avg_cam_center
dist = np.linalg.norm(cam_centers - center, axis=0, keepdims=True)
diagonal = np.max(dist)
return center.flatten(), diagonal
cam_centers = []
for cam in cam_info:
W2C = getWorld2View2(cam.R, cam.T)
C2W = np.linalg.inv(W2C)
cam_centers.append(C2W[:3, 3:4])
center, diagonal = get_center_and_diag(cam_centers)
radius = diagonal * 1.1
translate = -center
return {
'translate': translate,
'radius': radius,
'center': center,
}
def get_PCA_Norm(xyz):
from sklearn.decomposition import PCA
pca = PCA()
pca.fit(xyz)
axis = pca.components_[-1]
projected_point_cloud = np.dot(xyz, axis)
min_value = np.min(projected_point_cloud)
max_value = np.max(projected_point_cloud)
radius = (max_value - min_value) / 2
return {
'radius': radius,
}
def get_Sphere_Norm(xyz):
from lib.config import cfg
xyz_max = np.max(xyz, axis=0)
xyz_min = np.min(xyz, axis=0)
center = (xyz_max + xyz_min) / 2
radius = np.linalg.norm(xyz_max - xyz_min) / 2.
scale = cfg.data.get('sphere_scale', 1.0)
radius *= scale
return {
'radius': radius,
'center': center,
}
def fetchPly(path):
plydata = PlyData.read(path)
vertices = plydata['vertex']
positions = np.vstack([vertices['x'], vertices['y'], vertices['z']]).T
colors = np.vstack([vertices['red'], vertices['green'], vertices['blue']]).T / 255.0
normals = np.vstack([vertices['nx'], vertices['ny'], vertices['nz']]).T
return BasicPointCloud(points=positions, colors=colors, normals=normals)
def storePly(path, xyz, rgb):
# set rgb to 0 - 255
if rgb.max() <= 1. and rgb.min() >= 0:
rgb = np.clip(rgb * 255, 0., 255.)
# Define the dtype for the structured array
dtype = [('x', 'f4'), ('y', 'f4'), ('z', 'f4'),
('nx', 'f4'), ('ny', 'f4'), ('nz', 'f4'),
('red', 'u1'), ('green', 'u1'), ('blue', 'u1')]
normals = np.zeros_like(xyz)
elements = np.empty(xyz.shape[0], dtype=dtype)
attributes = np.concatenate((xyz, normals, rgb), axis=1)
elements[:] = list(map(tuple, attributes))
# Create the PlyData object and write to file
vertex_element = PlyElement.describe(elements, 'vertex')
ply_data = PlyData([vertex_element])
ply_data.write(path)
================================================
FILE: lib/datasets/blender_readers.py
================================================
import os
import numpy as np
import json
from PIL import Image
from lib.utils.graphics_utils import getWorld2View2, focal2fov, fov2focal, BasicPointCloud
from lib.config import cfg
from pathlib import Path
from lib.datasets.base_readers import CameraInfo, SceneInfo, getNerfppNorm, fetchPly, storePly
from lib.utils.sh_utils import SH2RGB
def readCamerasFromTransforms(path, transformsfile, white_background, extension=".png"):
cam_infos = []
with open(os.path.join(path, transformsfile)) as json_file:
contents = json.load(json_file)
fovx = contents["camera_angle_x"]
frames = contents["frames"]
for idx, frame in enumerate(frames):
cam_name = os.path.join(path, frame["file_path"] + extension)
matrix = np.linalg.inv(np.array(frame["transform_matrix"]))
R = -np.transpose(matrix[:3,:3])
R[:,0] = -R[:,0]
T = -matrix[:3, 3]
image_path = os.path.join(path, cam_name)
image_name = Path(cam_name).stem
image = Image.open(image_path)
im_data = np.array(image.convert("RGBA"))
bg = np.array([1,1,1]) if white_background else np.array([0, 0, 0])
norm_data = im_data / 255.0
arr = norm_data[:,:,:3] * norm_data[:, :, 3:4] + bg * (1 - norm_data[:, :, 3:4])
image = Image.fromarray(np.array(arr*255.0, dtype=np.byte), "RGB")
fovy = focal2fov(fov2focal(fovx, image.size[0]), image.size[1])
FovY = fovy
FovX = fovx
cam_infos.append(CameraInfo(uid=idx, R=R, T=T, FovY=FovY, FovX=FovX, image=image,
image_path=image_path, image_name=image_name, width=image.size[0], height=image.size[1]))
return cam_infos
def readNerfSyntheticInfo(path, eval, extension=".png", **kwargs):
white_background = cfg.data.white_background
print("Reading Training Transforms")
train_cam_infos = readCamerasFromTransforms(path, "transforms_train.json", white_background, extension)
print("Reading Test Transforms")
test_cam_infos = readCamerasFromTransforms(path, "transforms_test.json", white_background, extension)
if not eval:
train_cam_infos.extend(test_cam_infos)
test_cam_infos = []
nerf_normalization = getNerfppNorm(train_cam_infos)
ply_path = os.path.join(path, "points3d.ply")
if not os.path.exists(ply_path):
# Since this data set has no colmap data, we start with random points
num_pts = 100_000
print(f"Generating random point cloud ({num_pts})...")
# We create random points inside the bounds of the synthetic Blender scenes
xyz = np.random.random((num_pts, 3)) * 2.6 - 1.3
shs = np.random.random((num_pts, 3)) / 255.0
pcd = BasicPointCloud(points=xyz, colors=SH2RGB(shs), normals=np.zeros((num_pts, 3)))
storePly(ply_path, xyz, SH2RGB(shs) * 255)
try:
pcd = fetchPly(ply_path)
except:
pcd = None
scene_info = SceneInfo(point_cloud=pcd,
train_cameras=train_cam_infos,
test_cameras=test_cam_infos,
nerf_normalization=nerf_normalization,
ply_path=ply_path)
return scene_info
================================================
FILE: lib/datasets/colmap_readers.py
================================================
import os
import sys
import numpy as np
from PIL import Image
from lib.utils.graphics_utils import getWorld2View2, focal2fov, fov2focal, BasicPointCloud
from lib.utils.colmap_utils import read_extrinsics_text, read_intrinsics_text, qvec2rotmat, \
read_extrinsics_binary, read_intrinsics_binary, read_points3D_binary, read_points3D_text
from lib.config import cfg
from lib.datasets.base_readers import CameraInfo, SceneInfo, getNerfppNorm, fetchPly, storePly
def readColmapCameras(cam_extrinsics, cam_intrinsics, images_folder):
cam_infos = []
for idx, key in enumerate(cam_extrinsics):
sys.stdout.write('\r')
# the exact output you're looking for:
sys.stdout.write("Reading camera {}/{}".format(idx+1, len(cam_extrinsics)))
sys.stdout.flush()
extr = cam_extrinsics[key]
intr = cam_intrinsics[extr.camera_id]
height = intr.height
width = intr.width
uid = intr.id
R = np.transpose(qvec2rotmat(extr.qvec))
T = np.array(extr.tvec)
if intr.model == "SIMPLE_PINHOLE":
focal_length = intr.params[0]
cx = intr.params[1]
cy = intr.params[2]
FovY = focal2fov(focal_length, height)
FovX = focal2fov(focal_length, width)
K = np.array([[focal_length, 0, cx], [0, focal_length, cy], [0, 0, 1]]).astype(np.float32)
elif intr.model == "PINHOLE":
focal_length_x = intr.params[0]
focal_length_y = intr.params[1]
cx = intr.params[2]
cy = intr.params[3]
FovY = focal2fov(focal_length_y, height)
FovX = focal2fov(focal_length_x, width)
K = np.array([[focal_length_x, 0, cx], [0, focal_length_y, cy], [0, 0, 1]]).astype(np.float32)
else:
assert False, "Colmap camera model not handled: only undistorted datasets (PINHOLE or SIMPLE_PINHOLE cameras) supported!"
image_path = os.path.join(images_folder, os.path.basename(extr.name))
image_name = os.path.basename(image_path).split(".")[0]
image = Image.open(image_path)
cam_info = CameraInfo(uid=uid, R=R, T=T, FovY=FovY, FovX=FovX, K=K,
image=image, image_path=image_path, image_name=image_name,
width=width, height=height)
cam_infos.append(cam_info)
sys.stdout.write('\n')
return cam_infos
def readColmapSceneInfo(path, images='images', split_test=8, **kwargs):
colmap_basedir = os.path.join(path, 'sparse/0')
if not os.path.exists(colmap_basedir):
colmap_basedir = os.path.join(path, 'sparse')
try:
cameras_extrinsic_file = os.path.join(colmap_basedir, "images.bin")
cameras_intrinsic_file = os.path.join(colmap_basedir, "cameras.bin")
cam_extrinsics = read_extrinsics_binary(cameras_extrinsic_file)
cam_intrinsics = read_intrinsics_binary(cameras_intrinsic_file)
except:
cameras_extrinsic_file = os.path.join(colmap_basedir, "images.txt")
cameras_intrinsic_file = os.path.join(colmap_basedir, "cameras.txt")
cam_extrinsics = read_extrinsics_text(cameras_extrinsic_file)
cam_intrinsics = read_intrinsics_text(cameras_intrinsic_file)
reading_dir = images
cam_infos_unsorted = readColmapCameras(cam_extrinsics=cam_extrinsics, cam_intrinsics=cam_intrinsics, images_folder=os.path.join(path, reading_dir))
cam_infos = sorted(cam_infos_unsorted.copy(), key = lambda x : x.image_name)
if split_test == -1:
train_cam_infos = cam_infos
test_cam_infos = []
else:
train_cam_infos = [c for idx, c in enumerate(cam_infos) if idx % split_test != 0]
test_cam_infos = [c for idx, c in enumerate(cam_infos) if idx % split_test == 0]
nerf_normalization = getNerfppNorm(train_cam_infos)
ply_path = os.path.join(colmap_basedir, "points3D.ply")
bin_path = os.path.join(colmap_basedir, "points3D.bin")
txt_path = os.path.join(colmap_basedir, "points3D.txt")
if not os.path.exists(ply_path):
print("Converting point3d.bin to .ply, will happen only the first time you open the scene.")
try:
xyz, rgb, _ = read_points3D_binary(bin_path)
except:
xyz, rgb, _ = read_points3D_text(txt_path)
storePly(ply_path, xyz, rgb)
try:
pcd = fetchPly(ply_path)
except:
pcd = None
scene_info = SceneInfo(point_cloud=pcd,
train_cameras=train_cam_infos,
test_cameras=test_cam_infos,
nerf_normalization=nerf_normalization,
ply_path=ply_path)
return scene_info
================================================
FILE: lib/datasets/dataset.py
================================================
import os
import random
import json
from lib.utils.camera_utils import camera_to_JSON, cameraList_from_camInfos
from lib.config import cfg
from lib.datasets.base_readers import storePly, SceneInfo
from lib.datasets.colmap_readers import readColmapSceneInfo
from lib.datasets.blender_readers import readNerfSyntheticInfo
from lib.datasets.waymo_full_readers import readWaymoFullInfo
sceneLoadTypeCallbacks = {
"Colmap": readColmapSceneInfo,
"Blender" : readNerfSyntheticInfo,
"Waymo": readWaymoFullInfo,
}
class Dataset():
def __init__(self):
self.cfg = cfg.data
self.model_path = cfg.model_path
self.source_path = cfg.source_path
self.images = self.cfg.images
self.train_cameras = {}
self.test_cameras = {}
dataset_type = cfg.data.get('type', "Colmap")
assert dataset_type in sceneLoadTypeCallbacks.keys(), 'Could not recognize scene type!'
scene_info: SceneInfo = sceneLoadTypeCallbacks[dataset_type](self.source_path, **cfg.data)
if cfg.mode == 'train':
print(f'Saving input pointcloud to {os.path.join(self.model_path, "input.ply")}')
pcd = scene_info.point_cloud
storePly(os.path.join(self.model_path, "input.ply"), pcd.points, pcd.colors)
json_cams = []
camlist = []
if scene_info.test_cameras:
camlist.extend(scene_info.test_cameras)
if scene_info.train_cameras:
camlist.extend(scene_info.train_cameras)
for id, cam in enumerate(camlist):
json_cams.append(camera_to_JSON(id, cam))
print(f'Saving input camera to {os.path.join(self.model_path, "cameras.json")}')
with open(os.path.join(self.model_path, "cameras.json"), 'w') as file:
json.dump(json_cams, file)
self.scene_info = scene_info
if self.cfg.shuffle and cfg.mode == 'train':
random.shuffle(self.scene_info.train_cameras) # Multi-res consistent random shuffling
random.shuffle(self.scene_info.test_cameras) # Multi-res consistent random shuffling
for resolution_scale in cfg.resolution_scales:
print("Loading Training Cameras")
self.train_cameras[resolution_scale] = cameraList_from_camInfos(self.scene_info.train_cameras, resolution_scale)
print("Loading Test Cameras")
self.test_cameras[resolution_scale] = cameraList_from_camInfos(self.scene_info.test_cameras, resolution_scale)
================================================
FILE: lib/datasets/waymo_full_readers.py
================================================
from lib.utils.waymo_utils import generate_dataparser_outputs
from lib.utils.graphics_utils import focal2fov, BasicPointCloud
from lib.utils.data_utils import get_val_frames
from lib.datasets.base_readers import CameraInfo, SceneInfo, getNerfppNorm, fetchPly, get_PCA_Norm, get_Sphere_Norm
from lib.config import cfg
from tqdm import tqdm
from PIL import Image
import os
import numpy as np
import cv2
import sys
import copy
import shutil
sys.path.append(os.getcwd())
def readWaymoFullInfo(path, images='images', split_train=-1, split_test=-1, **kwargs):
selected_frames = cfg.data.get('selected_frames', None)
if cfg.debug:
selected_frames = [0, 0]
if cfg.data.get('load_pcd_from', False) and (cfg.mode == 'train'):
load_dir = os.path.join(cfg.workspace, cfg.data.load_pcd_from, 'input_ply')
save_dir = os.path.join(cfg.model_path, 'input_ply')
os.system(f'rm -rf {save_dir}')
shutil.copytree(load_dir, save_dir)
colmap_dir = os.path.join(cfg.workspace, cfg.data.load_pcd_from, 'colmap')
save_dir = os.path.join(cfg.model_path, 'colmap')
os.system(f'rm -rf {save_dir}')
shutil.copytree(colmap_dir, save_dir)
bkgd_ply_path = os.path.join(cfg.model_path, 'input_ply/points3D_bkgd.ply')
build_pointcloud = (cfg.mode == 'train') and (not os.path.exists(bkgd_ply_path) or cfg.data.get('regenerate_pcd', False))
# dynamic mask
dynamic_mask_dir = os.path.join(path, 'dynamic_mask')
load_dynamic_mask = True
# sky mask
sky_mask_dir = os.path.join(path, 'sky_mask')
if not os.path.exists(sky_mask_dir):
cmd = f'python script/waymo/generate_sky_mask.py --datadir {path}'
print('Generating sky mask')
os.system(cmd)
load_sky_mask = (cfg.mode == 'train')
# lidar depth
lidar_depth_dir = os.path.join(path, 'lidar_depth')
if not os.path.exists(lidar_depth_dir):
cmd = f'python script/waymo/generate_lidar_depth.py --datadir {path}'
print('Generating lidar depth')
os.system(cmd)
load_lidar_depth = (cfg.mode == 'train')
# Optional: monocular normal cue
mono_normal_dir = os.path.join(path, 'mono_normal')
load_mono_normal = cfg.data.use_mono_normal and (cfg.mode == 'train') and os.path.exists(mono_normal_dir)
# Optional: monocular depth cue
mono_depth_dir = os.path.join(path, 'mono_depth')
load_mono_depth = cfg.data.use_mono_depth and (cfg.mode == 'train') and os.path.exists(mono_depth_dir)
output = generate_dataparser_outputs(
datadir=path,
selected_frames=selected_frames,
build_pointcloud=build_pointcloud,
cameras=cfg.data.get('cameras', [0, 1, 2]),
)
exts = output['exts']
ixts = output['ixts']
poses = output['poses']
c2ws = output['c2ws']
image_filenames = output['image_filenames']
obj_tracklets = output['obj_tracklets']
obj_info = output['obj_info']
frames, cams = output['frames'], output['cams']
frames_idx = output['frames_idx']
num_frames = output['num_frames']
cams_timestamps = output['cams_timestamps']
tracklet_timestamps = output['tracklet_timestamps']
obj_bounds = output['obj_bounds']
train_frames, test_frames = get_val_frames(
num_frames,
test_every=split_test if split_test > 0 else None,
train_every=split_train if split_train > 0 else None,
)
scene_metadata = dict()
scene_metadata['obj_tracklets'] = obj_tracklets
scene_metadata['tracklet_timestamps'] = tracklet_timestamps
scene_metadata['obj_meta'] = obj_info
scene_metadata['num_images'] = len(exts)
scene_metadata['num_cams'] = len(cfg.data.cameras)
scene_metadata['num_frames'] = num_frames
camera_timestamps = dict()
for cam in cfg.data.get('cameras', [0, 1, 2]):
camera_timestamps[cam] = dict()
camera_timestamps[cam]['train_timestamps'] = []
camera_timestamps[cam]['test_timestamps'] = []
########################################################################################################################
cam_infos = []
for i in tqdm(range(len(exts))):
# generate pose and image
ext = exts[i]
ixt = ixts[i]
c2w = c2ws[i]
pose = poses[i]
image_path = image_filenames[i]
image_name = os.path.basename(image_path).split('.')[0]
image = Image.open(image_path)
width, height = image.size
fx, fy = ixt[0, 0], ixt[1, 1]
FovY = focal2fov(fx, height)
FovX = focal2fov(fy, width)
# if cfg.render.coord == 'world':
# RT = np.linalg.inv(c2w) # render in world space
# else:
# RT = np.linalg.inv(ext) # render in vehicle space
RT = np.linalg.inv(c2w)
R = RT[:3, :3].T
T = RT[:3, 3]
K = ixt.copy()
metadata = dict()
metadata['frame'] = frames[i]
metadata['cam'] = cams[i]
metadata['frame_idx'] = frames_idx[i]
metadata['ego_pose'] = pose
metadata['extrinsic'] = ext
metadata['timestamp'] = cams_timestamps[i]
if frames_idx[i] in train_frames:
metadata['is_val'] = False
camera_timestamps[cams[i]]['train_timestamps'].append(cams_timestamps[i])
else:
metadata['is_val'] = True
camera_timestamps[cams[i]]['test_timestamps'].append(cams_timestamps[i])
# load dynamic mask
if load_dynamic_mask:
# dynamic_mask_path = os.path.join(dynamic_mask_dir, f'{image_name}.png')
# obj_bound = (cv2.imread(dynamic_mask_path)[..., 0]) > 0.
# obj_bound = Image.fromarray(obj_bound)
metadata['obj_bound'] = Image.fromarray(obj_bounds[i])
# load lidar depth
if load_lidar_depth:
depth_path = os.path.join(path, 'lidar_depth', f'{image_name}.npy')
depth = np.load(depth_path, allow_pickle=True)
if isinstance(depth, np.ndarray):
depth = dict(depth.item())
mask = depth['mask']
value = depth['value']
depth = np.zeros_like(mask).astype(np.float32)
depth[mask] = value
metadata['lidar_depth'] = depth
# load sky mask
if load_sky_mask:
sky_mask_path = os.path.join(sky_mask_dir, f'{image_name}.png')
sky_mask = (cv2.imread(sky_mask_path)[..., 0]) > 0.
sky_mask = Image.fromarray(sky_mask)
metadata['sky_mask'] = sky_mask
# Optional: load monocular normal
if load_mono_normal:
mono_normal_path = os.path.join(mono_normal_dir, f'{image_name}.npy')
mono_normal = np.load(mono_normal_path)
metadata['mono_normal'] = mono_normal
# Optional load midas depth
if load_mono_depth:
mono_depth_path = os.path.join(mono_depth_dir, f'{image_name}.npy')
mono_depth = np.load(mono_depth_path)
metadata['mono_depth'] = mono_depth
mask = None
cam_info = CameraInfo(
uid=i, R=R, T=T, FovY=FovY, FovX=FovX, K=K,
image=image, image_path=image_path, image_name=image_name,
width=width, height=height,
mask=mask,
metadata=metadata)
cam_infos.append(cam_info)
# sys.stdout.write('\n')
train_cam_infos = [cam_info for cam_info in cam_infos if not cam_info.metadata['is_val']]
test_cam_infos = [cam_info for cam_info in cam_infos if cam_info.metadata['is_val']]
for cam in cfg.data.get('cameras', [0, 1, 2]):
camera_timestamps[cam]['train_timestamps'] = sorted(camera_timestamps[cam]['train_timestamps'])
camera_timestamps[cam]['test_timestamps'] = sorted(camera_timestamps[cam]['test_timestamps'])
scene_metadata['camera_timestamps'] = camera_timestamps
novel_view_cam_infos = []
#######################################################################################################################3
# Get scene extent
# 1. Default nerf++ setting
if cfg.mode == 'novel_view':
nerf_normalization = getNerfppNorm(novel_view_cam_infos)
else:
nerf_normalization = getNerfppNorm(train_cam_infos)
# 2. The radius we obtain should not be too small (larger than 10 here)
nerf_normalization['radius'] = max(nerf_normalization['radius'], 10)
# 3. If we have extent set in config, we ignore previous setting
if cfg.data.get('extent', False):
nerf_normalization['radius'] = cfg.data.extent
# 4. We write scene radius back to config
cfg.data.extent = float(nerf_normalization['radius'])
# 5. We write scene center and radius to scene metadata
scene_metadata['scene_center'] = nerf_normalization['center']
scene_metadata['scene_radius'] = nerf_normalization['radius']
print(f'Scene extent: {nerf_normalization["radius"]}')
# Get sphere center
lidar_ply_path = os.path.join(cfg.model_path, 'input_ply/points3D_lidar.ply')
if os.path.exists(lidar_ply_path):
sphere_pcd: BasicPointCloud = fetchPly(lidar_ply_path)
else:
sphere_pcd: BasicPointCloud = fetchPly(bkgd_ply_path)
sphere_normalization = get_Sphere_Norm(sphere_pcd.points)
scene_metadata['sphere_center'] = sphere_normalization['center']
scene_metadata['sphere_radius'] = sphere_normalization['radius']
print(f'Sphere extent: {sphere_normalization["radius"]}')
pcd: BasicPointCloud = fetchPly(bkgd_ply_path)
if cfg.mode == 'train':
point_cloud = pcd
else:
point_cloud = None
bkgd_ply_path = None
scene_info = SceneInfo(
point_cloud=point_cloud,
train_cameras=train_cam_infos,
test_cameras=test_cam_infos,
nerf_normalization=nerf_normalization,
ply_path=bkgd_ply_path,
metadata=scene_metadata,
novel_view_cameras=novel_view_cam_infos,
)
return scene_info
================================================
FILE: lib/models/__init__.py
================================================
================================================
FILE: lib/models/actor_pose.py
================================================
import torch
import torch.nn as nn
import numpy as np
from lib.utils.general_utils import quaternion_raw_multiply, get_expon_lr_func, quaternion_slerp, matrix_to_quaternion
from lib.config import cfg
from lib.utils.camera_utils import Camera
class ActorPose(nn.Module):
def __init__(self, tracklets, tracklet_timestamps, camera_timestamps, obj_info):
# tracklets: [num_frames, max_obj, [track_id, x, y, z, qw, qx, qy, qz]]
# frame_timestamps: [num_frames]
super().__init__()
tracklets = torch.from_numpy(tracklets).float().cuda()
self.track_ids = tracklets[..., 0] # [num_frames, max_obj]
self.input_trans = tracklets[..., 1:4] # [num_frames, max_obj, [x, y, z]]
self.input_rots = tracklets[..., 4:8] # [num_frames, max_obj, [qw, qx, qy, qz]]
self.timestamps = tracklet_timestamps
self.camera_timestamps = camera_timestamps
self.opt_track = cfg.model.nsg.opt_track
if self.opt_track:
self.opt_trans = nn.Parameter(torch.zeros_like(self.input_trans)).requires_grad_(True)
# [num_frames, max_obj, [dx, dy, dz]]
self.opt_rots = nn.Parameter(torch.zeros_like(self.input_rots[..., :1])).requires_grad_(True)
# [num_frames, max_obj, [dtheta]
self.obj_info = obj_info
for track_id in self.obj_info.keys():
self.obj_info[track_id]['track_idx'] = torch.argwhere(self.track_ids == track_id)
def save_state_dict(self, is_final):
state_dict = dict()
if self.opt_track:
state_dict['params'] = self.state_dict()
if not is_final:
state_dict['optimizer'] = self.optimizer.state_dict()
return state_dict
def load_state_dict(self, state_dict):
if self.opt_track:
super().load_state_dict(state_dict['params'])
if cfg.mode == 'train' and 'optimizer' in state_dict:
self.optimizer.load_state_dict(state_dict['optimizer'])
def training_setup(self):
args = cfg.optim
if self.opt_track:
params = [
{'params': [self.opt_trans], 'lr': args.track_position_lr_init, 'name': 'opt_trans'},
{'params': [self.opt_rots], 'lr': args.track_rotation_lr_init, 'name': 'opt_rots'},
]
self.opt_trans_scheduler_args = get_expon_lr_func(lr_init=args.track_position_lr_init,
lr_final=args.track_position_lr_final,
lr_delay_mult=args.track_position_lr_delay_mult,
max_steps=args.track_position_max_steps,
warmup_steps=args.opacity_reset_interval)
self.opt_rots_scheduler_args = get_expon_lr_func(lr_init=args.track_rotation_lr_init,
lr_final=args.track_rotation_lr_final,
lr_delay_mult=args.track_rotation_lr_delay_mult,
max_steps=args.track_rotation_max_steps,
warmup_steps=args.opacity_reset_interval)
self.optimizer = torch.optim.Adam(params=params, lr=0, eps=1e-15)
def update_learning_rate(self, iteration):
if self.opt_track:
for param_group in self.optimizer.param_groups:
if param_group["name"] == "opt_trans":
lr = self.opt_trans_scheduler_args(iteration)
param_group['lr'] = lr
if param_group["name"] == "opt_rots":
lr = self.opt_rots_scheduler_args(iteration)
param_group['lr'] = lr
def update_optimizer(self):
if self.opt_track:
self.optimizer.step()
self.optimizer.zero_grad(set_to_none=None)
def find_closest_indices(self, track_id, timestamp):
track_idx = self.obj_info[track_id]['track_idx']
frame_idx = track_idx[:, 0].cpu()
frame_timestamps = np.array(self.timestamps[frame_idx])
assert len(frame_timestamps) > 1
delta_timestamps = np.abs(frame_timestamps - timestamp)
idx1, idx2 = np.argsort(delta_timestamps)[:2]
return track_idx[idx1], track_idx[idx2]
def find_closest_camera_timestamps(self, track_id, camera: Camera):
timestamp = camera.meta['timestamp']
cam = camera.meta['cam']
camera_timestamps = self.camera_timestamps[cam]['train_timestamps']
start_timestamp = self.obj_info[track_id]['start_timestamp']
end_timestamp = self.obj_info[track_id]['end_timestamp']
camera_timestamps = np.array([x for x in camera_timestamps if x >= start_timestamp and x <= end_timestamp])
if len(camera_timestamps) < 2:
return None, None
else:
delta_timestamps = np.abs(camera_timestamps - timestamp)
idx1, idx2 = np.argsort(delta_timestamps)[:2]
return camera_timestamps[idx1], camera_timestamps[idx2]
def get_tracking_translation_(self, track_id, timestamp):
ind1, ind2 = self.find_closest_indices(track_id, timestamp)
frame_ind1, frame_ind2 = ind1[0], ind2[0]
column_ind1, column_ind2 = ind1[1], ind2[1]
timestamp1, timestamp2 = self.timestamps[frame_ind1.cpu()], self.timestamps[frame_ind2.cpu()]
if self.opt_track:
trans1 = self.input_trans[frame_ind1, column_ind1] + self.opt_trans[frame_ind1, column_ind1]
trans2 = self.input_trans[frame_ind2, column_ind2] + self.opt_trans[frame_ind2, column_ind2]
else:
trans1 = self.input_trans[frame_ind1, column_ind1]
trans2 = self.input_trans[frame_ind2, column_ind2]
trans = (trans1 * (timestamp2 - timestamp) + trans2 * (timestamp - timestamp1)) / (timestamp2 - timestamp1)
return trans
def get_tracking_translation(self, track_id, camera: Camera):
if self.opt_track and camera.meta['is_val']:
timestamp1, timestamp2 = self.find_closest_camera_timestamps(track_id, camera)
if timestamp1 is None:
return self.get_tracking_translation_(track_id, camera.meta['timestamp'])
else:
timestamp = camera.meta['timestamp']
trans1 = self.get_tracking_translation_(track_id, timestamp1)
trans2 = self.get_tracking_translation_(track_id, timestamp2)
trans = (trans1 * (timestamp2 - timestamp) + trans2 * (timestamp - timestamp1)) / (timestamp2 - timestamp1)
return trans
else:
return self.get_tracking_translation_(track_id, camera.meta['timestamp'])
def get_tracking_rotation_(self, track_id, timestamp):
ind1, ind2 = self.find_closest_indices(track_id, timestamp)
frame_ind1, frame_ind2 = ind1[0], ind2[0]
column_ind1, column_ind2 = ind1[1], ind2[1]
timestamp1, timestamp2 = self.timestamps[frame_ind1.cpu()], self.timestamps[frame_ind2.cpu()]
if self.opt_track:
rots1 = self.input_rots[frame_ind1, column_ind1]
rots2 = self.input_rots[frame_ind2, column_ind2]
opt_rots1 = torch.zeros_like(rots1)
opt_rots2 = torch.zeros_like(rots2)
opt_rots1[0] = torch.cos(self.opt_rots[frame_ind1, column_ind1])
opt_rots1[3] = torch.sin(self.opt_rots[frame_ind1, column_ind1])
opt_rots2[0] = torch.cos(self.opt_rots[frame_ind2, column_ind2])
opt_rots2[3] = torch.sin(self.opt_rots[frame_ind2, column_ind2])
rots1 = quaternion_raw_multiply(rots1.unsqueeze(0), opt_rots1.unsqueeze(0)).squeeze(0)
rots2 = quaternion_raw_multiply(rots2.unsqueeze(0), opt_rots2.unsqueeze(0)).squeeze(0)
else:
rots1 = self.input_rots[frame_ind1, column_ind1]
rots2 = self.input_rots[frame_ind2, column_ind2]
r = (timestamp - timestamp1) / (timestamp2 - timestamp1)
rots = quaternion_slerp(rots1, rots2, r)
return rots
def get_tracking_rotation(self, track_id, camera: Camera):
if self.opt_track and camera.meta['is_val']:
timestamp1, timestamp2 = self.find_closest_camera_timestamps(track_id, camera)
if timestamp1 is None:
return self.get_tracking_rotation_(track_id, camera.meta['timestamp'])
else:
timestamp = camera.meta['timestamp']
rots1 = self.get_tracking_rotation_(track_id, timestamp1)
rots2 = self.get_tracking_rotation_(track_id, timestamp2)
r = (timestamp - timestamp1) / (timestamp2 - timestamp1)
rots = quaternion_slerp(rots1, rots2, r)
return rots
else:
return self.get_tracking_rotation_(track_id, camera.meta['timestamp'])
================================================
FILE: lib/models/camera_pose.py
================================================
import torch
import torch.nn as nn
from lib.config import cfg
from lib.utils.camera_utils import Camera
from lib.utils.general_utils import get_expon_lr_func, exp_map_SO3xR3, matrix_to_quaternion, quaternion_raw_multiply, quaternion_to_matrix
class PoseCorrection(nn.Module):
def __init__(self, metadata):
super().__init__()
self.identity_matrix = torch.eye(4).float().cuda()[:3] # [3, 4]
self.config = cfg.model.pose_correction
self.mode = self.config.mode
# per image embedding
if self.mode == 'image':
num_poses = metadata['num_images']
# per frame embedding
elif self.mode == 'frame':
num_poses = metadata['num_frames']
else:
raise ValueError(f'Invalid mode: {self.mode}')
self.pose_correction_trans = torch.nn.Parameter(torch.zeros(num_poses, 3).float().cuda()).requires_grad_(True)
self.pose_correction_rots = torch.nn.Parameter(torch.tensor([[1, 0, 0, 0]]).repeat(num_poses, 1).float().cuda()).requires_grad_(True)
def save_state_dict(self, is_final):
state_dict = dict()
state_dict['params'] = self.state_dict()
if not is_final:
state_dict['optimizer'] = self.optimizer.state_dict()
return state_dict
def load_state_dict(self, state_dict):
super().load_state_dict(state_dict['params'])
if cfg.mode == 'train' and 'optimizer' in state_dict:
self.optimizer.load_state_dict(state_dict['optimizer'])
def training_setup(self):
args = cfg.optim
pose_correction_lr_init = args.get('pose_correction_lr_init', 5e-6)
pose_correction_lr_final = args.get('pose_correction_lr_final', 1e-6)
pose_correction_max_steps = args.get('pose_correction_max_steps', cfg.train.iterations)
params = [
{'params': [self.pose_correction_trans], 'lr': pose_correction_lr_init, 'name': 'pose_correction_trans'},
{'params': [self.pose_correction_rots], 'lr': pose_correction_lr_init, 'name': 'pose_correction_rots'},
]
self.optimizer = torch.optim.Adam(params=params, lr=0, eps=1e-8, weight_decay=0.01)
self.pose_correction_scheduler_args = get_expon_lr_func(
warmup_steps=0,
lr_init=pose_correction_lr_init,
lr_final=pose_correction_lr_final,
max_steps=pose_correction_max_steps,
)
def update_learning_rate(self, iteration):
for param_group in self.optimizer.param_groups:
lr = self.pose_correction_scheduler_args(iteration)
param_group['lr'] = lr
def update_optimizer(self):
self.optimizer.step()
self.optimizer.zero_grad(set_to_none=None)
def get_id(self, camera: Camera):
if self.mode == 'image':
return camera.id
elif self.mode == 'frame':
return camera.meta['frame_idx']
else:
raise ValueError(f'invalid mode: {self.mode}')
def forward(self, camera: Camera):
id = self.get_id(camera)
pose_correction_trans = self.pose_correction_trans[id]
pose_correction_rot = self.pose_correction_rots[id]
pose_correction_rot = torch.nn.functional.normalize(pose_correction_rot.unsqueeze(0))
pose_correction_rot = quaternion_to_matrix(pose_correction_rot).squeeze(0)
pose_correction_matrix = torch.cat([pose_correction_rot, pose_correction_trans[:, None]], dim=-1)
padding = torch.tensor([[0, 0, 0, 1]]).float().cuda()
pose_correction_matrix = torch.cat([pose_correction_matrix, padding], dim=0)
return pose_correction_matrix
def correct_gaussian_xyz(self, camera: Camera, xyz: torch.Tensor):
# xyz: [N, 3]
if cfg.mode in ['train', 'evaluate']:
id = self.get_id(camera)
pose_correction_trans = self.pose_correction_trans[id]
pose_correction_rot = self.pose_correction_rots[id]
pose_correction_rot = torch.nn.functional.normalize(pose_correction_rot.unsqueeze(0), dim=-1)
pose_correction_rot = quaternion_to_matrix(pose_correction_rot).squeeze(0)
pose_correction_matrix = torch.cat([pose_correction_rot, pose_correction_trans[:, None]], dim=-1)
padding = torch.tensor([[0, 0, 0, 1]]).float().cuda()
pose_correction_matrix = torch.cat([pose_correction_matrix, padding], dim=0)
xyz = torch.cat([xyz, torch.ones_like(xyz[..., :1])], dim=-1)
xyz = xyz @ pose_correction_matrix.T
xyz = xyz[:, :3]
return xyz
def correct_gaussian_rotation(self, camera: Camera, rotation: torch.Tensor):
# rotation: [N, 4]
if cfg.mode in ['train', 'evaluate']:
id = self.get_id(camera)
pose_correction_rot = self.pose_correction_rots[id]
pose_correction_rot = torch.nn.functional.normalize(pose_correction_rot.unsqueeze(0), dim=-1)
rotation = quaternion_raw_multiply(pose_correction_rot, rotation)
return rotation
def regularization_loss(self):
loss_trans = torch.abs(self.pose_correction_trans).mean()
rots_norm = torch.nn.functional.normalize(self.pose_correction_rots, dim=-1)
loss_rots = torch.abs(rots_norm - torch.tensor([[1, 0, 0, 0]]).float().cuda()).mean()
loss = loss_trans + loss_rots
return loss
================================================
FILE: lib/models/color_correction.py
================================================
import torch
import torch.nn as nn
from lib.config import cfg
from lib.utils.camera_utils import Camera
from lib.utils.general_utils import get_expon_lr_func, matrix_to_axis_angle
class ColorCorrection(nn.Module):
def __init__(self, metadata):
super().__init__()
self.identity_matrix = torch.eye(4).float().cuda()[:3] # [3, 4]
self.config = cfg.model.color_correction
self.mode = self.config.mode
# per image embedding
if self.mode == 'image':
num_corrections = metadata['num_images']
# per sensor embedding
elif self.mode == 'sensor':
num_corrections = metadata['num_cams']
else:
raise ValueError(f'Invalid mode: {self.mode}')
if self.config.use_mlp:
input_ch = 6
dim = 64
self.affine_trans = nn.Sequential(
nn.Linear(input_ch, dim),
nn.ReLU(),
nn.Linear(dim, dim),
nn.ReLU(),
nn.Linear(dim, dim),
nn.ReLU(),
nn.Linear(dim, 12),
)
self.affine_trans[6].weight.data.fill_(0)
self.affine_trans[6].bias.data.fill_(0)
self.affine_trans.cuda()
self.affine_trans_sky = nn.Sequential(
nn.Linear(input_ch, dim),
nn.ReLU(),
nn.Linear(dim, dim),
nn.ReLU(),
nn.Linear(dim, dim),
nn.ReLU(),
nn.Linear(dim, 12),
)
self.affine_trans_sky[6].weight.data.fill_(0)
self.affine_trans_sky[6].bias.data.fill_(0)
self.affine_trans_sky.cuda()
else:
self.affine_trans = nn.Parameter(torch.eye(4).float().cuda()[:3].unsqueeze(0).repeat(num_corrections, 1, 1)).requires_grad_(True)
self.affine_trans_sky = nn.Parameter(torch.eye(4).float().cuda()[:3].unsqueeze(0).repeat(num_corrections, 1, 1)).requires_grad_(True)
self.cur_affine_trans = None
def save_state_dict(self, is_final):
state_dict = dict()
state_dict['params'] = self.state_dict()
if not is_final:
state_dict['optimizer'] = self.optimizer.state_dict()
return state_dict
def load_state_dict(self, state_dict):
super().load_state_dict(state_dict['params'])
if cfg.mode == 'train' and 'optimizer' in state_dict:
self.optimizer.load_state_dict(state_dict['optimizer'])
def training_setup(self):
args = cfg.optim
color_correction_lr_init = args.get('color_correction_lr_init', 5e-4)
color_correction_lr_final = args.get('color_correction_lr_final', 5e-5)
color_correction_max_steps = args.get('color_correction_max_steps', cfg.train.iterations)
if self.config.use_mlp:
params = [
{'params': list(self.affine_trans.parameters()), 'lr': color_correction_lr_init, 'name': 'affine_trans'},
{'params': list(self.affine_trans_sky.parameters()), 'lr': color_correction_lr_init, 'name': 'affine_trans_sky'},
]
else:
params = [
{'params': [self.affine_trans], 'lr': color_correction_lr_init, 'name': 'affine_trans'},
{'params': [self.affine_trans_sky], 'lr': color_correction_lr_init, 'name': 'affine_trans_sky'},
]
self.optimizer = torch.optim.Adam(params=params, lr=0, eps=1e-15)
self.color_correction_scheduler_args = get_expon_lr_func(
lr_init=color_correction_lr_init,
lr_final=color_correction_lr_final,
max_steps=color_correction_max_steps,
)
def update_learning_rate(self, iteration):
for param_group in self.optimizer.param_groups:
lr = self.color_correction_scheduler_args(iteration)
param_group['lr'] = lr
def update_optimizer(self):
self.optimizer.step()
self.optimizer.zero_grad(set_to_none=None)
def get_id(self, camera: Camera):
if self.mode == 'image':
return camera.id
elif self.mode == 'sensor':
return camera.meta['cam']
else:
raise ValueError(f'invalid mode: {self.mode}')
def get_affine_trans(self, camera: Camera, use_sky=False):
if self.config.use_mlp:
c2w = camera.ego_pose @ camera.extrinsic
c2w = matrix_to_axis_angle(c2w.unsqueeze(0)).squeeze(0)
if use_sky:
affine_trans = self.affine_trans_sky(c2w).view(3, 4) + self.identity_matrix
else:
affine_trans = self.affine_trans(c2w).view(3, 4) + self.identity_matrix
else:
id = self.get_id(camera)
if use_sky:
affine_trans = self.affine_trans_sky[id]
else:
affine_trans = self.affine_trans[id]
self.cur_affine_trans = affine_trans
return affine_trans
def forward(self, camera: Camera, image: torch.Tensor, use_sky=False):
affine_trans = self.get_affine_trans(camera, use_sky)
image = torch.einsum('ij, jhw -> ihw', affine_trans[:3, :3], image) + affine_trans[:3, 3].unsqueeze(-1).unsqueeze(-1)
return image
def regularization_loss(self, camera: Camera):
affine_trans = self.get_affine_trans(camera, use_sky=False)
affine_trans_sky = self.get_affine_trans(camera, use_sky=True)
loss = torch.abs(affine_trans - self.identity_matrix) + torch.abs(affine_trans_sky - self.identity_matrix)
loss = loss.mean()
return loss
================================================
FILE: lib/models/gaussian_model.py
================================================
import torch
import torch.nn as nn
import numpy as np
import os
from simple_knn._C import distCUDA2
from lib.config import cfg
from lib.utils.general_utils import inverse_sigmoid, get_expon_lr_func, quaternion_to_matrix
from lib.utils.sh_utils import RGB2SH
from lib.utils.graphics_utils import BasicPointCloud
from lib.utils.general_utils import strip_symmetric, build_scaling_rotation
from lib.utils.system_utils import mkdir_p
from lib.utils.data_utils import to_cuda
from plyfile import PlyData, PlyElement
from lib.utils.camera_utils import Camera
class GaussianModel(nn.Module):
def __init__(self, model_name='background', num_classes=1):
super().__init__()
cfg_model = cfg.model.gaussian
self.model_name = model_name
# semantic
self.num_classes = num_classes
self.semantic_mode = cfg_model.get('semantic_mode', 'logits')
assert self.semantic_mode in ['logits', 'probabilities']
# spherical harmonics
default_max_sh_degree = cfg_model.get('sh_degree')
if self.model_name == 'background':
self.max_sh_degree = cfg_model.get('sh_degree_background', default_max_sh_degree)
elif self.model_name == 'sky':
self.max_sh_degree = cfg_model.get('sh_degree_sky', default_max_sh_degree)
else:
self.max_sh_degree = cfg_model.get('sh_degree_obj', default_max_sh_degree)
self.active_sh_degree = self.max_sh_degree
# original gaussian initialization
self._xyz = torch.empty(0)
self._features_dc = torch.empty(0)
self._features_rest = torch.empty(0)
self._scaling = torch.empty(0)
self._rotation = torch.empty(0)
self._opacity = torch.empty(0)
self._semantic = torch.empty(0)
self.max_radii2D = torch.empty(0)
self.xyz_gradient_accum = torch.empty(0)
self.denom = torch.empty(0)
self.optimizer = None
self.percent_dense = 0
self.spatial_lr_scale = 0
self.setup_functions()
def create_from_pcd(self, pcd : BasicPointCloud, spatial_lr_scale : float):
self.spatial_lr_scale = spatial_lr_scale
fused_point_cloud = torch.tensor(np.asarray(pcd.points)).float().cuda()
fused_color = RGB2SH(torch.tensor(np.asarray(pcd.colors)).float().cuda())
features = torch.zeros((fused_color.shape[0], 3, (self.max_sh_degree + 1) ** 2)).float().cuda()
features[..., 0] = fused_color
print(f"Number of points at initialisation for {self.model_name}: ", fused_point_cloud.shape[0])
dist2 = torch.clamp_min(distCUDA2(torch.from_numpy(np.asarray(pcd.points)).float().cuda()), 0.0000001)
scales = torch.log(torch.sqrt(dist2))[..., None].repeat(1, 3)
rots = torch.zeros((fused_point_cloud.shape[0], 4), device="cuda")
rots[:, 0] = 1
opacities = inverse_sigmoid(0.1 * torch.ones((fused_point_cloud.shape[0], 1), dtype=torch.float, device="cuda"))
semamtics = torch.zeros((fused_point_cloud.shape[0], self.num_classes), dtype=torch.float, device="cuda")
self._xyz = nn.Parameter(fused_point_cloud.requires_grad_(True))
self._features_dc = nn.Parameter(features[:, :, 0:1].transpose(1, 2).contiguous().requires_grad_(True))
self._features_rest = nn.Parameter(features[:, :, 1:].transpose(1, 2).contiguous().requires_grad_(True))
self._scaling = nn.Parameter(scales.requires_grad_(True))
self._rotation = nn.Parameter(rots.requires_grad_(True))
self._opacity = nn.Parameter(opacities.requires_grad_(True))
self._semantic = nn.Parameter(semamtics.requires_grad_(True))
self.max_radii2D = torch.zeros((self.get_xyz.shape[0]), device="cuda")
def make_ply(self):
xyz = self._xyz.detach().cpu().numpy()
normals = np.zeros_like(xyz)
f_dc = self._features_dc.detach().transpose(1, 2).flatten(start_dim=1).contiguous().cpu().numpy()
f_rest = self._features_rest.detach().transpose(1, 2).flatten(start_dim=1).contiguous().cpu().numpy()
opacities = self._opacity.detach().cpu().numpy()
scale = self._scaling.detach().cpu().numpy()
rotation = self._rotation.detach().cpu().numpy()
semantic = self._semantic.detach().cpu().numpy()
dtype_full = [(attribute, 'f4') for attribute in self.construct_list_of_attributes()]
elements = np.empty(xyz.shape[0], dtype=dtype_full)
attributes = np.concatenate((xyz, normals, f_dc, f_rest, opacities, scale, rotation, semantic), axis=1)
elements[:] = list(map(tuple, attributes))
return elements
def save_ply(self, path):
mkdir_p(os.path.dirname(path))
elements = self.make_ply()
elements = PlyElement.describe(elements, 'vertex')
PlyData([elements]).write(path)
def load_ply(self, path=None, input_ply=None):
if path is None:
plydata = input_ply
else:
plydata = PlyData.read(path)
plydata = plydata.elements[0]
xyz = np.stack((np.asarray(plydata["x"]),
np.asarray(plydata["y"]),
np.asarray(plydata["z"])), axis=1)
opacities = np.asarray(plydata["opacity"])[..., np.newaxis]
base_f_names = [p.name for p in plydata.properties if p.name.startswith("f_dc_")]
base_f_names = sorted(base_f_names, key = lambda x: int(x.split('_')[-1]))
extra_f_names = [p.name for p in plydata.properties if p.name.startswith("f_rest_")]
extra_f_names = sorted(extra_f_names, key = lambda x: int(x.split('_')[-1]))
features_dc = np.zeros((xyz.shape[0], len(base_f_names)))
features_extra = np.zeros((xyz.shape[0], len(extra_f_names)))
for idx, attr_name in enumerate(base_f_names):
features_dc[:, idx] = np.asarray(plydata[attr_name])
for idx, attr_name in enumerate(extra_f_names):
features_extra[:, idx] = np.asarray(plydata[attr_name])
features_dc = features_dc.reshape(features_dc.shape[0], 3, -1)
features_extra = features_extra.reshape(features_extra.shape[0], 3, -1)
scale_names = [p.name for p in plydata.properties if p.name.startswith("scale_")]
scale_names = sorted(scale_names, key = lambda x: int(x.split('_')[-1]))
scales = np.zeros((xyz.shape[0], len(scale_names)))
for idx, attr_name in enumerate(scale_names):
scales[:, idx] = np.asarray(plydata[attr_name])
rot_names = [p.name for p in plydata.properties if p.name.startswith("rot_")]
rot_names = sorted(rot_names, key = lambda x: int(x.split('_')[-1]))
rots = np.zeros((xyz.shape[0], len(rot_names)))
for idx, attr_name in enumerate(rot_names):
rots[:, idx] = np.asarray(plydata[attr_name])
semantic_names = [p.name for p in plydata.properties if p.name.startswith("semantic_")]
semantic_names = sorted(semantic_names, key = lambda x: int(x.split('_')[-1]))
semantic = np.zeros((xyz.shape[0], len(semantic_names)))
for idx, attr_name in enumerate(semantic_names):
semantic[:, idx] = np.asarray(plydata[attr_name])
self._xyz = nn.Parameter(torch.tensor(xyz, dtype=torch.float, device="cuda").requires_grad_(True))
self._features_dc = nn.Parameter(torch.tensor(features_dc, dtype=torch.float, device="cuda").transpose(1, 2).contiguous().requires_grad_(True))
self._features_rest = nn.Parameter(torch.tensor(features_extra, dtype=torch.float, device="cuda").transpose(1, 2).contiguous().requires_grad_(True))
self._opacity = nn.Parameter(torch.tensor(opacities, dtype=torch.float, device="cuda").requires_grad_(True))
self._scaling = nn.Parameter(torch.tensor(scales, dtype=torch.float, device="cuda").requires_grad_(True))
self._rotation = nn.Parameter(torch.tensor(rots, dtype=torch.float, device="cuda").requires_grad_(True))
self._semantic = nn.Parameter(torch.tensor(semantic, dtype=torch.float, device="cuda").requires_grad_(True))
self.active_sh_degree = self.max_sh_degree
def load_state_dict(self, state_dict):
self._xyz = state_dict['xyz']
self._features_dc = state_dict['feature_dc']
self._features_rest = state_dict['feature_rest']
self._scaling = state_dict['scaling']
self._rotation = state_dict['rotation']
self._opacity = state_dict['opacity']
self._semantic = state_dict['semantic']
if cfg.mode == 'train':
self.training_setup()
if 'spatial_lr_scale' in state_dict:
self.spatial_lr_scale = state_dict['spatial_lr_scale']
if 'denom' in state_dict:
self.denom = state_dict['denom']
if 'max_radii2D' in state_dict:
self.max_radii2D = state_dict['max_radii2D']
if 'xyz_gradient_accum' in state_dict:
self.xyz_gradient_accum = state_dict['xyz_gradient_accum']
if 'active_sh_degree' in state_dict:
self.active_sh_degree = state_dict['active_sh_degree']
if 'optimizer' in state_dict:
self.optimizer.load_state_dict(state_dict['optimizer'])
def state_dict(self, is_final=False):
state_dict = {
'xyz': self._xyz,
'feature_dc': self._features_dc,
'feature_rest': self._features_rest,
'scaling': self._scaling,
'rotation': self._rotation,
'opacity': self._opacity,
'semantic': self._semantic,
}
if not is_final:
state_dict_extra = {
'spatial_lr_scale': self.spatial_lr_scale,
'denom': self.denom,
'max_radii2D': self.max_radii2D,
'xyz_gradient_accum': self.xyz_gradient_accum,
'active_sh_degree': self.active_sh_degree,
'optimizer': self.optimizer.state_dict(),
}
state_dict.update(state_dict_extra)
return state_dict
def setup_functions(self):
def build_covariance_from_scaling_rotation(scaling, scaling_modifier, rotation):
L = build_scaling_rotation(scaling_modifier * scaling, rotation)
actual_covariance = L @ L.transpose(1, 2)
symm = strip_symmetric(actual_covariance)
return symm
self.scaling_activation = torch.exp
self.scaling_inverse_activation = torch.log
self.covariance_activation = build_covariance_from_scaling_rotation
self.opacity_activation = torch.sigmoid
self.inverse_opacity_activation = inverse_sigmoid
self.rotation_activation = torch.nn.functional.normalize
@property
def get_scaling(self):
return self.scaling_activation(self._scaling)
@property
def get_rotation(self):
return self.rotation_activation(self._rotation)
@property
def get_xyz(self):
return self._xyz
@property
def get_features(self):
features_dc = self._features_dc
features_rest = self._features_rest
return torch.cat((features_dc, features_rest), dim=1)
@property
def get_semantic(self):
if self.semantic_mode == 'logits':
return self._semantic
elif self.semantic_mode == 'probabilities':
return torch.nn.functional.softmax(self._semantic, dim=1)
@property
def get_opacity(self):
return self.opacity_activation(self._opacity)
def get_covariance(self, scaling_modifier = 1):
return self.covariance_activation(self.get_scaling, scaling_modifier, self._rotation)
def get_normals(self, camera: Camera):
scales, rotations = self.get_scaling, self.get_rotation
rotations_mat = quaternion_to_matrix(rotations)
min_scales = torch.argmin(scales, dim=-1)
indices = torch.arange(min_scales.shape[0])
normals = rotations_mat[indices, :, min_scales]
# points from gaussian to camera
dir_pp = (self.get_xyz - camera.camera_center.repeat(self._xyz.shape[0], 1))
dir_pp_normalized = dir_pp / dir_pp.norm(dim=1, keepdim=True) # (N, 3)
dotprod = torch.sum(-dir_pp_normalized * normals, dim=1, keepdim=True) # (N, 1)
normals = torch.where(dotprod >= 0, normals, -normals)
return normals
def scale_flatten_loss(self):
scales = self.get_scaling
sorted_scales = torch.sort(scales, dim=1, descending=False).values
s1, s2, s3 = sorted_scales[:, 0], sorted_scales[:, 1], sorted_scales[:, 2]
s1 = torch.clamp(s1, 0, 30)
s2 = torch.clamp(s2, 1e-5, 30)
s3 = torch.clamp(s3, 1e-5, 30)
scale_flatten_loss = torch.abs(s1).mean()
scale_flatten_loss += torch.abs(s2 / s3 + s3 / s2 - 2.).mean()
return scale_flatten_loss
def oneupSHdegree(self):
if self.active_sh_degree < self.max_sh_degree:
self.active_sh_degree += 1
def training_setup(self):
args = cfg.optim
self.xyz_gradient_accum = torch.zeros((self.get_xyz.shape[0], 2), device="cuda")
self.denom = torch.zeros((self.get_xyz.shape[0], 1), device="cuda")
self.active_sh_degree = 0
l = [
{'params': [self._xyz], 'lr': args.position_lr_init * self.spatial_lr_scale, "name": "xyz"},
{'params': [self._features_dc], 'lr': args.feature_lr, "name": "f_dc"},
{'params': [self._features_rest], 'lr': args.feature_lr / 20.0, "name": "f_rest"},
{'params': [self._opacity], 'lr': args.opacity_lr, "name": "opacity"},
{'params': [self._scaling], 'lr': args.scaling_lr, "name": "scaling"},
{'params': [self._rotation], 'lr': args.rotation_lr, "name": "rotation"},
{'params': [self._semantic], 'lr': args.semantic_lr, "name": "semantic"},
]
self.percent_dense = args.percent_dense
self.percent_big_ws = args.percent_big_ws
self.optimizer = torch.optim.Adam(l, lr=0.0, eps=1e-15)
self.xyz_scheduler_args = get_expon_lr_func(
lr_init=args.position_lr_init * self.spatial_lr_scale,
lr_final=args.position_lr_final * self.spatial_lr_scale,
lr_delay_mult=args.position_lr_delay_mult,
max_steps=args.position_lr_max_steps
)
self.densify_and_prune_list = ['xyz, f_dc, f_rest, opacity, scaling, rotation, semantic']
self.scalar_dict = dict()
self.tensor_dict = dict()
def update_optimizer(self):
self.optimizer.step()
self.optimizer.zero_grad(set_to_none=True)
def update_learning_rate(self, iteration):
''' Learning rate scheduling per step '''
for param_group in self.optimizer.param_groups:
if param_group["name"] == "xyz":
lr = self.xyz_scheduler_args(iteration)
param_group['lr'] = lr
def construct_list_of_attributes(self):
l = ['x', 'y', 'z', 'nx', 'ny', 'nz']
# All channels except the 3 DC
for i in range(self._features_dc.shape[1] * self._features_dc.shape[2]):
l.append('f_dc_{}'.format(i))
for i in range(self._features_rest.shape[1] * self._features_rest.shape[2]):
l.append('f_rest_{}'.format(i))
l.append('opacity')
for i in range(self._scaling.shape[1]):
l.append('scale_{}'.format(i))
for i in range(self._rotation.shape[1]):
l.append('rot_{}'.format(i))
for i in range(self._semantic.shape[1]):
l.append('semantic_{}'.format(i))
return l
def reset_optimizer(self, tensors_dict):
optimizable_tensors = {}
name_list = tensors_dict.keys()
for group in self.optimizer.param_groups:
if group['name'] in name_list:
reset_tensor = tensors_dict[group['name']]
stored_state = self.optimizer.state.get(group['params'][0], None)
stored_state["exp_avg"] = torch.zeros_like(reset_tensor)
stored_state["exp_avg_sq"] = torch.zeros_like(reset_tensor)
del self.optimizer.state[group['params'][0]]
group["params"][0] = nn.Parameter(reset_tensor.requires_grad_(True))
self.optimizer.state[group['params'][0]] = stored_state
optimizable_tensors[group["name"]] = group["params"][0]
return optimizable_tensors
def prune_optimizer(self, mask, prune_list = None):
optimizable_tensors = {}
for group in self.optimizer.param_groups:
if group['name'] not in prune_list:
continue
stored_state = self.optimizer.state.get(group['params'][0], None)
if stored_state is not None:
stored_state["exp_avg"] = stored_state["exp_avg"][mask]
stored_state["exp_avg_sq"] = stored_state["exp_avg_sq"][mask]
del self.optimizer.state[group['params'][0]]
group["params"][0] = nn.Parameter((group["params"][0][mask].requires_grad_(True)))
self.optimizer.state[group['params'][0]] = stored_state
optimizable_tensors[group["name"]] = group["params"][0]
else:
group["params"][0] = nn.Parameter(group["params"][0][mask].requires_grad_(True))
optimizable_tensors[group["name"]] = group["params"][0]
return optimizable_tensors
def cat_optimizer(self, tensors_dict):
optimizable_tensors = {}
name_list = tensors_dict.keys()
for group in self.optimizer.param_groups:
if group['name'] not in name_list:
continue
assert len(group["params"]) == 1
extension_tensor = tensors_dict[group["name"]]
stored_state = self.optimizer.state.get(group['params'][0], None)
if stored_state is not None:
stored_state["exp_avg"] = torch.cat((stored_state["exp_avg"], torch.zeros_like(extension_tensor)), dim=0)
stored_state["exp_avg_sq"] = torch.cat((stored_state["exp_avg_sq"], torch.zeros_like(extension_tensor)), dim=0)
del self.optimizer.state[group['params'][0]]
group["params"][0] = nn.Parameter(torch.cat((group["params"][0], extension_tensor), dim=0).requires_grad_(True))
self.optimizer.state[group['params'][0]] = stored_state
optimizable_tensors[group["name"]] = group["params"][0]
else:
group["params"][0] = nn.Parameter(torch.cat((group["params"][0], extension_tensor), dim=0).requires_grad_(True))
optimizable_tensors[group["name"]] = group["params"][0]
return optimizable_tensors
def reset_opacity(self):
opacities_new = inverse_sigmoid(torch.min(self.get_opacity, torch.ones_like(self.get_opacity) * 0.01))
d = {'opacity': opacities_new}
optimizable_tensors = self.reset_optimizer(d)
self._opacity = optimizable_tensors["opacity"]
def prune_points(self, mask):
valid_points_mask = ~mask
optimizable_tensors = self.prune_optimizer(valid_points_mask,
prune_list = ['xyz', 'f_dc', 'f_rest', 'opacity', 'scaling', 'rotation', 'semantic'])
self._xyz = optimizable_tensors["xyz"]
self._features_dc = optimizable_tensors["f_dc"]
self._features_rest = optimizable_tensors["f_rest"]
self._opacity = optimizable_tensors["opacity"]
self._scaling = optimizable_tensors["scaling"]
self._rotation = optimizable_tensors["rotation"]
self._semantic = optimizable_tensors["semantic"]
self.xyz_gradient_accum = self.xyz_gradient_accum[valid_points_mask]
self.denom = self.denom[valid_points_mask]
self.max_radii2D = self.max_radii2D[valid_points_mask]
def densification_postfix(self, tensors_dict):
optimizable_tensors = self.cat_optimizer(tensors_dict)
self._xyz = optimizable_tensors["xyz"]
self._features_dc = optimizable_tensors["f_dc"]
self._features_rest = optimizable_tensors["f_rest"]
self._opacity = optimizable_tensors["opacity"]
self._scaling = optimizable_tensors["scaling"]
self._rotation = optimizable_tensors["rotation"]
self._semantic = optimizable_tensors["semantic"]
cat_points_num = self.get_xyz.shape[0] - self.xyz_gradient_accum.shape[0]
self.xyz_gradient_accum = torch.cat([self.xyz_gradient_accum, torch.zeros(cat_points_num, 2).cuda()], dim=0)
self.denom = torch.cat([self.denom, torch.zeros(cat_points_num, 1).cuda()], dim=0)
self.max_radii2D = torch.cat([self.max_radii2D, torch.zeros(cat_points_num).cuda()], dim=0)
# self.xyz_gradient_accum = torch.zeros((self.get_xyz.shape[0], 1), device="cuda")
# self.denom = torch.zeros((self.get_xyz.shape[0], 1), device="cuda")
# self.max_radii2D = torch.zeros((self.get_xyz.shape[0]), device="cuda")
def densify_and_split(self, grads, grad_threshold, scene_extent, N=2):
n_init_points = self.get_xyz.shape[0]
# Extract points that satisfy the gradient condition
padded_grad = torch.zeros((n_init_points), device="cuda")
padded_grad[:grads.shape[0]] = grads.squeeze()
padded_extent = torch.zeros((n_init_points), device="cuda")
padded_extent[:grads.shape[0]] = scene_extent
selected_pts_mask = torch.where(padded_grad >= grad_threshold, True, False)
selected_pts_mask = torch.logical_and(selected_pts_mask,
torch.max(self.get_scaling, dim=1).values > self.percent_dense * padded_extent)
self.scalar_dict['points_split'] = selected_pts_mask.sum().item()
print(f'Number of points to split: {selected_pts_mask.sum()}')
stds = self.get_scaling[selected_pts_mask].repeat(N, 1)
means = torch.zeros((stds.size(0), 3), device="cuda")
samples = torch.normal(mean=means, std=stds)
rots = quaternion_to_matrix(self._rotation[selected_pts_mask]).repeat(N, 1, 1)
new_xyz = torch.bmm(rots, samples.unsqueeze(-1)).squeeze(-1) + self.get_xyz[selected_pts_mask].repeat(N, 1)
new_scaling = self.scaling_inverse_activation(self.get_scaling[selected_pts_mask].repeat(N, 1) / (0.8 * N))
new_rotation = self._rotation[selected_pts_mask].repeat(N, 1)
new_features_dc = self._features_dc[selected_pts_mask].repeat(N, 1, 1)
new_features_rest = self._features_rest[selected_pts_mask].repeat(N, 1, 1)
new_opacity = self._opacity[selected_pts_mask].repeat(N, 1)
new_semantic = self._semantic[selected_pts_mask].repeat(N, 1)
self.densification_postfix({
"xyz": new_xyz,
"f_dc": new_features_dc,
"f_rest": new_features_rest,
"opacity": new_opacity,
"scaling" : new_scaling,
"rotation" : new_rotation,
"semantic" : new_semantic,
})
prune_filter = torch.cat((selected_pts_mask, torch.zeros(N * selected_pts_mask.sum(), device="cuda", dtype=bool)))
self.prune_points(prune_filter)
def densify_and_clone(self, grads, grad_threshold, scene_extent):
# Extract points that satisfy the gradient condition
selected_pts_mask = torch.where(torch.norm(grads, dim=-1) >= grad_threshold, True, False)
selected_pts_mask = torch.logical_and(selected_pts_mask,
torch.max(self.get_scaling, dim=1).values <= self.percent_dense * scene_extent)
self.scalar_dict['points_clone'] = selected_pts_mask.sum().item()
print(f'Number of points to clone: {selected_pts_mask.sum()}')
new_xyz = self._xyz[selected_pts_mask]
new_features_dc = self._features_dc[selected_pts_mask]
new_features_rest = self._features_rest[selected_pts_mask]
new_opacity = self._opacity[selected_pts_mask]
new_scaling = self._scaling[selected_pts_mask]
new_rotation = self._rotation[selected_pts_mask]
new_semantic = self._semantic[selected_pts_mask]
self.densification_postfix({
"xyz": new_xyz,
"f_dc": new_features_dc,
"f_rest": new_features_rest,
"opacity": new_opacity,
"scaling" : new_scaling,
"rotation" : new_rotation,
"semantic" : new_semantic,
})
def densify_and_prune(self, max_grad, min_opacity, extent, max_screen_size):
grads = self.xyz_gradient_accum[:, 0:1] / self.denom
grads[grads.isnan()] = 0.0
self.scalar_dict.clear()
self.scalar_dict['points_total'] = self.get_xyz.shape[0]
print(f'Number of current gaussians: {self.get_xyz.shape[0]}')
# Clone and Split
self.densify_and_clone(grads, max_grad, extent)
self.densify_and_split(grads, max_grad, extent)
# Prune
prune_mask = (self.get_opacity < min_opacity).squeeze()
if max_screen_size:
big_points_vs = self.max_radii2D > max_screen_size
big_points_ws = self.get_scaling.max(dim=1).values > extent * self.percent_big_ws
# prune_mask = torch.logical_or(torch.logical_or(prune_mask, big_points_vs), big_points_ws)
prune_mask = torch.logical_or(prune_mask, big_points_ws)
self.prune_points(prune_mask)
self.scalar_dict['points_pruned'] = prune_mask.sum().item()
print(f'Number of pruned gaussians: {prune_mask.sum()}')
self.xyz_gradient_accum = torch.zeros((self.get_xyz.shape[0], 2), device="cuda")
self.denom = torch.zeros((self.get_xyz.shape[0], 1), device="cuda")
self.max_radii2D = torch.zeros((self.get_xyz.shape[0]), device="cuda")
torch.cuda.empty_cache()
return self.scalar_dict, self.tensor_dict
def add_densification_stats(self, viewspace_point_tensor, update_filter):
self.xyz_gradient_accum[update_filter, 0:1] += torch.norm(viewspace_point_tensor.grad[update_filter, :2], dim=-1, keepdim=True)
self.denom[update_filter] += 1
def add_densification_stats_grad(self, viewspace_point_tensor_grad, update_filter):
self.xyz_gradient_accum[update_filter, 0:1] += torch.norm(viewspace_point_tensor_grad[update_filter, :2], dim=-1, keepdim=True)
self.denom[update_filter] += 1
def parse_camera(self, camera: Camera):
pass
================================================
FILE: lib/models/gaussian_model_actor.py
================================================
import torch
import torch.nn as nn
import numpy as np
import os
from lib.config import cfg
from lib.models.gaussian_model import GaussianModel
from lib.utils.general_utils import quaternion_to_matrix, inverse_sigmoid, matrix_to_quaternion, get_expon_lr_func, quaternion_raw_multiply
from lib.utils.sh_utils import RGB2SH, IDFT
from lib.datasets.base_readers import fetchPly
from plyfile import PlyData, PlyElement
from simple_knn._C import distCUDA2
class GaussianModelActor(GaussianModel):
def __init__(
self,
model_name,
obj_meta,
):
# parse obj_meta
self.obj_meta = obj_meta
self.obj_class = obj_meta['class']
self.obj_class_label = obj_meta['class_label']
self.deformable = obj_meta['deformable']
self.start_frame = obj_meta['start_frame']
self.start_timestamp = obj_meta['start_timestamp']
self.end_frame = obj_meta['end_frame']
self.end_timestamp = obj_meta['end_timestamp']
self.track_id = obj_meta['track_id']
# fourier spherical harmonics
self.fourier_dim = cfg.model.gaussian.get('fourier_dim', 1)
self.fourier_scale = cfg.model.gaussian.get('fourier_scale', 1.)
# bbox
length, width, height = obj_meta['length'], obj_meta['width'], obj_meta['height']
self.bbox = np.array([length, width, height]).astype(np.float32)
xyz = torch.tensor(self.bbox).float().cuda()
self.min_xyz, self.max_xyz = -xyz/2., xyz/2.
extent = max(length*1.5/cfg.data.box_scale, width*1.5/cfg.data.box_scale, height) / 2.
self.extent = torch.tensor([extent]).float().cuda()
num_classes = 1 if cfg.data.get('use_semantic', False) else 0
self.num_classes_global = cfg.data.num_classes if cfg.data.get('use_semantic', False) else 0
super().__init__(model_name=model_name, num_classes=num_classes)
self.flip_prob = cfg.model.gaussian.get('flip_prob', 0.) if not self.deformable else 0.
self.flip_axis = 1
self.spatial_lr_scale = extent
def get_extent(self):
max_scaling = torch.max(self.get_scaling, dim=1).values
extent_lower_bound = torch.topk(max_scaling, int(self.get_xyz.shape[0] * 0.1), largest=False).values[-1] / self.percent_dense
extent_upper_bound = torch.topk(max_scaling, int(self.get_xyz.shape[0] * 0.1), largest=True).values[-1] / self.percent_dense
extent = torch.clamp(self.extent, min=extent_lower_bound, max=extent_upper_bound)
print(f'extent: {extent.item()}, extent bound: [{extent_lower_bound}, {extent_upper_bound}]')
return extent
@property
def get_semantic(self):
semantic = torch.zeros((self.get_xyz.shape[0], self.num_classes_global)).float().cuda()
if self.semantic_mode == 'logits':
semantic[:, self.obj_class_label] = self._semantic[:, 0] # ubounded semantic
elif self.semantic_mode == 'probabilities':
semantic[:, self.obj_class_label] = torch.nn.functional.sigmoid(self._semantic[:, 0]) # 0 ~ 1
return semantic
def get_features_fourier(self, frame=0):
normalized_frame = (frame - self.start_frame) / (self.end_frame - self.start_frame)
time = self.fourier_scale * normalized_frame
idft_base = IDFT(time, self.fourier_dim)[0].cuda()
features_dc = self._features_dc # [N, C, 3]
features_dc = torch.sum(features_dc * idft_base[..., None], dim=1, keepdim=True) # [N, 1, 3]
features_rest = self._features_rest # [N, sh, 3]
features = torch.cat([features_dc, features_rest], dim=1) # [N, (sh + 1) * C, 3]
return features
def create_from_pcd(self, spatial_lr_scale):
pointcloud_path = os.path.join(cfg.model_path, 'input_ply', f'points3D_{self.model_name}.ply')
if os.path.exists(pointcloud_path):
pcd = fetchPly(pointcloud_path)
pointcloud_xyz = np.asarray(pcd.points)
if pointcloud_xyz.shape[0] < 2000:
self.random_initialization = True
else:
self.random_initialization = False
else:
self.random_initialization = True
if self.random_initialization is True:
points_dim = 20
print(f'Creating random pointcloud for {self.model_name}')
points_x, points_y, points_z = np.meshgrid(
np.linspace(-1., 1., points_dim), np.linspace(-1., 1., points_dim), np.linspace(-1., 1., points_dim),
)
points_x = points_x.reshape(-1)
points_y = points_y.reshape(-1)
points_z = points_z.reshape(-1)
bbox_xyz_scale = self.bbox / 2.
pointcloud_xyz = np.stack([points_x, points_y, points_z], axis=-1)
pointcloud_xyz = pointcloud_xyz * bbox_xyz_scale
pointcloud_rgb = np.random.rand(*pointcloud_xyz.shape).astype(np.float32)
elif not self.deformable and self.flip_prob > 0.:
pcd = fetchPly(pointcloud_path)
pointcloud_xyz = np.asarray(pcd.points)
pointcloud_rgb = np.asarray(pcd.colors)
num_pointcloud_1 = (pointcloud_xyz[:, self.flip_axis] > 0).sum()
num_pointcloud_2 = (pointcloud_xyz[:, self.flip_axis] < 0).sum()
if num_pointcloud_1 >= num_pointcloud_2:
pointcloud_xyz_part = pointcloud_xyz[pointcloud_xyz[:, self.flip_axis] > 0]
pointcloud_rgb_part = pointcloud_rgb[pointcloud_xyz[:, self.flip_axis] > 0]
else:
pointcloud_xyz_part = pointcloud_xyz[pointcloud_xyz[:, self.flip_axis] < 0]
pointcloud_rgb_part = pointcloud_rgb[pointcloud_xyz[:, self.flip_axis] < 0]
pointcloud_xyz_flip = pointcloud_xyz_part.copy()
pointcloud_xyz_flip[:, self.flip_axis] *= -1
pointcloud_rgb_flip = pointcloud_rgb_part.copy()
pointcloud_xyz = np.concatenate([pointcloud_xyz, pointcloud_xyz_flip], axis=0)
pointcloud_rgb = np.concatenate([pointcloud_rgb, pointcloud_rgb_flip], axis=0)
else:
pcd = fetchPly(pointcloud_path)
pointcloud_xyz = np.asarray(pcd.points)
pointcloud_rgb = np.asarray(pcd.colors)
fused_point_cloud = torch.tensor(np.asarray(pointcloud_xyz)).float().cuda()
fused_color = RGB2SH(torch.tensor(np.asarray(pointcloud_rgb)).float().cuda())
# features = torch.zeros((fused_color.shape[0], 3,
# (self.max_sh_degree + 1) ** 2 * self.fourier_dim)).float().cuda()
# features[:, :3, 0] = fused_color
features_dc = torch.zeros((fused_color.shape[0], 3, self.fourier_dim)).float().cuda()
features_rest = torch.zeros(fused_color.shape[0], 3, (self.max_sh_degree + 1) ** 2 - 1).float().cuda()
features_dc[:, :3, 0] = fused_color
print(f"Number of points at initialisation for {self.model_name}: ", fused_point_cloud.shape[0])
dist2 = torch.clamp_min(distCUDA2(torch.from_numpy(np.asarray(pointcloud_xyz)).float().cuda()), 0.0000001)
scales = torch.log(torch.sqrt(dist2))[..., None].repeat(1, 3)
rots = torch.zeros((fused_point_cloud.shape[0], 4)).cuda()
rots[:, 0] = 1
opacities = inverse_sigmoid(0.1 * torch.ones((fused_point_cloud.shape[0], 1))).float().cuda()
semantics = torch.zeros((fused_point_cloud.shape[0], self.num_classes)).float().cuda()
self._xyz = nn.Parameter(fused_point_cloud.requires_grad_(True))
# self._features_dc = nn.Parameter(features[:, :, :self.fourier_dim].transpose(1, 2).contiguous().requires_grad_(True))
# self._features_rest = nn.Parameter(features[:, :, self.fourier_dim:].transpose(1, 2).contiguous().requires_grad_(True))
self._features_dc = nn.Parameter(features_dc.transpose(1, 2).contiguous().requires_grad_(True))
self._features_rest = nn.Parameter(features_rest.transpose(1, 2).contiguous().requires_grad_(True))
self._scaling = nn.Parameter(scales.requires_grad_(True))
self._rotation = nn.Parameter(rots.requires_grad_(True))
self._opacity = nn.Parameter(opacities.requires_grad_(True))
self._semantic = nn.Parameter(semantics.requires_grad_(True))
self.max_radii2D = torch.zeros((self.get_xyz.shape[0]), device="cuda")
def training_setup(self):
args = cfg.optim
self.xyz_gradient_accum = torch.zeros((self.get_xyz.shape[0], 2), device="cuda")
self.denom = torch.zeros((self.get_xyz.shape[0], 1), device="cuda")
self.active_sh_degree = 0
tag = 'obj'
position_lr_init = args.get('position_lr_init_{}'.format(tag), args.position_lr_init)
position_lr_final = args.get('position_lr_final_{}'.format(tag), args.position_lr_final)
scaling_lr = args.get('scaling_lr_{}'.format(tag), args.scaling_lr)
feature_lr = args.get('feature_lr_{}'.format(tag), args.feature_lr)
semantic_lr = args.get('semantic_lr_{}'.format(tag), args.semantic_lr)
rotation_lr = args.get('rotation_lr_{}'.format(tag), args.rotation_lr)
opacity_lr = args.get('opacity_lr_{}'.format(tag), args.opacity_lr)
feature_rest_lr = args.get('feature_rest_lr_{}'.format(tag), feature_lr / 20.0)
l = [
{'params': [self._xyz], 'lr': position_lr_init * self.spatial_lr_scale, "name": "xyz"},
{'params': [self._features_dc], 'lr': feature_lr, "name": "f_dc"},
{'params': [self._features_rest], 'lr': feature_rest_lr, "name": "f_rest"},
{'params': [self._opacity], 'lr': opacity_lr, "name": "opacity"},
{'params': [self._scaling], 'lr': scaling_lr, "name": "scaling"},
{'params': [self._rotation], 'lr': rotation_lr, "name": "rotation"},
{'params': [self._semantic], 'lr': semantic_lr, "name": "semantic"},
]
self.percent_dense = args.percent_dense
self.percent_big_ws = args.percent_big_ws
self.optimizer = torch.optim.Adam(l, lr=0.0, eps=1e-15)
self.xyz_scheduler_args = get_expon_lr_func(
lr_init=position_lr_init * self.spatial_lr_scale,
lr_final=position_lr_final * self.spatial_lr_scale,
lr_delay_mult=args.position_lr_delay_mult,
max_steps=args.position_lr_max_steps
)
self.densify_and_prune_list = ['xyz, f_dc, f_rest, opacity, scaling, rotation, semantic']
self.scalar_dict = dict()
self.tensor_dict = dict()
def densify_and_prune(self, max_grad, min_opacity, prune_big_points):
if not (self.random_initialization or self.deformable):
max_grad = cfg.optim.get('densify_grad_threshold_obj', max_grad)
if cfg.optim.get('densify_grad_abs_obj', False):
grads = self.xyz_gradient_accum[:, 1:2] / self.denom
else:
grads = self.xyz_gradient_accum[:, 0:1] / self.denom
else:
grads = self.xyz_gradient_accum[:, 0:1] / self.denom
grads[grads.isnan()] = 0.0
# Clone and Split
# extent = self.get_extent()
extent = self.extent
self.densify_and_clone(grads, max_grad, extent)
self.densify_and_split(grads, max_grad, extent)
# Prune points below opacity
prune_mask = (self.get_opacity < min_opacity).squeeze()
if prune_big_points:
# Prune big points in world space
extent = self.extent
big_points_ws = self.get_scaling.max(dim=1).values > extent * self.percent_big_ws
# Prune points outside the tracking box
repeat_num = 2
stds = self.get_scaling
stds = stds[:, None, :].expand(-1, repeat_num, -1) # [N, M, 1]
means = torch.zeros_like(self.get_xyz)
means = means[:, None, :].expand(-1, repeat_num, -1) # [N, M, 3]
samples = torch.normal(mean=means, std=stds) # [N, M, 3]
rots = quaternion_to_matrix(self.get_rotation) # [N, 3, 3]
rots = rots[:, None, :, :].expand(-1, repeat_num, -1, -1) # [N, M, 3, 3]
origins = self.get_xyz[:, None, :].expand(-1, repeat_num, -1) # [N, M, 3]
samples_xyz = torch.matmul(rots, samples.unsqueeze(-1)).squeeze(-1) + origins # [N, M, 3]
num_gaussians = self.get_xyz.shape[0]
points_inside_box = torch.logical_and(
torch.all((samples_xyz >= self.min_xyz).view(num_gaussians, -1), dim=-1),
torch.all((samples_xyz <= self.max_xyz).view(num_gaussians, -1), dim=-1),
)
points_outside_box = torch.logical_not(points_inside_box)
prune_mask = torch.logical_or(prune_mask, big_points_ws)
prune_mask = torch.logical_or(prune_mask, points_outside_box)
self.prune_points(prune_mask)
# Reset
self.xyz_gradient_accum = torch.zeros((self.get_xyz.shape[0], 2), device="cuda")
self.denom = torch.zeros((self.get_xyz.shape[0], 1), device="cuda")
self.max_radii2D = torch.zeros((self.get_xyz.shape[0]), device="cuda")
torch.cuda.empty_cache()
return self.scalar_dict, self.tensor_dict
def set_max_radii(self, visibility_obj, max_radii2D):
self.max_radii2D[visibility_obj] = torch.max(self.max_radii2D[visibility_obj], max_radii2D[visibility_obj])
def box_reg_loss(self):
scaling_max = self.get_scaling.max(dim=1).values
scaling_max = torch.where(scaling_max > self.extent * self.percent_dense, scaling_max, 0.)
reg_loss = (scaling_max / self.extent).mean()
return reg_loss
================================================
FILE: lib/models/gaussian_model_bkgd.py
================================================
import torch
import numpy as np
import os
from lib.config import cfg
from lib.utils.graphics_utils import BasicPointCloud
from lib.datasets.base_readers import fetchPly
from lib.models.gaussian_model import GaussianModel
from lib.utils.camera_utils import Camera, make_rasterizer
class GaussianModelBkgd(GaussianModel):
def __init__(
self,
model_name='background',
scene_center=np.array([0, 0, 0]),
scene_radius=20,
sphere_center=np.array([0, 0, 0]),
sphere_radius=20,
):
self.scene_center = torch.from_numpy(scene_center).float().cuda()
self.scene_radius = torch.tensor([scene_radius]).float().cuda()
self.sphere_center = torch.from_numpy(sphere_center).float().cuda()
self.sphere_radius = torch.tensor([sphere_radius]).float().cuda()
num_classes = cfg.data.num_classes if cfg.data.get('use_semantic', False) else 0
self.background_mask = None
super().__init__(model_name=model_name, num_classes=num_classes)
def create_from_pcd(self, pcd: BasicPointCloud, spatial_lr_scale: float):
print('Create background model')
# pointcloud_path_sky = os.path.join(cfg.model_path, 'input_ply', 'points3D_sky.ply')
# include_sky = cfg.model.nsg.get('include_sky', False)
# if os.path.exists(pointcloud_path_sky) and not include_sky:
# pcd_sky = fetchPly(pointcloud_path_sky)
# pointcloud_xyz = np.concatenate((pcd.points, pcd_sky.points), axis=0)
# pointcloud_rgb = np.concatenate((pcd.colors, pcd_sky.colors), axis=0)
# pointcloud_normal = np.zeros_like(pointcloud_xyz)
# pcd = BasicPointCloud(pointcloud_xyz, pointcloud_rgb, pointcloud_normal)
return super().create_from_pcd(pcd, spatial_lr_scale)
def set_background_mask(self, camera: Camera):
pass
@property
def get_scaling(self):
scaling = super().get_scaling
return scaling if self.background_mask is None else scaling[self.background_mask]
@property
def get_rotation(self):
rotation = super().get_rotation
return rotation if self.background_mask is None else rotation[self.background_mask]
@property
def get_xyz(self):
xyz = super().get_xyz
return xyz if self.background_mask is None else xyz[self.background_mask]
@property
def get_features(self):
features = super().get_features
return features if self.background_mask is None else features[self.background_mask]
@property
def get_opacity(self):
opacity = super().get_opacity
return opacity if self.background_mask is None else opacity[self.background_mask]
@property
def get_semantic(self):
semantic = super().get_semantic
return semantic if self.background_mask is None else semantic[self.background_mask]
def densify_and_prune(self, max_grad, min_opacity, prune_big_points):
max_grad = cfg.optim.get('densify_grad_threshold_bkgd', max_grad)
if cfg.optim.get('densify_grad_abs_bkgd', False):
grads = self.xyz_gradient_accum[:, 1:2] / self.denom
else:
grads = self.xyz_gradient_accum[:, 0:1] / self.denom
grads[grads.isnan()] = 0.0
self.scalar_dict.clear()
self.tensor_dict.clear()
self.scalar_dict['points_total'] = self.get_xyz.shape[0]
# Clone and Split
extent = self.scene_radius
self.densify_and_clone(grads, max_grad, extent)
self.densify_and_split(grads, max_grad, extent)
# Prune points below opacity
prune_mask = (self.get_opacity < min_opacity).squeeze()
self.scalar_dict['points_below_min_opacity'] = prune_mask.sum().item()
# Prune big points in world space
if prune_big_points:
dists = torch.linalg.norm(self.get_xyz - self.sphere_center, dim=1)
big_points_ws = torch.max(self.get_scaling, dim=1).values > extent * self.percent_big_ws
big_points_ws[dists > 2 * self.sphere_radius] = False
prune_mask = torch.logical_or(prune_mask, big_points_ws)
self.scalar_dict['points_big_ws'] = big_points_ws.sum().item()
self.scalar_dict['points_pruned'] = prune_mask.sum().item()
self.prune_points(prune_mask)
# Reset
self.xyz_gradient_accum = torch.zeros((self.get_xyz.shape[0], 2), device="cuda")
self.denom = torch.zeros((self.get_xyz.shape[0], 1), device="cuda")
self.max_radii2D = torch.zeros((self.get_xyz.shape[0]), device="cuda")
torch.cuda.empty_cache()
return self.scalar_dict, self.tensor_dict
================================================
FILE: lib/models/gaussian_model_sky.py
================================================
import torch
import numpy as np
import os
from lib.config import cfg
from lib.utils.graphics_utils import BasicPointCloud
from lib.datasets.base_readers import fetchPly
from lib.models.gaussian_model import GaussianModel
from lib.utils.general_utils import quaternion_to_matrix
class GaussinaModelSky(GaussianModel):
def __init__(
self,
model_name='sky',
num_classes=1,
sphere_center=np.array([0, 0, 0]),
sphere_radius=20,
):
super().__init__(model_name=model_name, num_classes=num_classes)
self.sphere_center = torch.from_numpy(sphere_center).float().cuda()
self.sphere_radius = torch.Tensor([sphere_radius]).float().cuda()
def create_from_pcd(self, pcd: BasicPointCloud, spatial_lr_scale: float):
print('Create sky model')
pointcloud_path_sky = os.path.join(cfg.model_path, 'input_ply', 'points3D_sky.ply')
assert os.path.exists(pointcloud_path_sky), f'Pointcloud {pointcloud_path_sky} does not exist'
pcd_sky = fetchPly(pointcloud_path_sky)
pointcloud_xyz = pcd_sky.points
pointcloud_rgb = pcd_sky.colors
pointcloud_normal = np.zeros_like(pointcloud_xyz)
pcd = BasicPointCloud(pointcloud_xyz, pointcloud_rgb, pointcloud_normal)
return super().create_from_pcd(pcd, self.sphere_radius.item())
def get_extent(self):
max_scaling = torch.max(self.get_scaling, dim=1).values
extent_lower_bound = torch.topk(max_scaling, int(self.get_xyz.shape[0] * 0.1), largest=False).values[-1] / self.percent_dense
extent_upper_bound = torch.topk(max_scaling, int(self.get_xyz.shape[0] * 0.1), largest=True).values[-1] / self.percent_dense
extent = torch.clamp(self.sphere_radius, min=extent_lower_bound, max=extent_upper_bound)
print(f'extent: {extent.item()}, extent bound: [{extent_lower_bound}, {extent_upper_bound}]')
# distance = torch.linalg.norm(self.get_xyz - self.scene_center, dim=1)
# scale_factor = torch.clamp(distance / self.scene_radius - 1, min=1., max=3.)
# extent = self.scene_radius * scale_factor
return extent
@property
def get_scaling(self):
scaling = self.scaling_activation(self._scaling)
scaling = torch.clamp(scaling, max=self.sphere_radius.item())
return scaling
@property
def get_xyz(self):
xyz = self._xyz
dists = torch.linalg.norm(xyz - self.sphere_center, dim=1, keepdims=True)
ratios = dists / (2 * self.sphere_radius)
xyz = torch.where(ratios < 1., self.sphere_center + (xyz - self.sphere_center) / ratios, xyz)
return xyz
def densify_and_prune(self, max_grad, min_opacity, prune_big_points):
grads = self.xyz_gradient_accum / self.denom
grads[grads.isnan()] = 0.0
self.scalar_dict.clear()
self.tensor_dict.clear()
self.scalar_dict['points_total'] = self.get_xyz.shape[0]
print('=' * 20)
print(f'Model name: {self.model_name}')
print(f'Number of 3d gaussians: {self.get_xyz.shape[0]}')
# Clone and Split
extent = self.get_extent()
# extent = self.sphere_radius
self.densify_and_clone(grads, max_grad, extent)
self.densify_and_split(grads, max_grad, extent)
# Prune points below opacity
prune_mask = (self.get_opacity < min_opacity).squeeze()
print(f'Prune points below min_opactiy: {prune_mask.sum()}')
self.scalar_dict['points_below_min_opacity'] = prune_mask.sum().item()
# Prune big points in world space
if prune_big_points:
# Prune big points in world space
extent = self.get_extent()
# extent = self.sphere_radius
big_points_ws = torch.max(self.get_scaling, dim=1).values > extent * self.percent_big_ws
# Prune points too near to sphere center
# repeat_num = 2
# stds = self.get_scaling
# stds = stds[:, None, :].expand(-1, repeat_num, -1) # [N, M, 1]
# means = torch.zeros_like(self.get_xyz)
# means = means[:, None, :].expand(-1, repeat_num, -1) # [N, M, 3]
# samples = torch.normal(mean=means, std=stds) # [N, M, 3]
# rots = quaternion_to_matrix(self.get_rotation) # [N, 3, 3]
# rots = rots[:, None, :, :].expand(-1, repeat_num, -1, -1) # [N, M, 3, 3]
# origins = self.get_xyz[:, None, :].expand(-1, repeat_num, -1) # [N, M, 3]
# samples_xyz = torch.matmul(rots, samples.unsqueeze(-1)).squeeze(-1) + origins # [N, M, 3]
# dists = torch.linalg.norm(samples_xyz - self.sphere_center, dim=2) # [N, M]
# initalized at 2.5r, should not be smaller than 2r
# points_near_sphere = dists.min(dim=1).values < self.sphere_radius * 2
prune_mask = torch.logical_or(prune_mask, big_points_ws)
# prune_mask = torch.logical_or(prune_mask, points_near_sphere)
# print(f'Prune points near sphere center: {points_near_sphere.sum()}')
self.scalar_dict['points_pruned'] = prune_mask.sum().item()
self.prune_points(prune_mask)
# Reset
self.xyz_gradient_accum = torch.zeros((self.get_xyz.shape[0], 1), device="cuda")
self.denom = torch.zeros((self.get_xyz.shape[0], 1), device="cuda")
self.max_radii2D = torch.zeros((self.get_xyz.shape[0]), device="cuda")
torch.cuda.empty_cache()
return self.scalar_dict, self.tensor_dict
================================================
FILE: lib/models/gaussian_renderer.py
================================================
import torch
import math
from diff_gaussian_rasterization import GaussianRasterizationSettings, GaussianRasterizer
from lib.utils.sh_utils import eval_sh
from lib.models.gaussian_model import GaussianModel
from lib.models.street_gaussian_model import StreetGaussianModel
from typing import Union
from lib.utils.camera_utils import Camera
from lib.config import cfg
class GaussianRenderer():
def __init__(
self,
):
self.cfg = cfg.render
def render(
self,
viewpoint_camera: Camera,
pc: Union[GaussianModel, StreetGaussianModel],
convert_SHs_python = None,
compute_cov3D_python = None,
scaling_modifier = None,
override_color = None
):
bg_color = [1, 1, 1] if cfg.data.white_background else [0, 0, 0]
bg_color = torch.tensor(bg_color).float().cuda()
bg_depth = torch.tensor([0]).float().cuda()
scaling_modifier = scaling_modifier or self.cfg.scaling_modifier
convert_SHs_python = convert_SHs_python or self.cfg.convert_SHs_python
compute_cov3D_python = compute_cov3D_python or self.cfg.compute_cov3D_python
override_color = override_color or self.cfg.override_color
# Create zero tensor. We will use it to make pytorch return gradients of the 2D (screen-space) means
screenspace_points = torch.zeros_like(pc.get_xyz, dtype=pc.get_xyz.dtype, requires_grad=True, device="cuda") + 0
try:
screenspace_points.retain_grad()
except:
pass
# Set up rasterization configuration
tanfovx = math.tan(viewpoint_camera.FoVx * 0.5)
tanfovy = math.tan(viewpoint_camera.FoVy * 0.5)
raster_settings = GaussianRasterizationSettings(
image_height=int(viewpoint_camera.image_height),
image_width=int(viewpoint_camera.image_width),
tanfovx=tanfovx,
tanfovy=tanfovy,
bg_color=bg_color,
bg_depth=bg_depth,
scale_modifier=scaling_modifier,
viewmatrix=viewpoint_camera.world_view_transform,
projmatrix=viewpoint_camera.full_proj_transform,
sh_degree=pc.active_sh_degree,
campos=viewpoint_camera.camera_center,
prefiltered=False,
debug=self.cfg.debug
)
rasterizer = GaussianRasterizer(raster_settings=raster_settings)
means3D = pc.get_xyz
means2D = screenspace_points
opacity = pc.get_opacity
# If precomputed 3d covariance is provided, use it. If not, then it will be computed from
# scaling / rotation by the rasterizer.
scales = None
rotations = None
cov3D_precomp = None
if compute_cov3D_python:
cov3D_precomp = pc.get_covariance(scaling_modifier)
else:
scales = pc.get_scaling
rotations = pc.get_rotation
# If precomputed colors are provided, use them. Otherwise, if it is desired to precompute colors
# from SHs in Python, do it. If not, then SH -> RGB conversion will be done by rasterizer.
shs = None
colors_precomp = None
if override_color is None:
if convert_SHs_python:
shs_view = pc.get_features.transpose(1, 2).view(-1, 3, (pc.max_sh_degree+1)**2)
dir_pp = (pc.get_xyz - viewpoint_camera.camera_center.repeat(pc.get_features.shape[0], 1))
dir_pp_normalized = dir_pp/dir_pp.norm(dim=1, keepdim=True)
sh2rgb = eval_sh(pc.active_sh_degree, shs_view, dir_pp_normalized)
colors_precomp = torch.clamp_min(sh2rgb + 0.5, 0.0)
else:
shs = pc.get_features
else:
colors_precomp = override_color
# Rasterize visible Gaussians to image, obtain their radii (on screen).
rendered_color, radii, rendered_depth, rendered_acc, rendered_semantic = rasterizer(
means3D = means3D,
means2D = means2D,
opacities = opacity,
shs = shs,
colors_precomp = colors_precomp,
scales = scales,
rotations = rotations,
cov3D_precomp = cov3D_precomp,
semantics = None,
)
if cfg.mode != 'train':
rendered_color = torch.clamp(rendered_color, 0., 1.)
# Those Gaussians that were frustum culled or had a radius of 0 were not visible.
# They will be excluded from value updates used in the splitting criteria.
return {"rgb": rendered_color,
"acc": rendered_acc,
"depth": rendered_depth,
"viewspace_points": screenspace_points,
"visibility_filter" : radii > 0,
"radii": radii}
================================================
FILE: lib/models/network_gui.py
================================================
#
# Copyright (C) 2023, Inria
# GRAPHDECO research group, https://team.inria.fr/graphdeco
# All rights reserved.
#
# This software is free for non-commercial, research and evaluation use
# under the terms of the LICENSE.md file.
#
# For inquiries contact george.drettakis@inria.fr
#
import torch
import traceback
import socket
import json
from lib.utils.camera_utils import MiniCam
host = "127.0.0.1"
port = 6009
conn = None
addr = None
listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
def init(wish_host, wish_port):
global host, port, listener
host = wish_host
port = wish_port
listener.bind((host, port))
listener.listen()
listener.settimeout(0)
def try_connect():
global conn, addr, listener
try:
conn, addr = listener.accept()
print(f"\nConnected by {addr}")
conn.settimeout(None)
except Exception as inst:
pass
def read():
global conn
messageLength = conn.recv(4)
messageLength = int.from_bytes(messageLength, 'little')
message = conn.recv(messageLength)
return json.loads(message.decode("utf-8"))
def send(message_bytes, verify):
global conn
if message_bytes != None:
conn.sendall(message_bytes)
conn.sendall(len(verify).to_bytes(4, 'little'))
conn.sendall(bytes(verify, 'ascii'))
def receive():
message = read()
width = message["resolution_x"]
height = message["resolution_y"]
if width != 0 and height != 0:
try:
do_training = bool(message["train"])
fovy = message["fov_y"]
fovx = message["fov_x"]
znear = message["z_near"]
zfar = message["z_far"]
do_shs_python = bool(message["shs_python"])
do_rot_scale_python = bool(message["rot_scale_python"])
keep_alive = bool(message["keep_alive"])
scaling_modifier = message["scaling_modifier"]
world_view_transform = torch.reshape(torch.tensor(message["view_matrix"]), (4, 4)).cuda()
world_view_transform[:,1] = -world_view_transform[:,1]
world_view_transform[:,2] = -world_view_transform[:,2]
full_proj_transform = torch.reshape(torch.tensor(message["view_projection_matrix"]), (4, 4)).cuda()
full_proj_transform[:,1] = -full_proj_transform[:,1]
custom_cam = MiniCam(width, height, fovy, fovx, znear, zfar, world_view_transform, full_proj_transform)
except Exception as e:
print("")
traceback.print_exc()
raise e
return custom_cam, do_training, do_shs_python, do_rot_scale_python, keep_alive, scaling_modifier
else:
return None, None, None, None, None, None
================================================
FILE: lib/models/scene.py
================================================
import os
import torch
from typing import Union
from lib.datasets.dataset import Dataset
from lib.models.gaussian_model import GaussianModel
from lib.models.street_gaussian_model import StreetGaussianModel
from lib.config import cfg
from lib.utils.system_utils import searchForMaxIteration
class Scene:
gaussians : Union[GaussianModel, StreetGaussianModel]
dataset: Dataset
def __init__(self, gaussians: Union[GaussianModel, StreetGaussianModel], dataset: Dataset):
self.dataset = dataset
self.gaussians = gaussians
if cfg.mode == 'train':
point_cloud = self.dataset.scene_info.point_cloud
scene_raidus = self.dataset.scene_info.metadata['scene_radius']
print("Creating gaussian model from point cloud")
self.gaussians.create_from_pcd(point_cloud, scene_raidus)
train_cameras = self.getTrainCameras()
self.train_cameras_id_to_index = dict()
for i, train_camera in enumerate(train_cameras):
self.train_cameras_id_to_index[train_camera.id] = i
else:
# First check if there is a point cloud saved and get the iteration to load from
assert(os.path.exists(cfg.point_cloud_dir))
if cfg.loaded_iter == -1:
self.loaded_iter = searchForMaxIteration(cfg.point_cloud_dir)
else:
self.loaded_iter = cfg.loaded_iter
# Load pointcloud
# print("Loading saved pointcloud at iteration {}".format(self.loaded_iter))
# point_cloud_path = os.path.join(cfg.point_cloud_dir, f"iteration_{str(self.loaded_iter)}/point_cloud.ply")
# self.gaussians.load_ply(point_cloud_path)
# Load checkpoint if it exists (this loads other parameters like the optimized tracking poses)
print("Loading checkpoint at iteration {}".format(self.loaded_iter))
checkpoint_path = os.path.join(cfg.trained_model_dir, f"iteration_{str(self.loaded_iter)}.pth")
assert os.path.exists(checkpoint_path)
state_dict = torch.load(checkpoint_path)
self.gaussians.load_state_dict(state_dict=state_dict)
def save(self, iteration):
point_cloud_path = os.path.join(cfg.point_cloud_dir, f"iteration_{iteration}", "point_cloud.ply")
self.gaussians.save_ply(point_cloud_path)
def getTrainCameras(self, scale=1):
return self.dataset.train_cameras[scale]
def getTestCameras(self, scale=1):
return self.dataset.test_cameras[scale]
def getNovelViewCameras(self, scale=1):
try:
return self.dataset.novel_view_cameras[scale]
except:
return []
================================================
FILE: lib/models/sky_cubemap.py
================================================
import torch
import torch.nn as nn
import numpy as np
import imageio
import os
import cv2
import nvdiffrast.torch as dr
from lib.config import cfg
from lib.utils.camera_utils import Camera
from lib.utils.graphics_utils import get_rays_torch
from lib.utils.general_utils import get_expon_lr_func
from sklearn.cluster import KMeans
class SkyCubeMap(nn.Module):
def __init__(self):
super().__init__()
self.cfg = cfg.model.sky
self.resolution = self.cfg.resolution
eps = 1e-3
if self.cfg.white_background:
base = torch.ones(6, self.resolution, self.resolution, 3).float().cuda() * (1. - eps)
else:
base = torch.zeros(6, self.resolution, self.resolution, 3).float().cuda() + eps
self.sky_cube_map = nn.Parameter(base).requires_grad_(True)
# # TODO: change hard code here
max_h, max_w = 1080, 1920
if cfg.data.white_background:
self.sky_color = torch.ones((max_h, max_w, 3)).float().cuda()
else:
self.sky_color = torch.zeros((max_h, max_w, 3)).float().cuda()
def save_state_dict(self, is_final):
state_dict = dict()
state_dict['params'] = self.state_dict()
if not is_final:
state_dict['optimizer'] = self.optimizer.state_dict()
# save LDR cubemap now
sky_latlong = cubemap_to_latlong(self.sky_cube_map, [self.resolution, self.resolution * 2])
sky_latlong = (sky_latlong.clamp(0., 1.).detach().cpu().numpy() * 255).astype(np.uint8)
imageio.imwrite(os.path.join(cfg.model_path, 'sky_latlong.png'), sky_latlong)
return state_dict
def load_state_dict(self, state_dict):
super().load_state_dict(state_dict['params'])
if cfg.mode == 'train' and 'optimizer' in state_dict:
self.optimizer.load_state_dict(state_dict['optimizer'])
def training_setup(self):
args = cfg.optim
sky_cube_map_lr_init = args.get('sky_cube_map_lr_init', 0.01)
sky_cube_map_lr_final = args.get('sky_cube_map_lr_final', 0.0001)
sky_cube_map_max_steps = args.get('sky_cube_map_max_steps', cfg.train.iterations)
params = [{'params': [self.sky_cube_map], 'lr': sky_cube_map_lr_init, 'name':'sky_cube_map'}]
self.optimizer = torch.optim.Adam(params=params, lr=0, eps=1e-15)
self.sky_cube_map_scheduler_args = get_expon_lr_func(
lr_init=sky_cube_map_lr_init,
lr_final=sky_cube_map_lr_final,
max_steps=sky_cube_map_max_steps,
)
def update_learning_rate(self, iteration):
for param_group in self.optimizer.param_groups:
if param_group["name"] == "sky_cube_map":
lr = self.sky_cube_map_scheduler_args(iteration)
param_group['lr'] = lr
def update_optimizer(self):
self.optimizer.step()
self.optimizer.zero_grad(set_to_none=None)
def forward(self, camera: Camera, acc=None):
# acc: gaussian opacity of foreground model: [1, H, W]
# mask: [H, W], indicating whether a pixel is covered by forgeground model
if cfg.mode == 'train' and hasattr(camera, 'original_sky_mask'):
mask = camera.original_sky_mask.cuda()[0]
mask[:50, :] = True
elif acc is not None:
mask = (1 - acc[0]) > 1e-3
else:
mask = None
# R, T should be in w2c format
# rays_d: [H, W, 3]
w2c = camera.world_view_transform.transpose(0, 1)
H, W, K, R, T = camera.image_height, camera.image_width, camera.K, w2c[:3, :3], w2c[:3, 3]
if cfg.mode == 'train':
_, rays_d = get_rays_torch(H, W, K, R, T, perturb=True)
else:
_, rays_d = get_rays_torch(H, W, K, R, T, perturb=False)
if mask is None:
sky_color = dr.texture(self.sky_cube_map[None, ...], rays_d[None, ...],
filter_mode='linear', boundary_mode='cube')
sky_color = sky_color[0].permute(2, 0, 1).clamp(0., 1.) # [3, H, W]
else:
if cfg.mode == 'train':
if self.cfg.white_background:
sky_color = torch.ones((H, W, 3)).float().cuda()
else:
sky_color = torch.zeros((H, W, 3)).float().cuda()
else:
sky_color = self.sky_color[:H, :W, :]
if self.cfg.white_background:
torch.fill_(sky_color, 1.)
else:
torch.fill_(sky_color, 0.)
rays_d = rays_d[mask] # [N, 3]
sky_color_mask = dr.texture(self.sky_cube_map[None, ...], rays_d[None, None, ...],
filter_mode='linear', boundary_mode='cube')
sky_color_mask = sky_color_mask.squeeze(0).squeeze(0)
sky_color[mask] = sky_color_mask
sky_color = sky_color.permute(2, 0, 1).clamp(0., 1.) # [3, H, W]
return sky_color
#----------------------------------------------------------------------------
# Vector operations
#----------------------------------------------------------------------------
def dot(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
return torch.sum(x*y, -1, keepdim=True)
def reflect(x: torch.Tensor, n: torch.Tensor) -> torch.Tensor:
return 2*dot(x, n)*n - x
def length(x: torch.Tensor, eps: float =1e-20) -> torch.Tensor:
return torch.sqrt(torch.clamp(dot(x,x), min=eps)) # Clamp to avoid nan gradients because grad(sqrt(0)) = NaN
def safe_normalize(x: torch.Tensor, eps: float =1e-20) -> torch.Tensor:
return x / length(x, eps)
def to_hvec(x: torch.Tensor, w: float) -> torch.Tensor:
return torch.nn.functional.pad(x, pad=(0,1), mode='constant', value=w)
#----------------------------------------------------------------------------
# Cubemap utility functions
#----------------------------------------------------------------------------
def length(x: torch.Tensor, eps: float =1e-20) -> torch.Tensor:
return torch.sqrt(torch.clamp(dot(x,x), min=eps)) # Clamp to avoid nan gradients because grad(sqrt(0)) = NaN
def safe_normalize(x: torch.Tensor, eps: float =1e-20) -> torch.Tensor:
return x / length(x, eps)
def cube_to_dir(s, x, y):
if s == 0: rx, ry, rz = torch.ones_like(x), -y, -x
elif s == 1: rx, ry, rz = -torch.ones_like(x), -y, x
elif s == 2: rx, ry, rz = x, torch.ones_like(x), y
elif s == 3: rx, ry, rz = x, -torch.ones_like(x), -y
elif s == 4: rx, ry, rz = x, -y, torch.ones_like(x)
elif s == 5: rx, ry, rz = -x, -y, -torch.ones_like(x)
return torch.stack((rx, ry, rz), dim=-1)
def latlong_to_cubemap(latlong_map, res):
cubemap = torch.zeros(6, res[0], res[1], latlong_map.shape[-1], dtype=torch.float32, device='cuda')
for s in range(6):
gy, gx = torch.meshgrid(torch.linspace(-1.0 + 1.0 / res[0], 1.0 - 1.0 / res[0], res[0], device='cuda'),
torch.linspace(-1.0 + 1.0 / res[1], 1.0 - 1.0 / res[1], res[1], device='cuda'),
indexing='ij')
v = safe_normalize(cube_to_dir(s, gx, gy))
tu = torch.atan2(v[..., 0:1], -v[..., 2:3]) / (2 * np.pi) + 0.5
tv = torch.acos(torch.clamp(v[..., 1:2], min=-1, max=1)) / np.pi
texcoord = torch.cat((tu, tv), dim=-1)
cubemap[s, ...] = dr.texture(latlong_map[None, ...], texcoord[None, ...], filter_mode='linear')[0]
return cubemap
def cubemap_to_latlong(cubemap, res):
gy, gx = torch.meshgrid(torch.linspace( 0.0 + 1.0 / res[0], 1.0 - 1.0 / res[0], res[0], device='cuda'),
torch.linspace(-1.0 + 1.0 / res[1], 1.0 - 1.0 / res[1], res[1], device='cuda'),
indexing='ij')
sintheta, costheta = torch.sin(gy*np.pi), torch.cos(gy*np.pi)
sinphi, cosphi = torch.sin(gx*np.pi), torch.cos(gx*np.pi)
reflvec = torch.stack((
sintheta*sinphi,
costheta,
-sintheta*cosphi
), dim=-1)
return dr.texture(cubemap[None, ...], reflvec[None, ...].contiguous(), filter_mode='linear', boundary_mode='cube')[0]
from lib.utils.vq_utils import vq, vq_st
class SkyCubeMap_codebook(nn.Module):
def __init__(self):
super().__init__()
self.cfg = cfg.model.sky
self.resolution = self.cfg.resolution
feat_dim = 12
codebook_size = 32
self.sky_codebook = nn.Parameter(torch.zeros(codebook_size, feat_dim).float().cuda()).requires_grad_(True)
if cfg.mode == 'train':
self.sky_cube_map = nn.Parameter(torch.zeros(6, self.resolution, self.resolution, feat_dim).float().cuda()).requires_grad_(True)
else:
self.sky_cube_map = nn.Parameter(torch.zeros(6, self.resolution, self.resolution, 1).float().cuda())
input_dim = feat_dim + 3
self.mlp_shader = nn.Sequential(
nn.Linear(input_dim, 32),
nn.ReLU(),
nn.Linear(32, 32),
nn.ReLU(),
nn.Linear(32, 3),
).cuda()
# # TODO: change hard code here
max_h, max_w = 1080, 1920
if cfg.data.white_background:
self.sky_color = torch.ones((max_h, max_w, 3)).float().cuda()
else:
self.sky_color = torch.zeros((max_h, max_w, 3)).float().cuda()
def save_state_dict(self, is_final):
state_dict = dict()
if not is_final:
state_dict['params'] = self.state_dict()
state_dict['optimizer'] = self.optimizer.state_dict()
else:
params = self.state_dict()
sky_cube_map_flatten = self.sky_cube_map.reshape(6 * self.resolution * self.resolution, -1) # [N, F]
sky_cube_map_indices = vq(sky_cube_map_flatten, self.sky_codebook) # [N]
#TODO: compress to smaller size: log2(codebook size) bit
sky_cube_map_indices = sky_cube_map_indices.reshape(6, self.resolution, self.resolution, 1)
params['sky_cube_map'] = sky_cube_map_indices
state_dict['params'] = params
return state_dict
def load_state_dict(self, state_dict):
super().load_state_dict(state_dict['params'], strict=False)
if cfg.mode == 'train' and 'optimizer' in state_dict:
self.optimizer.load_state_dict(state_dict['optimizer'])
def training_setup(self):
args = cfg.optim
sky_cube_map_lr_init = args.get('sky_cube_map_lr', 0.01)
sky_cube_map_lr_final = args.get('sky_cube_map_lr_final', 0.0001)
mlp_shader_lr_init = args.get('mlp_shader_lr_init', 5e-4)
mlp_shader_lr_final = args.get('mlp_shader_lr_final', 1e-5)
max_steps = args.get('sky_cube_map_max_steps', cfg.train.iterations)
params = [{'params': [self.sky_cube_map], 'lr': sky_cube_map_lr_init, 'name': 'sky_cube_map'},
{'params': [self.sky_codebook], 'lr': sky_cube_map_lr_init, 'name': 'sky_codebook'},
{'params': list(self.mlp_shader.parameters()), 'lr': mlp_shader_lr_init, 'name': 'mlp_shader'}]
self.optimizer = torch.optim.Adam(params=params, lr=0, eps=1e-15)
self.sky_cube_map_scheduler_args = get_expon_lr_func(
lr_init=sky_cube_map_lr_init,
lr_final=sky_cube_map_lr_final,
max_steps=max_steps,
)
self.mlp_shader_scheduler_args = get_expon_lr_func(
lr_init=mlp_shader_lr_init,
lr_final=mlp_shader_lr_final,
max_steps=max_steps,
)
def update_learning_rate(self, iteration):
for param_group in self.optimizer.param_groups:
if param_group["name"] == "mlp_shader":
lr = self.mlp_shader_scheduler_args(iteration)
param_group['lr'] = lr
if param_group["name"] == "sky_cube_map" or 'sky_codebook':
lr = self.sky_cube_map_scheduler_args(iteration)
param_group['lr'] = lr
def update_optimizer(self):
self.optimizer.step()
self.optimizer.zero_grad(set_to_none=None)
def forward_train(self, camera: Camera, acc):
# acc: gaussian opacity of foreground model: [1, H, W]
# mask: [H, W], indicating whether a pixel is covered by forgeground model
if hasattr(camera, 'original_sky_mask'):
mask = camera.original_sky_mask.cuda()[0]
mask[:50, :] = True
elif acc is not None:
mask = (1 - acc[0]) > 1e-3
else:
mask = None
mask = camera.original_sky_mask.cuda()[0]
mask[:50, :] = True
# R, T should be in w2c format
# rays_d: [H, W, 3]
w2c = camera.world_view_transform.transpose(0, 1)
H, W, K, R, T = camera.image_height, camera.image_width, camera.K, w2c[:3, :3], w2c[:3, 3]
_, rays_d = get_rays_torch(H, W, K, R, T, perturb=False)
if cfg.mode == 'train':
if self.cfg.white_background:
sky_color = torch.ones((H, W, 3)).float().cuda()
else:
sky_color = torch.zeros((H, W, 3)).float().cuda()
rays_d = rays_d[mask] # [N, 3]
feat = dr.texture(self.sky_cube_map[None, ...], rays_d[None, None, ...],
filter_mode='linear', boundary_mode='cube')
feat_enc = feat.squeeze(0).squeeze(0) # [N, F]
feat_dec_detach, indices = vq_st(feat_enc, self.sky_codebook.detach())
feat_dec = self.sky_codebook[indices]
shader_input = torch.cat([feat_dec_detach, rays_d], dim=-1)
sky_color_mask = self.mlp_shader(shader_input)
sky_color_mask = torch.sigmoid(sky_color_mask)
sky_color[mask] = sky_color_mask
sky_color = sky_color.permute(2, 0, 1).clamp(0., 1.) # [3, H, W]
self.vq_loss_cache = {
'feat_enc': feat_enc,
'feat_dec': feat_dec,
}
return sky_color
def forward_inference(self, camera: Camera, acc):
mask = (1 - acc[0]) > 0
# R, T should be in w2c format
# rays_d: [H, W, 3]
w2c = camera.world_view_transform.transpose(0, 1)
H, W, K, R, T = camera.image_height, camera.image_width, camera.K, w2c[:3, :3], w2c[:3, 3]
_, rays_d = get_rays_torch(H, W, K, R, T, perturb=False)
sky_color = self.sky_color[:H, :W, :]
if self.cfg.white_background:
torch.fill_(sky_color, 1.)
else:
torch.fill_(sky_color, 0.)
rays_d = rays_d[mask] # [N, 3]
feat_indices = dr.texture(self.sky_cube_map[None, ...], rays_d[None, None, ...],
filter_mode='linear', boundary_mode='cube')
feat_indices = feat_indices.squeeze(0).squeeze(0).squeeze(-1).long()
# feat_enc = feat.squeeze(0).squeeze(0) # [N, F]
# indices = vq(feat_enc, self.sky_codebook)
feat_dec = self.sky_codebook[feat_indices]
shader_input = torch.cat([feat_dec, rays_d], dim=-1)
sky_color_mask = self.mlp_shader(shader_input)
sky_color_mask = torch.sigmoid(sky_color_mask)
sky_color[mask] = sky_color_mask
sky_color = sky_color.permute(2, 0, 1).clamp(0., 1.) # [3, H, W]
return sky_color
def forward(self, camera: Camera, acc):
# acc: gaussian opacity of foreground model: [1, H, W]
# mask: [H, W], indicating whether a pixel is covered by forgeground model
if cfg.mode == 'train':
sky_color = self.forward_train(camera)
else:
sky_color = self.forward_inference(camera, acc)
return sky_color
================================================
FILE: lib/models/street_gaussian_model.py
================================================
import torch
import torch.nn as nn
import numpy as np
import os
from simple_knn._C import distCUDA2
from lib.config import cfg
from lib.utils.general_utils import quaternion_to_matrix, \
build_scaling_rotation, \
strip_symmetric, \
quaternion_raw_multiply, \
startswith_any, \
matrix_to_quaternion, \
quaternion_invert
from lib.utils.graphics_utils import BasicPointCloud
from lib.utils.system_utils import mkdir_p
from plyfile import PlyData, PlyElement
from lib.models.gaussian_model import GaussianModel
from lib.models.gaussian_model_bkgd import GaussianModelBkgd
from lib.models.gaussian_model_actor import GaussianModelActor
from lib.models.gaussian_model_sky import GaussinaModelSky
from bidict import bidict
from lib.utils.camera_utils import Camera
from lib.utils.sh_utils import eval_sh
from lib.models.actor_pose import ActorPose
from lib.models.sky_cubemap import SkyCubeMap
from lib.models.color_correction import ColorCorrection
from lib.models.camera_pose import PoseCorrection
class StreetGaussianModel(nn.Module):
def __init__(self, metadata):
super().__init__()
self.metadata = metadata
self.max_sh_degree = cfg.model.gaussian.sh_degree
self.active_sh_degree = self.max_sh_degree
# background + moving objects
self.include_background = cfg.model.nsg.get('include_bkgd', True)
self.include_obj = cfg.model.nsg.get('include_obj', True)
# sky (modeling sky with gaussians, if set to false represent the sky with cube map)
self.include_sky = cfg.model.nsg.get('include_sky', False)
if self.include_sky:
assert cfg.data.white_background is False
# fourier sh dimensions
self.fourier_dim = cfg.model.gaussian.get('fourier_dim', 1)
# layer color correction
self.use_color_correction = cfg.model.use_color_correction
# camera pose optimizations (not test)
self.use_pose_correction = cfg.model.use_pose_correction
# symmetry
self.flip_prob = cfg.model.gaussian.get('flip_prob', 0.)
self.flip_axis = 1
self.flip_matrix = torch.eye(3).float().cuda() * -1
self.flip_matrix[self.flip_axis, self.flip_axis] = 1
self.flip_matrix = matrix_to_quaternion(self.flip_matrix.unsqueeze(0))
self.setup_functions()
def set_visibility(self, include_list):
self.include_list = include_list # prefix
def get_visibility(self, model_name):
if model_name == 'background':
if model_name in self.include_list and self.include_background:
return True
else:
return False
elif model_name == 'sky':
if model_name in self.include_list and self.include_sky:
return True
else:
return False
elif model_name.startswith('obj_'):
if model_name in self.include_list and self.include_obj:
return True
else:
return False
else:
raise ValueError(f'Unknown model name {model_name}')
def create_from_pcd(self, pcd: BasicPointCloud, spatial_lr_scale: float):
for model_name in self.model_name_id.keys():
model: GaussianModel = getattr(self, model_name)
if model_name in ['background', 'sky']:
model.create_from_pcd(pcd, spatial_lr_scale)
else:
model.create_from_pcd(spatial_lr_scale)
def save_ply(self, path):
mkdir_p(os.path.dirname(path))
plydata_list = []
for i in range(self.models_num):
model_name = self.model_name_id.inverse[i]
model: GaussianModel = getattr(self, model_name)
plydata = model.make_ply()
plydata = PlyElement.describe(plydata, f'vertex_{model_name}')
plydata_list.append(plydata)
PlyData(plydata_list).write(path)
def load_ply(self, path):
plydata_list = PlyData.read(path).elements
for plydata in plydata_list:
model_name = plydata.name[7:] # vertex_.....
if model_name in self.model_name_id.keys():
print('Loading model', model_name)
model: GaussianModel = getattr(self, model_name)
model.load_ply(path=None, input_ply=plydata)
plydata_list = PlyData.read(path).elements
self.active_sh_degree = self.max_sh_degree
def load_state_dict(self, state_dict, exclude_list=[]):
for model_name in self.model_name_id.keys():
if startswith_any(model_name, exclude_list):
continue
model: GaussianModel = getattr(self, model_name)
model.load_state_dict(state_dict[model_name])
if self.actor_pose is not None:
self.actor_pose.load_state_dict(state_dict['actor_pose'])
if self.sky_cubemap is not None:
self.sky_cubemap.load_state_dict(state_dict['sky_cubemap'])
if self.color_correction is not None:
self.color_correction.load_state_dict(state_dict['color_correction'])
if self.pose_correction is not None:
self.pose_correction.load_state_dict(state_dict['pose_correction'])
def save_state_dict(self, is_final, exclude_list=[]):
state_dict = dict()
for model_name in self.model_name_id.keys():
if startswith_any(model_name, exclude_list):
continue
model: GaussianModel = getattr(self, model_name)
state_dict[model_name] = model.state_dict(is_final)
if self.actor_pose is not None:
state_dict['actor_pose'] = self.actor_pose.save_state_dict(is_final)
if self.sky_cubemap is not None:
state_dict['sky_cubemap'] = self.sky_cubemap.save_state_dict(is_final)
if self.color_correction is not None:
state_dict['color_correction'] = self.color_correction.save_state_dict(is_final)
if self.pose_correction is not None:
state_dict['pose_correction'] = self.pose_correction.save_state_dict(is_final)
return state_dict
def setup_functions(self):
obj_tracklets = self.metadata['obj_tracklets']
obj_info = self.metadata['obj_meta']
tracklet_timestamps = self.metadata['tracklet_timestamps']
camera_timestamps = self.metadata['camera_timestamps']
self.model_name_id = bidict()
self.obj_list = []
self.models_num = 0
self.obj_info = obj_info
# Build background model
if self.include_background:
self.background = GaussianModelBkgd(
model_name='background',
scene_center=self.metadata['scene_center'],
scene_radius=self.metadata['scene_radius'],
sphere_center=self.metadata['sphere_center'],
sphere_radius=self.metadata['sphere_radius'],
)
self.model_name_id['background'] = 0
self.models_num += 1
# Build object model
if self.include_obj:
for track_id, obj_meta in self.obj_info.items():
model_name = f'obj_{track_id:03d}'
setattr(self, model_name, GaussianModelActor(model_name=model_name, obj_meta=obj_meta))
self.model_name_id[model_name] = self.models_num
self.obj_list.append(model_name)
self.models_num += 1
# Build sky model
if self.include_sky:
self.sky_cubemap = SkyCubeMap()
else:
self.sky_cubemap = None
# Build actor model
if self.include_obj:
self.actor_pose = ActorPose(obj_tracklets, tracklet_timestamps, camera_timestamps, obj_info)
else:
self.actor_pose = None
# Build color correction
if self.use_color_correction:
self.color_correction = ColorCorrection(self.metadata)
else:
self.color_correction = None
# Build pose correction
if self.use_pose_correction:
self.pose_correction = PoseCorrection(self.metadata)
else:
self.pose_correction = None
def parse_camera(self, camera: Camera):
# set camera
self.viewpoint_camera = camera
# set background mask
self.background.set_background_mask(camera)
self.frame = camera.meta['frame']
self.frame_idx = camera.meta['frame_idx']
self.frame_is_val = camera.meta['is_val']
self.num_gaussians = 0
# background
if self.get_visibility('background'):
num_gaussians_bkgd = self.background.get_xyz.shape[0]
self.num_gaussians += num_gaussians_bkgd
# object (build scene graph)
self.graph_obj_list = []
if self.include_obj:
timestamp = camera.meta['timestamp']
for i, obj_name in enumerate(self.obj_list):
obj_model: GaussianModelActor = getattr(self, obj_name)
start_timestamp, end_timestamp = obj_model.start_timestamp, obj_model.end_timestamp
if timestamp >= start_timestamp and timestamp <= end_timestamp and self.get_visibility(obj_name):
self.graph_obj_list.append(obj_name)
num_gaussians_obj = getattr(self, obj_name).get_xyz.shape[0]
self.num_gaussians += num_gaussians_obj
# set index range
self.graph_gaussian_range = dict()
idx = 0
if self.get_visibility('background'):
num_gaussians_bkgd = self.background.get_xyz.shape[0]
self.graph_gaussian_range['background'] = [idx, idx+num_gaussians_bkgd-1]
idx += num_gaussians_bkgd
for obj_name in self.graph_obj_list:
num_gaussians_obj = getattr(self, obj_name).get_xyz.shape[0]
self.graph_gaussian_range[obj_name] = [idx, idx+num_gaussians_obj-1]
idx += num_gaussians_obj
if len(self.graph_obj_list) > 0:
self.obj_rots = []
self.obj_trans = []
for i, obj_name in enumerate(self.graph_obj_list):
obj_model: GaussianModelActor = getattr(self, obj_name)
track_id = obj_model.track_id
obj_rot = self.actor_pose.get_tracking_rotation(track_id, self.viewpoint_camera)
obj_trans = self.actor_pose.get_tracking_translation(track_id, self.viewpoint_camera)
ego_pose = self.viewpoint_camera.ego_pose
ego_pose_rot = matrix_to_quaternion(ego_pose[:3, :3].unsqueeze(0)).squeeze(0)
obj_rot = quaternion_raw_multiply(ego_pose_rot.unsqueeze(0), obj_rot.unsqueeze(0)).squeeze(0)
obj_trans = ego_pose[:3, :3] @ obj_trans + ego_pose[:3, 3]
obj_rot = obj_rot.expand(obj_model.get_xyz.shape[0], -1)
obj_trans = obj_trans.unsqueeze(0).expand(obj_model.get_xyz.shape[0], -1)
self.obj_rots.append(obj_rot)
self.obj_trans.append(obj_trans)
self.obj_rots = torch.cat(self.obj_rots, dim=0)
self.obj_trans = torch.cat(self.obj_trans, dim=0)
self.flip_mask = []
for obj_name in self.graph_obj_list:
obj_model: GaussianModelActor = getat
gitextract_24ehzmat/
├── .gitignore
├── .idea/
│ ├── .gitignore
│ ├── inspectionProfiles/
│ │ └── profiles_settings.xml
│ ├── misc.xml
│ ├── modules.xml
│ ├── street_gaussians.iml
│ └── vcs.xml
├── README.md
├── configs/
│ ├── example/
│ │ ├── waymo_train_002.yaml
│ │ ├── waymo_train_002_1cam.yaml
│ │ ├── waymo_train_031.yaml
│ │ ├── waymo_train_124_1cam.yaml
│ │ └── waymo_train_149_1cam.yaml
│ └── experiments_waymo/
│ ├── waymo_val_006.yaml
│ ├── waymo_val_026.yaml
│ ├── waymo_val_090.yaml
│ ├── waymo_val_105.yaml
│ ├── waymo_val_108.yaml
│ ├── waymo_val_134.yaml
│ ├── waymo_val_150.yaml
│ └── waymo_val_181.yaml
├── lib/
│ ├── config/
│ │ ├── __init__.py
│ │ ├── config.py
│ │ └── yacs.py
│ ├── datasets/
│ │ ├── base_readers.py
│ │ ├── blender_readers.py
│ │ ├── colmap_readers.py
│ │ ├── dataset.py
│ │ └── waymo_full_readers.py
│ ├── models/
│ │ ├── __init__.py
│ │ ├── actor_pose.py
│ │ ├── camera_pose.py
│ │ ├── color_correction.py
│ │ ├── gaussian_model.py
│ │ ├── gaussian_model_actor.py
│ │ ├── gaussian_model_bkgd.py
│ │ ├── gaussian_model_sky.py
│ │ ├── gaussian_renderer.py
│ │ ├── network_gui.py
│ │ ├── scene.py
│ │ ├── sky_cubemap.py
│ │ ├── street_gaussian_model.py
│ │ └── street_gaussian_renderer.py
│ ├── utils/
│ │ ├── __init__.py
│ │ ├── box_utils.py
│ │ ├── camera_utils.py
│ │ ├── cfg_utils.py
│ │ ├── colmap_utils.py
│ │ ├── data_utils.py
│ │ ├── general_utils.py
│ │ ├── graphics_utils.py
│ │ ├── img_utils.py
│ │ ├── loss_utils.py
│ │ ├── lpipsPyTorch/
│ │ │ ├── __init__.py
│ │ │ └── modules/
│ │ │ ├── lpips.py
│ │ │ ├── networks.py
│ │ │ └── utils.py
│ │ ├── sem_utils.py
│ │ ├── sh_utils.py
│ │ ├── system_utils.py
│ │ ├── vq_utils.py
│ │ └── waymo_utils.py
│ └── visualizers/
│ ├── base_visualizer.py
│ └── street_gaussian_visualizer.py
├── make_ply.py
├── metrics.py
├── models/
│ ├── __init__.py
│ ├── common.py
│ ├── experimental.py
│ ├── export.py
│ ├── hub/
│ │ ├── anchors.yaml
│ │ ├── yolov3-spp.yaml
│ │ ├── yolov3-tiny.yaml
│ │ ├── yolov3.yaml
│ │ ├── yolov5-fpn.yaml
│ │ ├── yolov5-p2.yaml
│ │ ├── yolov5-p6.yaml
│ │ ├── yolov5-p7.yaml
│ │ ├── yolov5-panet.yaml
│ │ ├── yolov5l6.yaml
│ │ ├── yolov5m6.yaml
│ │ ├── yolov5s-transformer.yaml
│ │ ├── yolov5s6.yaml
│ │ └── yolov5x6.yaml
│ ├── yolo.py
│ ├── yolov5l.yaml
│ ├── yolov5m.yaml
│ ├── yolov5s.yaml
│ └── yolov5x.yaml
├── networks/
│ ├── __init__.py
│ ├── depth_decoder.py
│ ├── pose_cnn.py
│ ├── pose_decoder.py
│ └── resnet_encoder.py
├── nodes/
│ ├── rviz2/
│ │ └── gaussian_rpg.rviz
│ ├── scripts/
│ │ ├── simulator_launch.sh
│ │ ├── simulator_launch_hil.sh
│ │ └── simulator_launch_separate.sh
│ └── src/
│ ├── dummy_controllers/
│ │ ├── LICENSE
│ │ ├── dummy_controllers/
│ │ │ ├── AEB_controller.py
│ │ │ ├── __init__.py
│ │ │ └── object_detector.py
│ │ ├── package.xml
│ │ ├── resource/
│ │ │ └── dummy_controllers
│ │ ├── setup.cfg
│ │ ├── setup.py
│ │ └── test/
│ │ ├── test_copyright.py
│ │ ├── test_flake8.py
│ │ └── test_pep257.py
│ └── simulator/
│ ├── LICENSE
│ ├── package.xml
│ ├── resource/
│ │ └── simulator
│ ├── setup.cfg
│ ├── setup.py
│ ├── simulator/
│ │ ├── __init__.py
│ │ ├── evaluation.py
│ │ ├── groundtruth.py
│ │ ├── simulator.py
│ │ └── simulator_hil.py
│ └── test/
│ ├── test_copyright.py
│ ├── test_flake8.py
│ └── test_pep257.py
├── on_board/
│ └── nodes/
│ └── src/
│ └── dummy_controllers/
│ ├── LICENSE
│ ├── dummy_controllers/
│ │ ├── AEB_controller.py
│ │ ├── __init__.py
│ │ ├── object_detector.py
│ │ └── test_yolov5.py
│ ├── package.xml
│ ├── resource/
│ │ └── dummy_controllers
│ ├── setup.cfg
│ ├── setup.py
│ └── test/
│ ├── test_copyright.py
│ ├── test_flake8.py
│ └── test_pep257.py
├── render.py
├── render_lite.py
├── requirements.txt
├── script/
│ ├── convert.py
│ ├── kitti/
│ │ ├── colmap_kitti.py
│ │ ├── generate_dynamic_mask.py
│ │ ├── generate_semantic_mask.py
│ │ └── generate_sky_mask.py
│ ├── render_waymo_example.sh
│ ├── render_waymo_exp.sh
│ ├── test_gaussian_rasterization.py
│ ├── train_waymo_example.sh
│ ├── train_waymo_exp.sh
│ └── waymo/
│ ├── colmap_waymo_full.py
│ ├── generate_lidar_depth.py
│ ├── generate_mono_depth.py
│ ├── generate_mono_normal.py
│ ├── generate_sky_mask.py
│ ├── waymo_converter.py
│ └── waymo_splits/
│ ├── demo.txt
│ ├── more_examples.txt
│ ├── segment_list_train.txt
│ ├── segment_list_val.txt
│ ├── train_diverse.txt
│ ├── train_dynamic.txt
│ ├── train_static.txt
│ └── val_dynamic.txt
├── submodules/
│ ├── diff-gaussian-rasterization/
│ │ ├── .gitignore
│ │ ├── .gitmodules
│ │ ├── CMakeLists.txt
│ │ ├── LICENSE.md
│ │ ├── README.md
│ │ ├── cuda_rasterizer/
│ │ │ ├── auxiliary.h
│ │ │ ├── backward.cu
│ │ │ ├── backward.h
│ │ │ ├── config.h
│ │ │ ├── forward.cu
│ │ │ ├── forward.h
│ │ │ ├── rasterizer.h
│ │ │ ├── rasterizer_impl.cu
│ │ │ └── rasterizer_impl.h
│ │ ├── diff_gaussian_rasterization/
│ │ │ └── __init__.py
│ │ ├── ext.cpp
│ │ ├── rasterize_points.cu
│ │ ├── rasterize_points.h
│ │ ├── setup.py
│ │ └── third_party/
│ │ ├── glm/
│ │ │ ├── .appveyor.yml
│ │ │ ├── .gitignore
│ │ │ ├── .travis.yml
│ │ │ ├── CMakeLists.txt
│ │ │ ├── cmake/
│ │ │ │ └── cmake_uninstall.cmake.in
│ │ │ ├── copying.txt
│ │ │ ├── doc/
│ │ │ │ ├── api/
│ │ │ │ │ ├── a00001_source.html
│ │ │ │ │ ├── a00002_source.html
│ │ │ │ │ ├── a00003_source.html
│ │ │ │ │ ├── a00004_source.html
│ │ │ │ │ ├── a00005_source.html
│ │ │ │ │ ├── a00006_source.html
│ │ │ │ │ ├── a00007.html
│ │ │ │ │ ├── a00007_source.html
│ │ │ │ │ ├── a00008.html
│ │ │ │ │ ├── a00008_source.html
│ │ │ │ │ ├── a00009.html
│ │ │ │ │ ├── a00009_source.html
│ │ │ │ │ ├── a00010.html
│ │ │ │ │ ├── a00010_source.html
│ │ │ │ │ ├── a00011.html
│ │ │ │ │ ├── a00011_source.html
│ │ │ │ │ ├── a00012.html
│ │ │ │ │ ├── a00012_source.html
│ │ │ │ │ ├── a00013.html
│ │ │ │ │ ├── a00013_source.html
│ │ │ │ │ ├── a00014.html
│ │ │ │ │ ├── a00014_source.html
│ │ │ │ │ ├── a00015.html
│ │ │ │ │ ├── a00015_source.html
│ │ │ │ │ ├── a00016.html
│ │ │ │ │ ├── a00016_source.html
│ │ │ │ │ ├── a00017.html
│ │ │ │ │ ├── a00017_source.html
│ │ │ │ │ ├── a00018.html
│ │ │ │ │ ├── a00018_source.html
│ │ │ │ │ ├── a00019_source.html
│ │ │ │ │ ├── a00020_source.html
│ │ │ │ │ ├── a00021.html
│ │ │ │ │ ├── a00021_source.html
│ │ │ │ │ ├── a00022.html
│ │ │ │ │ ├── a00022_source.html
│ │ │ │ │ ├── a00023.html
│ │ │ │ │ ├── a00023_source.html
│ │ │ │ │ ├── a00024.html
│ │ │ │ │ ├── a00024_source.html
│ │ │ │ │ ├── a00025.html
│ │ │ │ │ ├── a00025_source.html
│ │ │ │ │ ├── a00026.html
│ │ │ │ │ ├── a00026_source.html
│ │ │ │ │ ├── a00027.html
│ │ │ │ │ ├── a00027_source.html
│ │ │ │ │ ├── a00028.html
│ │ │ │ │ ├── a00028_source.html
│ │ │ │ │ ├── a00029.html
│ │ │ │ │ ├── a00029_source.html
│ │ │ │ │ ├── a00030.html
│ │ │ │ │ ├── a00030_source.html
│ │ │ │ │ ├── a00031.html
│ │ │ │ │ ├── a00031_source.html
│ │ │ │ │ ├── a00032.html
│ │ │ │ │ ├── a00032_source.html
│ │ │ │ │ ├── a00033.html
│ │ │ │ │ ├── a00033_source.html
│ │ │ │ │ ├── a00034.html
│ │ │ │ │ ├── a00034_source.html
│ │ │ │ │ ├── a00035_source.html
│ │ │ │ │ ├── a00036.html
│ │ │ │ │ ├── a00036_source.html
│ │ │ │ │ ├── a00037.html
│ │ │ │ │ ├── a00037_source.html
│ │ │ │ │ ├── a00038.html
│ │ │ │ │ ├── a00038_source.html
│ │ │ │ │ ├── a00039.html
│ │ │ │ │ ├── a00039_source.html
│ │ │ │ │ ├── a00040.html
│ │ │ │ │ ├── a00040_source.html
│ │ │ │ │ ├── a00041.html
│ │ │ │ │ ├── a00041_source.html
│ │ │ │ │ ├── a00042.html
│ │ │ │ │ ├── a00042_source.html
│ │ │ │ │ ├── a00043.html
│ │ │ │ │ ├── a00043_source.html
│ │ │ │ │ ├── a00044.html
│ │ │ │ │ ├── a00044_source.html
│ │ │ │ │ ├── a00045.html
│ │ │ │ │ ├── a00045_source.html
│ │ │ │ │ ├── a00046.html
│ │ │ │ │ ├── a00046_source.html
│ │ │ │ │ ├── a00047_source.html
│ │ │ │ │ ├── a00048.html
│ │ │ │ │ ├── a00048_source.html
│ │ │ │ │ ├── a00049.html
│ │ │ │ │ ├── a00049_source.html
│ │ │ │ │ ├── a00050.html
│ │ │ │ │ ├── a00050_source.html
│ │ │ │ │ ├── a00051.html
│ │ │ │ │ ├── a00051_source.html
│ │ │ │ │ ├── a00052.html
│ │ │ │ │ ├── a00052_source.html
│ │ │ │ │ ├── a00053.html
│ │ │ │ │ ├── a00053_source.html
│ │ │ │ │ ├── a00054.html
│ │ │ │ │ ├── a00054_source.html
│ │ │ │ │ ├── a00055.html
│ │ │ │ │ ├── a00055_source.html
│ │ │ │ │ ├── a00056.html
│ │ │ │ │ ├── a00056_source.html
│ │ │ │ │ ├── a00057.html
│ │ │ │ │ ├── a00057_source.html
│ │ │ │ │ ├── a00058.html
│ │ │ │ │ ├── a00058_source.html
│ │ │ │ │ ├── a00059.html
│ │ │ │ │ ├── a00059_source.html
│ │ │ │ │ ├── a00060.html
│ │ │ │ │ ├── a00060_source.html
│ │ │ │ │ ├── a00061.html
│ │ │ │ │ ├── a00061_source.html
│ │ │ │ │ ├── a00062.html
│ │ │ │ │ ├── a00062_source.html
│ │ │ │ │ ├── a00063.html
│ │ │ │ │ ├── a00063_source.html
│ │ │ │ │ ├── a00064.html
│ │ │ │ │ ├── a00064_source.html
│ │ │ │ │ ├── a00065.html
│ │ │ │ │ ├── a00065_source.html
│ │ │ │ │ ├── a00066.html
│ │ │ │ │ ├── a00066_source.html
│ │ │ │ │ ├── a00067.html
│ │ │ │ │ ├── a00067_source.html
│ │ │ │ │ ├── a00068.html
│ │ │ │ │ ├── a00068_source.html
│ │ │ │ │ ├── a00069.html
│ │ │ │ │ ├── a00069_source.html
│ │ │ │ │ ├── a00070.html
│ │ │ │ │ ├── a00070_source.html
│ │ │ │ │ ├── a00071.html
│ │ │ │ │ ├── a00071_source.html
│ │ │ │ │ ├── a00072.html
│ │ │ │ │ ├── a00072_source.html
│ │ │ │ │ ├── a00073.html
│ │ │ │ │ ├── a00073_source.html
│ │ │ │ │ ├── a00074.html
│ │ │ │ │ ├── a00074_source.html
│ │ │ │ │ ├── a00075.html
│ │ │ │ │ ├── a00075_source.html
│ │ │ │ │ ├── a00076.html
│ │ │ │ │ ├── a00076_source.html
│ │ │ │ │ ├── a00077.html
│ │ │ │ │ ├── a00077_source.html
│ │ │ │ │ ├── a00078.html
│ │ │ │ │ ├── a00078_source.html
│ │ │ │ │ ├── a00079.html
│ │ │ │ │ ├── a00079_source.html
│ │ │ │ │ ├── a00080.html
│ │ │ │ │ ├── a00080_source.html
│ │ │ │ │ ├── a00081.html
│ │ │ │ │ ├── a00081_source.html
│ │ │ │ │ ├── a00082.html
│ │ │ │ │ ├── a00082_source.html
│ │ │ │ │ ├── a00083.html
│ │ │ │ │ ├── a00083_source.html
│ │ │ │ │ ├── a00084.html
│ │ │ │ │ ├── a00084_source.html
│ │ │ │ │ ├── a00085.html
│ │ │ │ │ ├── a00085_source.html
│ │ │ │ │ ├── a00086.html
│ │ │ │ │ ├── a00086_source.html
│ │ │ │ │ ├── a00087.html
│ │ │ │ │ ├── a00087_source.html
│ │ │ │ │ ├── a00088.html
│ │ │ │ │ ├── a00088_source.html
│ │ │ │ │ ├── a00089.html
│ │ │ │ │ ├── a00089_source.html
│ │ │ │ │ ├── a00090.html
│ │ │ │ │ ├── a00090_source.html
│ │ │ │ │ ├── a00091.html
│ │ │ │ │ ├── a00091_source.html
│ │ │ │ │ ├── a00092.html
│ │ │ │ │ ├── a00092_source.html
│ │ │ │ │ ├── a00093.html
│ │ │ │ │ ├── a00093_source.html
│ │ │ │ │ ├── a00094.html
│ │ │ │ │ ├── a00094_source.html
│ │ │ │ │ ├── a00095_source.html
│ │ │ │ │ ├── a00096.html
│ │ │ │ │ ├── a00096_source.html
│ │ │ │ │ ├── a00097.html
│ │ │ │ │ ├── a00097_source.html
│ │ │ │ │ ├── a00098.html
│ │ │ │ │ ├── a00098_source.html
│ │ │ │ │ ├── a00099.html
│ │ │ │ │ ├── a00099_source.html
│ │ │ │ │ ├── a00100.html
│ │ │ │ │ ├── a00100_source.html
│ │ │ │ │ ├── a00101.html
│ │ │ │ │ ├── a00101_source.html
│ │ │ │ │ ├── a00102.html
│ │ │ │ │ ├── a00102_source.html
│ │ │ │ │ ├── a00103.html
│ │ │ │ │ ├── a00103_source.html
│ │ │ │ │ ├── a00104.html
│ │ │ │ │ ├── a00104_source.html
│ │ │ │ │ ├── a00105.html
│ │ │ │ │ ├── a00105_source.html
│ │ │ │ │ ├── a00106.html
│ │ │ │ │ ├── a00106_source.html
│ │ │ │ │ ├── a00107.html
│ │ │ │ │ ├── a00107_source.html
│ │ │ │ │ ├── a00108.html
│ │ │ │ │ ├── a00108_source.html
│ │ │ │ │ ├── a00109.html
│ │ │ │ │ ├── a00109_source.html
│ │ │ │ │ ├── a00110.html
│ │ │ │ │ ├── a00110_source.html
│ │ │ │ │ ├── a00111.html
│ │ │ │ │ ├── a00111_source.html
│ │ │ │ │ ├── a00112.html
│ │ │ │ │ ├── a00112_source.html
│ │ │ │ │ ├── a00113.html
│ │ │ │ │ ├── a00113_source.html
│ │ │ │ │ ├── a00114.html
│ │ │ │ │ ├── a00114_source.html
│ │ │ │ │ ├── a00115.html
│ │ │ │ │ ├── a00115_source.html
│ │ │ │ │ ├── a00116.html
│ │ │ │ │ ├── a00116_source.html
│ │ │ │ │ ├── a00117.html
│ │ │ │ │ ├── a00117_source.html
│ │ │ │ │ ├── a00118.html
│ │ │ │ │ ├── a00118_source.html
│ │ │ │ │ ├── a00119.html
│ │ │ │ │ ├── a00119_source.html
│ │ │ │ │ ├── a00120.html
│ │ │ │ │ ├── a00120_source.html
│ │ │ │ │ ├── a00121.html
│ │ │ │ │ ├── a00121_source.html
│ │ │ │ │ ├── a00122.html
│ │ │ │ │ ├── a00122_source.html
│ │ │ │ │ ├── a00123.html
│ │ │ │ │ ├── a00123_source.html
│ │ │ │ │ ├── a00124_source.html
│ │ │ │ │ ├── a00125.html
│ │ │ │ │ ├── a00125_source.html
│ │ │ │ │ ├── a00126.html
│ │ │ │ │ ├── a00126_source.html
│ │ │ │ │ ├── a00127.html
│ │ │ │ │ ├── a00127_source.html
│ │ │ │ │ ├── a00128.html
│ │ │ │ │ ├── a00128_source.html
│ │ │ │ │ ├── a00129.html
│ │ │ │ │ ├── a00129_source.html
│ │ │ │ │ ├── a00130.html
│ │ │ │ │ ├── a00130_source.html
│ │ │ │ │ ├── a00131.html
│ │ │ │ │ ├── a00131_source.html
│ │ │ │ │ ├── a00132.html
│ │ │ │ │ ├── a00132_source.html
│ │ │ │ │ ├── a00133.html
│ │ │ │ │ ├── a00133_source.html
│ │ │ │ │ ├── a00134.html
│ │ │ │ │ ├── a00134_source.html
│ │ │ │ │ ├── a00135.html
│ │ │ │ │ ├── a00135_source.html
│ │ │ │ │ ├── a00136.html
│ │ │ │ │ ├── a00136_source.html
│ │ │ │ │ ├── a00137.html
│ │ │ │ │ ├── a00137_source.html
│ │ │ │ │ ├── a00138.html
│ │ │ │ │ ├── a00138_source.html
│ │ │ │ │ ├── a00139.html
│ │ │ │ │ ├── a00139_source.html
│ │ │ │ │ ├── a00140.html
│ │ │ │ │ ├── a00140_source.html
│ │ │ │ │ ├── a00141.html
│ │ │ │ │ ├── a00141_source.html
│ │ │ │ │ ├── a00142.html
│ │ │ │ │ ├── a00142_source.html
│ │ │ │ │ ├── a00143.html
│ │ │ │ │ ├── a00143_source.html
│ │ │ │ │ ├── a00144.html
│ │ │ │ │ ├── a00144_source.html
│ │ │ │ │ ├── a00145.html
│ │ │ │ │ ├── a00145_source.html
│ │ │ │ │ ├── a00146.html
│ │ │ │ │ ├── a00146_source.html
│ │ │ │ │ ├── a00147.html
│ │ │ │ │ ├── a00147_source.html
│ │ │ │ │ ├── a00148.html
│ │ │ │ │ ├── a00148_source.html
│ │ │ │ │ ├── a00149.html
│ │ │ │ │ ├── a00149_source.html
│ │ │ │ │ ├── a00150.html
│ │ │ │ │ ├── a00150_source.html
│ │ │ │ │ ├── a00151.html
│ │ │ │ │ ├── a00151_source.html
│ │ │ │ │ ├── a00152.html
│ │ │ │ │ ├── a00152_source.html
│ │ │ │ │ ├── a00153_source.html
│ │ │ │ │ ├── a00154.html
│ │ │ │ │ ├── a00154_source.html
│ │ │ │ │ ├── a00155.html
│ │ │ │ │ ├── a00155_source.html
│ │ │ │ │ ├── a00156.html
│ │ │ │ │ ├── a00156_source.html
│ │ │ │ │ ├── a00157.html
│ │ │ │ │ ├── a00157_source.html
│ │ │ │ │ ├── a00158.html
│ │ │ │ │ ├── a00158_source.html
│ │ │ │ │ ├── a00159.html
│ │ │ │ │ ├── a00159_source.html
│ │ │ │ │ ├── a00160.html
│ │ │ │ │ ├── a00160_source.html
│ │ │ │ │ ├── a00161.html
│ │ │ │ │ ├── a00161_source.html
│ │ │ │ │ ├── a00162.html
│ │ │ │ │ ├── a00162_source.html
│ │ │ │ │ ├── a00163_source.html
│ │ │ │ │ ├── a00164_source.html
│ │ │ │ │ ├── a00165.html
│ │ │ │ │ ├── a00165_source.html
│ │ │ │ │ ├── a00166.html
│ │ │ │ │ ├── a00166_source.html
│ │ │ │ │ ├── a00167.html
│ │ │ │ │ ├── a00167_source.html
│ │ │ │ │ ├── a00168.html
│ │ │ │ │ ├── a00168_source.html
│ │ │ │ │ ├── a00169.html
│ │ │ │ │ ├── a00169_source.html
│ │ │ │ │ ├── a00170.html
│ │ │ │ │ ├── a00170_source.html
│ │ │ │ │ ├── a00171.html
│ │ │ │ │ ├── a00171_source.html
│ │ │ │ │ ├── a00172.html
│ │ │ │ │ ├── a00172_source.html
│ │ │ │ │ ├── a00173.html
│ │ │ │ │ ├── a00173_source.html
│ │ │ │ │ ├── a00174.html
│ │ │ │ │ ├── a00174_source.html
│ │ │ │ │ ├── a00175.html
│ │ │ │ │ ├── a00175_source.html
│ │ │ │ │ ├── a00176.html
│ │ │ │ │ ├── a00176_source.html
│ │ │ │ │ ├── a00177.html
│ │ │ │ │ ├── a00177_source.html
│ │ │ │ │ ├── a00178.html
│ │ │ │ │ ├── a00178_source.html
│ │ │ │ │ ├── a00179.html
│ │ │ │ │ ├── a00179_source.html
│ │ │ │ │ ├── a00180.html
│ │ │ │ │ ├── a00180_source.html
│ │ │ │ │ ├── a00181.html
│ │ │ │ │ ├── a00181_source.html
│ │ │ │ │ ├── a00182.html
│ │ │ │ │ ├── a00182_source.html
│ │ │ │ │ ├── a00183.html
│ │ │ │ │ ├── a00183_source.html
│ │ │ │ │ ├── a00184.html
│ │ │ │ │ ├── a00184_source.html
│ │ │ │ │ ├── a00185.html
│ │ │ │ │ ├── a00185_source.html
│ │ │ │ │ ├── a00186.html
│ │ │ │ │ ├── a00186_source.html
│ │ │ │ │ ├── a00187.html
│ │ │ │ │ ├── a00187_source.html
│ │ │ │ │ ├── a00188.html
│ │ │ │ │ ├── a00188_source.html
│ │ │ │ │ ├── a00189.html
│ │ │ │ │ ├── a00189_source.html
│ │ │ │ │ ├── a00190.html
│ │ │ │ │ ├── a00190_source.html
│ │ │ │ │ ├── a00191.html
│ │ │ │ │ ├── a00191_source.html
│ │ │ │ │ ├── a00192.html
│ │ │ │ │ ├── a00192_source.html
│ │ │ │ │ ├── a00193.html
│ │ │ │ │ ├── a00193_source.html
│ │ │ │ │ ├── a00194.html
│ │ │ │ │ ├── a00194_source.html
│ │ │ │ │ ├── a00195.html
│ │ │ │ │ ├── a00195_source.html
│ │ │ │ │ ├── a00196.html
│ │ │ │ │ ├── a00196_source.html
│ │ │ │ │ ├── a00197.html
│ │ │ │ │ ├── a00197_source.html
│ │ │ │ │ ├── a00198.html
│ │ │ │ │ ├── a00198_source.html
│ │ │ │ │ ├── a00199.html
│ │ │ │ │ ├── a00199_source.html
│ │ │ │ │ ├── a00200.html
│ │ │ │ │ ├── a00200_source.html
│ │ │ │ │ ├── a00201.html
│ │ │ │ │ ├── a00201_source.html
│ │ │ │ │ ├── a00202.html
│ │ │ │ │ ├── a00202_source.html
│ │ │ │ │ ├── a00203.html
│ │ │ │ │ ├── a00203_source.html
│ │ │ │ │ ├── a00204.html
│ │ │ │ │ ├── a00204_source.html
│ │ │ │ │ ├── a00205.html
│ │ │ │ │ ├── a00205_source.html
│ │ │ │ │ ├── a00206.html
│ │ │ │ │ ├── a00206_source.html
│ │ │ │ │ ├── a00207.html
│ │ │ │ │ ├── a00207_source.html
│ │ │ │ │ ├── a00208.html
│ │ │ │ │ ├── a00208_source.html
│ │ │ │ │ ├── a00209.html
│ │ │ │ │ ├── a00209_source.html
│ │ │ │ │ ├── a00210.html
│ │ │ │ │ ├── a00210_source.html
│ │ │ │ │ ├── a00211.html
│ │ │ │ │ ├── a00211_source.html
│ │ │ │ │ ├── a00212.html
│ │ │ │ │ ├── a00212_source.html
│ │ │ │ │ ├── a00213.html
│ │ │ │ │ ├── a00213_source.html
│ │ │ │ │ ├── a00214.html
│ │ │ │ │ ├── a00214_source.html
│ │ │ │ │ ├── a00215.html
│ │ │ │ │ ├── a00215_source.html
│ │ │ │ │ ├── a00216.html
│ │ │ │ │ ├── a00216_source.html
│ │ │ │ │ ├── a00217.html
│ │ │ │ │ ├── a00217_source.html
│ │ │ │ │ ├── a00218.html
│ │ │ │ │ ├── a00218_source.html
│ │ │ │ │ ├── a00219.html
│ │ │ │ │ ├── a00219_source.html
│ │ │ │ │ ├── a00220.html
│ │ │ │ │ ├── a00220_source.html
│ │ │ │ │ ├── a00221.html
│ │ │ │ │ ├── a00221_source.html
│ │ │ │ │ ├── a00222.html
│ │ │ │ │ ├── a00222_source.html
│ │ │ │ │ ├── a00223.html
│ │ │ │ │ ├── a00223_source.html
│ │ │ │ │ ├── a00224.html
│ │ │ │ │ ├── a00224_source.html
│ │ │ │ │ ├── a00225.html
│ │ │ │ │ ├── a00225_source.html
│ │ │ │ │ ├── a00226.html
│ │ │ │ │ ├── a00226_source.html
│ │ │ │ │ ├── a00227.html
│ │ │ │ │ ├── a00227_source.html
│ │ │ │ │ ├── a00228.html
│ │ │ │ │ ├── a00228_source.html
│ │ │ │ │ ├── a00229.html
│ │ │ │ │ ├── a00229_source.html
│ │ │ │ │ ├── a00230.html
│ │ │ │ │ ├── a00230_source.html
│ │ │ │ │ ├── a00231.html
│ │ │ │ │ ├── a00231_source.html
│ │ │ │ │ ├── a00232.html
│ │ │ │ │ ├── a00232_source.html
│ │ │ │ │ ├── a00233.html
│ │ │ │ │ ├── a00233_source.html
│ │ │ │ │ ├── a00234.html
│ │ │ │ │ ├── a00234_source.html
│ │ │ │ │ ├── a00235.html
│ │ │ │ │ ├── a00235_source.html
│ │ │ │ │ ├── a00241.html
│ │ │ │ │ ├── a00242.html
│ │ │ │ │ ├── a00243.html
│ │ │ │ │ ├── a00244.html
│ │ │ │ │ ├── a00245.html
│ │ │ │ │ ├── a00246.html
│ │ │ │ │ ├── a00247.html
│ │ │ │ │ ├── a00248.html
│ │ │ │ │ ├── a00249.html
│ │ │ │ │ ├── a00250.html
│ │ │ │ │ ├── a00251.html
│ │ │ │ │ ├── a00252.html
│ │ │ │ │ ├── a00253.html
│ │ │ │ │ ├── a00254.html
│ │ │ │ │ ├── a00255.html
│ │ │ │ │ ├── a00256.html
│ │ │ │ │ ├── a00257.html
│ │ │ │ │ ├── a00258.html
│ │ │ │ │ ├── a00259.html
│ │ │ │ │ ├── a00260.html
│ │ │ │ │ ├── a00261.html
│ │ │ │ │ ├── a00262.html
│ │ │ │ │ ├── a00263.html
│ │ │ │ │ ├── a00264.html
│ │ │ │ │ ├── a00265.html
│ │ │ │ │ ├── a00266.html
│ │ │ │ │ ├── a00267.html
│ │ │ │ │ ├── a00268.html
│ │ │ │ │ ├── a00269.html
│ │ │ │ │ ├── a00270.html
│ │ │ │ │ ├── a00271.html
│ │ │ │ │ ├── a00272.html
│ │ │ │ │ ├── a00273.html
│ │ │ │ │ ├── a00274.html
│ │ │ │ │ ├── a00275.html
│ │ │ │ │ ├── a00276.html
│ │ │ │ │ ├── a00277.html
│ │ │ │ │ ├── a00278.html
│ │ │ │ │ ├── a00279.html
│ │ │ │ │ ├── a00280.html
│ │ │ │ │ ├── a00281.html
│ │ │ │ │ ├── a00282.html
│ │ │ │ │ ├── a00283.html
│ │ │ │ │ ├── a00284.html
│ │ │ │ │ ├── a00285.html
│ │ │ │ │ ├── a00286.html
│ │ │ │ │ ├── a00287.html
│ │ │ │ │ ├── a00288.html
│ │ │ │ │ ├── a00289.html
│ │ │ │ │ ├── a00290.html
│ │ │ │ │ ├── a00291.html
│ │ │ │ │ ├── a00292.html
│ │ │ │ │ ├── a00293.html
│ │ │ │ │ ├── a00294.html
│ │ │ │ │ ├── a00295.html
│ │ │ │ │ ├── a00296.html
│ │ │ │ │ ├── a00297.html
│ │ │ │ │ ├── a00298.html
│ │ │ │ │ ├── a00299.html
│ │ │ │ │ ├── a00300.html
│ │ │ │ │ ├── a00301.html
│ │ │ │ │ ├── a00302.html
│ │ │ │ │ ├── a00303.html
│ │ │ │ │ ├── a00304.html
│ │ │ │ │ ├── a00305.html
│ │ │ │ │ ├── a00306.html
│ │ │ │ │ ├── a00307.html
│ │ │ │ │ ├── a00308.html
│ │ │ │ │ ├── a00309.html
│ │ │ │ │ ├── a00310.html
│ │ │ │ │ ├── a00311.html
│ │ │ │ │ ├── a00312.html
│ │ │ │ │ ├── a00313.html
│ │ │ │ │ ├── a00314.html
│ │ │ │ │ ├── a00315.html
│ │ │ │ │ ├── a00316.html
│ │ │ │ │ ├── a00317.html
│ │ │ │ │ ├── a00318.html
│ │ │ │ │ ├── a00319.html
│ │ │ │ │ ├── a00320.html
│ │ │ │ │ ├── a00321.html
│ │ │ │ │ ├── a00322.html
│ │ │ │ │ ├── a00323.html
│ │ │ │ │ ├── a00324.html
│ │ │ │ │ ├── a00325.html
│ │ │ │ │ ├── a00326.html
│ │ │ │ │ ├── a00327.html
│ │ │ │ │ ├── a00328.html
│ │ │ │ │ ├── a00329.html
│ │ │ │ │ ├── a00330.html
│ │ │ │ │ ├── a00331.html
│ │ │ │ │ ├── a00332.html
│ │ │ │ │ ├── a00333.html
│ │ │ │ │ ├── a00334.html
│ │ │ │ │ ├── a00335.html
│ │ │ │ │ ├── a00336.html
│ │ │ │ │ ├── a00337.html
│ │ │ │ │ ├── a00338.html
│ │ │ │ │ ├── a00339.html
│ │ │ │ │ ├── a00340.html
│ │ │ │ │ ├── a00341.html
│ │ │ │ │ ├── a00342.html
│ │ │ │ │ ├── a00343.html
│ │ │ │ │ ├── a00344.html
│ │ │ │ │ ├── a00345.html
│ │ │ │ │ ├── a00346.html
│ │ │ │ │ ├── a00347.html
│ │ │ │ │ ├── a00348.html
│ │ │ │ │ ├── a00349.html
│ │ │ │ │ ├── a00350.html
│ │ │ │ │ ├── a00351.html
│ │ │ │ │ ├── a00352.html
│ │ │ │ │ ├── a00353.html
│ │ │ │ │ ├── a00354.html
│ │ │ │ │ ├── a00355.html
│ │ │ │ │ ├── a00356.html
│ │ │ │ │ ├── a00357.html
│ │ │ │ │ ├── a00358.html
│ │ │ │ │ ├── a00359.html
│ │ │ │ │ ├── a00360.html
│ │ │ │ │ ├── a00361.html
│ │ │ │ │ ├── a00362.html
│ │ │ │ │ ├── a00363.html
│ │ │ │ │ ├── a00364.html
│ │ │ │ │ ├── a00365.html
│ │ │ │ │ ├── a00366.html
│ │ │ │ │ ├── a00367.html
│ │ │ │ │ ├── a00368.html
│ │ │ │ │ ├── a00369.html
│ │ │ │ │ ├── a00370.html
│ │ │ │ │ ├── a00371.html
│ │ │ │ │ ├── a00372.html
│ │ │ │ │ ├── a00373.html
│ │ │ │ │ ├── a00374.html
│ │ │ │ │ ├── dir_033f5edb0915b828d2c46ed4804e5503.html
│ │ │ │ │ ├── dir_3a581ba30d25676e4b797b1f96d53b45.html
│ │ │ │ │ ├── dir_44e5e654415abd9ca6fdeaddaff8565e.html
│ │ │ │ │ ├── dir_4c6bd29c73fa4e5a2509e1c15f846751.html
│ │ │ │ │ ├── dir_5189610d3ba09ec39b766fb99b34cd93.html
│ │ │ │ │ ├── dir_6b66465792d005310484819a0eb0b0d3.html
│ │ │ │ │ ├── dir_9e5fe034a00e89334fd5186c3e7db156.html
│ │ │ │ │ ├── dir_a8bee7be44182a33f3820393ae0b105d.html
│ │ │ │ │ ├── dir_cef2d71d502cb69a9252bca2297d9549.html
│ │ │ │ │ ├── dir_d9496f0844b48bc7e53b5af8c99b9ab2.html
│ │ │ │ │ ├── dir_f35778ec600a1b9bbc4524e62e226aa2.html
│ │ │ │ │ ├── doxygen.css
│ │ │ │ │ ├── dynsections.js
│ │ │ │ │ ├── files.html
│ │ │ │ │ ├── index.html
│ │ │ │ │ ├── jquery.js
│ │ │ │ │ ├── modules.html
│ │ │ │ │ ├── search/
│ │ │ │ │ │ ├── all_0.html
│ │ │ │ │ │ ├── all_0.js
│ │ │ │ │ │ ├── all_1.html
│ │ │ │ │ │ ├── all_1.js
│ │ │ │ │ │ ├── all_10.html
│ │ │ │ │ │ ├── all_10.js
│ │ │ │ │ │ ├── all_11.html
│ │ │ │ │ │ ├── all_11.js
│ │ │ │ │ │ ├── all_12.html
│ │ │ │ │ │ ├── all_12.js
│ │ │ │ │ │ ├── all_13.html
│ │ │ │ │ │ ├── all_13.js
│ │ │ │ │ │ ├── all_14.html
│ │ │ │ │ │ ├── all_14.js
│ │ │ │ │ │ ├── all_15.html
│ │ │ │ │ │ ├── all_15.js
│ │ │ │ │ │ ├── all_16.html
│ │ │ │ │ │ ├── all_16.js
│ │ │ │ │ │ ├── all_2.html
│ │ │ │ │ │ ├── all_2.js
│ │ │ │ │ │ ├── all_3.html
│ │ │ │ │ │ ├── all_3.js
│ │ │ │ │ │ ├── all_4.html
│ │ │ │ │ │ ├── all_4.js
│ │ │ │ │ │ ├── all_5.html
│ │ │ │ │ │ ├── all_5.js
│ │ │ │ │ │ ├── all_6.html
│ │ │ │ │ │ ├── all_6.js
│ │ │ │ │ │ ├── all_7.html
│ │ │ │ │ │ ├── all_7.js
│ │ │ │ │ │ ├── all_8.html
│ │ │ │ │ │ ├── all_8.js
│ │ │ │ │ │ ├── all_9.html
│ │ │ │ │ │ ├── all_9.js
│ │ │ │ │ │ ├── all_a.html
│ │ │ │ │ │ ├── all_a.js
│ │ │ │ │ │ ├── all_b.html
│ │ │ │ │ │ ├── all_b.js
│ │ │ │ │ │ ├── all_c.html
│ │ │ │ │ │ ├── all_c.js
│ │ │ │ │ │ ├── all_d.html
│ │ │ │ │ │ ├── all_d.js
│ │ │ │ │ │ ├── all_e.html
│ │ │ │ │ │ ├── all_e.js
│ │ │ │ │ │ ├── all_f.html
│ │ │ │ │ │ ├── all_f.js
│ │ │ │ │ │ ├── files_0.html
│ │ │ │ │ │ ├── files_0.js
│ │ │ │ │ │ ├── files_1.html
│ │ │ │ │ │ ├── files_1.js
│ │ │ │ │ │ ├── files_10.html
│ │ │ │ │ │ ├── files_10.js
│ │ │ │ │ │ ├── files_11.html
│ │ │ │ │ │ ├── files_11.js
│ │ │ │ │ │ ├── files_12.html
│ │ │ │ │ │ ├── files_12.js
│ │ │ │ │ │ ├── files_13.html
│ │ │ │ │ │ ├── files_13.js
│ │ │ │ │ │ ├── files_14.html
│ │ │ │ │ │ ├── files_14.js
│ │ │ │ │ │ ├── files_2.html
│ │ │ │ │ │ ├── files_2.js
│ │ │ │ │ │ ├── files_3.html
│ │ │ │ │ │ ├── files_3.js
│ │ │ │ │ │ ├── files_4.html
│ │ │ │ │ │ ├── files_4.js
│ │ │ │ │ │ ├── files_5.html
│ │ │ │ │ │ ├── files_5.js
│ │ │ │ │ │ ├── files_6.html
│ │ │ │ │ │ ├── files_6.js
│ │ │ │ │ │ ├── files_7.html
│ │ │ │ │ │ ├── files_7.js
│ │ │ │ │ │ ├── files_8.html
│ │ │ │ │ │ ├── files_8.js
│ │ │ │ │ │ ├── files_9.html
│ │ │ │ │ │ ├── files_9.js
│ │ │ │ │ │ ├── files_a.html
│ │ │ │ │ │ ├── files_a.js
│ │ │ │ │ │ ├── files_b.html
│ │ │ │ │ │ ├── files_b.js
│ │ │ │ │ │ ├── files_c.html
│ │ │ │ │ │ ├── files_c.js
│ │ │ │ │ │ ├── files_d.html
│ │ │ │ │ │ ├── files_d.js
│ │ │ │ │ │ ├── files_e.html
│ │ │ │ │ │ ├── files_e.js
│ │ │ │ │ │ ├── files_f.html
│ │ │ │ │ │ ├── files_f.js
│ │ │ │ │ │ ├── functions_0.html
│ │ │ │ │ │ ├── functions_0.js
│ │ │ │ │ │ ├── functions_1.html
│ │ │ │ │ │ ├── functions_1.js
│ │ │ │ │ │ ├── functions_10.html
│ │ │ │ │ │ ├── functions_10.js
│ │ │ │ │ │ ├── functions_11.html
│ │ │ │ │ │ ├── functions_11.js
│ │ │ │ │ │ ├── functions_12.html
│ │ │ │ │ │ ├── functions_12.js
│ │ │ │ │ │ ├── functions_13.html
│ │ │ │ │ │ ├── functions_13.js
│ │ │ │ │ │ ├── functions_14.html
│ │ │ │ │ │ ├── functions_14.js
│ │ │ │ │ │ ├── functions_15.html
│ │ │ │ │ │ ├── functions_15.js
│ │ │ │ │ │ ├── functions_16.html
│ │ │ │ │ │ ├── functions_16.js
│ │ │ │ │ │ ├── functions_2.html
│ │ │ │ │ │ ├── functions_2.js
│ │ │ │ │ │ ├── functions_3.html
│ │ │ │ │ │ ├── functions_3.js
│ │ │ │ │ │ ├── functions_4.html
│ │ │ │ │ │ ├── functions_4.js
│ │ │ │ │ │ ├── functions_5.html
│ │ │ │ │ │ ├── functions_5.js
│ │ │ │ │ │ ├── functions_6.html
│ │ │ │ │ │ ├── functions_6.js
│ │ │ │ │ │ ├── functions_7.html
│ │ │ │ │ │ ├── functions_7.js
│ │ │ │ │ │ ├── functions_8.html
│ │ │ │ │ │ ├── functions_8.js
│ │ │ │ │ │ ├── functions_9.html
│ │ │ │ │ │ ├── functions_9.js
│ │ │ │ │ │ ├── functions_a.html
│ │ │ │ │ │ ├── functions_a.js
│ │ │ │ │ │ ├── functions_b.html
│ │ │ │ │ │ ├── functions_b.js
│ │ │ │ │ │ ├── functions_c.html
│ │ │ │ │ │ ├── functions_c.js
│ │ │ │ │ │ ├── functions_d.html
│ │ │ │ │ │ ├── functions_d.js
│ │ │ │ │ │ ├── functions_e.html
│ │ │ │ │ │ ├── functions_e.js
│ │ │ │ │ │ ├── functions_f.html
│ │ │ │ │ │ ├── functions_f.js
│ │ │ │ │ │ ├── groups_0.html
│ │ │ │ │ │ ├── groups_0.js
│ │ │ │ │ │ ├── groups_1.html
│ │ │ │ │ │ ├── groups_1.js
│ │ │ │ │ │ ├── groups_2.html
│ │ │ │ │ │ ├── groups_2.js
│ │ │ │ │ │ ├── groups_3.html
│ │ │ │ │ │ ├── groups_3.js
│ │ │ │ │ │ ├── groups_4.html
│ │ │ │ │ │ ├── groups_4.js
│ │ │ │ │ │ ├── groups_5.html
│ │ │ │ │ │ ├── groups_5.js
│ │ │ │ │ │ ├── groups_6.html
│ │ │ │ │ │ ├── groups_6.js
│ │ │ │ │ │ ├── groups_7.html
│ │ │ │ │ │ ├── groups_7.js
│ │ │ │ │ │ ├── groups_8.html
│ │ │ │ │ │ ├── groups_8.js
│ │ │ │ │ │ ├── groups_9.html
│ │ │ │ │ │ ├── groups_9.js
│ │ │ │ │ │ ├── nomatches.html
│ │ │ │ │ │ ├── pages_0.html
│ │ │ │ │ │ ├── pages_0.js
│ │ │ │ │ │ ├── search.css
│ │ │ │ │ │ ├── search.js
│ │ │ │ │ │ ├── searchdata.js
│ │ │ │ │ │ ├── typedefs_0.html
│ │ │ │ │ │ ├── typedefs_0.js
│ │ │ │ │ │ ├── typedefs_1.html
│ │ │ │ │ │ ├── typedefs_1.js
│ │ │ │ │ │ ├── typedefs_2.html
│ │ │ │ │ │ ├── typedefs_2.js
│ │ │ │ │ │ ├── typedefs_3.html
│ │ │ │ │ │ ├── typedefs_3.js
│ │ │ │ │ │ ├── typedefs_4.html
│ │ │ │ │ │ ├── typedefs_4.js
│ │ │ │ │ │ ├── typedefs_5.html
│ │ │ │ │ │ ├── typedefs_5.js
│ │ │ │ │ │ ├── typedefs_6.html
│ │ │ │ │ │ ├── typedefs_6.js
│ │ │ │ │ │ ├── typedefs_7.html
│ │ │ │ │ │ ├── typedefs_7.js
│ │ │ │ │ │ ├── typedefs_8.html
│ │ │ │ │ │ ├── typedefs_8.js
│ │ │ │ │ │ ├── typedefs_9.html
│ │ │ │ │ │ ├── typedefs_9.js
│ │ │ │ │ │ ├── typedefs_a.html
│ │ │ │ │ │ ├── typedefs_a.js
│ │ │ │ │ │ ├── typedefs_b.html
│ │ │ │ │ │ ├── typedefs_b.js
│ │ │ │ │ │ ├── typedefs_c.html
│ │ │ │ │ │ ├── typedefs_c.js
│ │ │ │ │ │ ├── typedefs_d.html
│ │ │ │ │ │ └── typedefs_d.js
│ │ │ │ │ └── tabs.css
│ │ │ │ ├── man.doxy
│ │ │ │ └── theme/
│ │ │ │ └── doxygen.css
│ │ │ ├── glm/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── common.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ ├── _features.hpp
│ │ │ │ │ ├── _fixes.hpp
│ │ │ │ │ ├── _noise.hpp
│ │ │ │ │ ├── _swizzle.hpp
│ │ │ │ │ ├── _swizzle_func.hpp
│ │ │ │ │ ├── _vectorize.hpp
│ │ │ │ │ ├── compute_common.hpp
│ │ │ │ │ ├── compute_vector_relational.hpp
│ │ │ │ │ ├── func_common.inl
│ │ │ │ │ ├── func_common_simd.inl
│ │ │ │ │ ├── func_exponential.inl
│ │ │ │ │ ├── func_exponential_simd.inl
│ │ │ │ │ ├── func_geometric.inl
│ │ │ │ │ ├── func_geometric_simd.inl
│ │ │ │ │ ├── func_integer.inl
│ │ │ │ │ ├── func_integer_simd.inl
│ │ │ │ │ ├── func_matrix.inl
│ │ │ │ │ ├── func_matrix_simd.inl
│ │ │ │ │ ├── func_packing.inl
│ │ │ │ │ ├── func_packing_simd.inl
│ │ │ │ │ ├── func_trigonometric.inl
│ │ │ │ │ ├── func_trigonometric_simd.inl
│ │ │ │ │ ├── func_vector_relational.inl
│ │ │ │ │ ├── func_vector_relational_simd.inl
│ │ │ │ │ ├── glm.cpp
│ │ │ │ │ ├── qualifier.hpp
│ │ │ │ │ ├── setup.hpp
│ │ │ │ │ ├── type_float.hpp
│ │ │ │ │ ├── type_half.hpp
│ │ │ │ │ ├── type_half.inl
│ │ │ │ │ ├── type_mat2x2.hpp
│ │ │ │ │ ├── type_mat2x2.inl
│ │ │ │ │ ├── type_mat2x3.hpp
│ │ │ │ │ ├── type_mat2x3.inl
│ │ │ │ │ ├── type_mat2x4.hpp
│ │ │ │ │ ├── type_mat2x4.inl
│ │ │ │ │ ├── type_mat3x2.hpp
│ │ │ │ │ ├── type_mat3x2.inl
│ │ │ │ │ ├── type_mat3x3.hpp
│ │ │ │ │ ├── type_mat3x3.inl
│ │ │ │ │ ├── type_mat3x4.hpp
│ │ │ │ │ ├── type_mat3x4.inl
│ │ │ │ │ ├── type_mat4x2.hpp
│ │ │ │ │ ├── type_mat4x2.inl
│ │ │ │ │ ├── type_mat4x3.hpp
│ │ │ │ │ ├── type_mat4x3.inl
│ │ │ │ │ ├── type_mat4x4.hpp
│ │ │ │ │ ├── type_mat4x4.inl
│ │ │ │ │ ├── type_mat4x4_simd.inl
│ │ │ │ │ ├── type_quat.hpp
│ │ │ │ │ ├── type_quat.inl
│ │ │ │ │ ├── type_quat_simd.inl
│ │ │ │ │ ├── type_vec1.hpp
│ │ │ │ │ ├── type_vec1.inl
│ │ │ │ │ ├── type_vec2.hpp
│ │ │ │ │ ├── type_vec2.inl
│ │ │ │ │ ├── type_vec3.hpp
│ │ │ │ │ ├── type_vec3.inl
│ │ │ │ │ ├── type_vec4.hpp
│ │ │ │ │ ├── type_vec4.inl
│ │ │ │ │ └── type_vec4_simd.inl
│ │ │ │ ├── exponential.hpp
│ │ │ │ ├── ext/
│ │ │ │ │ ├── _matrix_vectorize.hpp
│ │ │ │ │ ├── matrix_clip_space.hpp
│ │ │ │ │ ├── matrix_clip_space.inl
│ │ │ │ │ ├── matrix_common.hpp
│ │ │ │ │ ├── matrix_common.inl
│ │ │ │ │ ├── matrix_double2x2.hpp
│ │ │ │ │ ├── matrix_double2x2_precision.hpp
│ │ │ │ │ ├── matrix_double2x3.hpp
│ │ │ │ │ ├── matrix_double2x3_precision.hpp
│ │ │ │ │ ├── matrix_double2x4.hpp
│ │ │ │ │ ├── matrix_double2x4_precision.hpp
│ │ │ │ │ ├── matrix_double3x2.hpp
│ │ │ │ │ ├── matrix_double3x2_precision.hpp
│ │ │ │ │ ├── matrix_double3x3.hpp
│ │ │ │ │ ├── matrix_double3x3_precision.hpp
│ │ │ │ │ ├── matrix_double3x4.hpp
│ │ │ │ │ ├── matrix_double3x4_precision.hpp
│ │ │ │ │ ├── matrix_double4x2.hpp
│ │ │ │ │ ├── matrix_double4x2_precision.hpp
│ │ │ │ │ ├── matrix_double4x3.hpp
│ │ │ │ │ ├── matrix_double4x3_precision.hpp
│ │ │ │ │ ├── matrix_double4x4.hpp
│ │ │ │ │ ├── matrix_double4x4_precision.hpp
│ │ │ │ │ ├── matrix_float2x2.hpp
│ │ │ │ │ ├── matrix_float2x2_precision.hpp
│ │ │ │ │ ├── matrix_float2x3.hpp
│ │ │ │ │ ├── matrix_float2x3_precision.hpp
│ │ │ │ │ ├── matrix_float2x4.hpp
│ │ │ │ │ ├── matrix_float2x4_precision.hpp
│ │ │ │ │ ├── matrix_float3x2.hpp
│ │ │ │ │ ├── matrix_float3x2_precision.hpp
│ │ │ │ │ ├── matrix_float3x3.hpp
│ │ │ │ │ ├── matrix_float3x3_precision.hpp
│ │ │ │ │ ├── matrix_float3x4.hpp
│ │ │ │ │ ├── matrix_float3x4_precision.hpp
│ │ │ │ │ ├── matrix_float4x2.hpp
│ │ │ │ │ ├── matrix_float4x2_precision.hpp
│ │ │ │ │ ├── matrix_float4x3.hpp
│ │ │ │ │ ├── matrix_float4x3_precision.hpp
│ │ │ │ │ ├── matrix_float4x4.hpp
│ │ │ │ │ ├── matrix_float4x4_precision.hpp
│ │ │ │ │ ├── matrix_int2x2.hpp
│ │ │ │ │ ├── matrix_int2x2_sized.hpp
│ │ │ │ │ ├── matrix_int2x3.hpp
│ │ │ │ │ ├── matrix_int2x3_sized.hpp
│ │ │ │ │ ├── matrix_int2x4.hpp
│ │ │ │ │ ├── matrix_int2x4_sized.hpp
│ │ │ │ │ ├── matrix_int3x2.hpp
│ │ │ │ │ ├── matrix_int3x2_sized.hpp
│ │ │ │ │ ├── matrix_int3x3.hpp
│ │ │ │ │ ├── matrix_int3x3_sized.hpp
│ │ │ │ │ ├── matrix_int3x4.hpp
│ │ │ │ │ ├── matrix_int3x4_sized.hpp
│ │ │ │ │ ├── matrix_int4x2.hpp
│ │ │ │ │ ├── matrix_int4x2_sized.hpp
│ │ │ │ │ ├── matrix_int4x3.hpp
│ │ │ │ │ ├── matrix_int4x3_sized.hpp
│ │ │ │ │ ├── matrix_int4x4.hpp
│ │ │ │ │ ├── matrix_int4x4_sized.hpp
│ │ │ │ │ ├── matrix_integer.hpp
│ │ │ │ │ ├── matrix_integer.inl
│ │ │ │ │ ├── matrix_projection.hpp
│ │ │ │ │ ├── matrix_projection.inl
│ │ │ │ │ ├── matrix_relational.hpp
│ │ │ │ │ ├── matrix_relational.inl
│ │ │ │ │ ├── matrix_transform.hpp
│ │ │ │ │ ├── matrix_transform.inl
│ │ │ │ │ ├── matrix_uint2x2.hpp
│ │ │ │ │ ├── matrix_uint2x2_sized.hpp
│ │ │ │ │ ├── matrix_uint2x3.hpp
│ │ │ │ │ ├── matrix_uint2x3_sized.hpp
│ │ │ │ │ ├── matrix_uint2x4.hpp
│ │ │ │ │ ├── matrix_uint2x4_sized.hpp
│ │ │ │ │ ├── matrix_uint3x2.hpp
│ │ │ │ │ ├── matrix_uint3x2_sized.hpp
│ │ │ │ │ ├── matrix_uint3x3.hpp
│ │ │ │ │ ├── matrix_uint3x3_sized.hpp
│ │ │ │ │ ├── matrix_uint3x4.hpp
│ │ │ │ │ ├── matrix_uint3x4_sized.hpp
│ │ │ │ │ ├── matrix_uint4x2.hpp
│ │ │ │ │ ├── matrix_uint4x2_sized.hpp
│ │ │ │ │ ├── matrix_uint4x3.hpp
│ │ │ │ │ ├── matrix_uint4x3_sized.hpp
│ │ │ │ │ ├── matrix_uint4x4.hpp
│ │ │ │ │ ├── matrix_uint4x4_sized.hpp
│ │ │ │ │ ├── quaternion_common.hpp
│ │ │ │ │ ├── quaternion_common.inl
│ │ │ │ │ ├── quaternion_common_simd.inl
│ │ │ │ │ ├── quaternion_double.hpp
│ │ │ │ │ ├── quaternion_double_precision.hpp
│ │ │ │ │ ├── quaternion_exponential.hpp
│ │ │ │ │ ├── quaternion_exponential.inl
│ │ │ │ │ ├── quaternion_float.hpp
│ │ │ │ │ ├── quaternion_float_precision.hpp
│ │ │ │ │ ├── quaternion_geometric.hpp
│ │ │ │ │ ├── quaternion_geometric.inl
│ │ │ │ │ ├── quaternion_relational.hpp
│ │ │ │ │ ├── quaternion_relational.inl
│ │ │ │ │ ├── quaternion_transform.hpp
│ │ │ │ │ ├── quaternion_transform.inl
│ │ │ │ │ ├── quaternion_trigonometric.hpp
│ │ │ │ │ ├── quaternion_trigonometric.inl
│ │ │ │ │ ├── scalar_common.hpp
│ │ │ │ │ ├── scalar_common.inl
│ │ │ │ │ ├── scalar_constants.hpp
│ │ │ │ │ ├── scalar_constants.inl
│ │ │ │ │ ├── scalar_int_sized.hpp
│ │ │ │ │ ├── scalar_integer.hpp
│ │ │ │ │ ├── scalar_integer.inl
│ │ │ │ │ ├── scalar_packing.hpp
│ │ │ │ │ ├── scalar_packing.inl
│ │ │ │ │ ├── scalar_reciprocal.hpp
│ │ │ │ │ ├── scalar_reciprocal.inl
│ │ │ │ │ ├── scalar_relational.hpp
│ │ │ │ │ ├── scalar_relational.inl
│ │ │ │ │ ├── scalar_uint_sized.hpp
│ │ │ │ │ ├── scalar_ulp.hpp
│ │ │ │ │ ├── scalar_ulp.inl
│ │ │ │ │ ├── vector_bool1.hpp
│ │ │ │ │ ├── vector_bool1_precision.hpp
│ │ │ │ │ ├── vector_bool2.hpp
│ │ │ │ │ ├── vector_bool2_precision.hpp
│ │ │ │ │ ├── vector_bool3.hpp
│ │ │ │ │ ├── vector_bool3_precision.hpp
│ │ │ │ │ ├── vector_bool4.hpp
│ │ │ │ │ ├── vector_bool4_precision.hpp
│ │ │ │ │ ├── vector_common.hpp
│ │ │ │ │ ├── vector_common.inl
│ │ │ │ │ ├── vector_double1.hpp
│ │ │ │ │ ├── vector_double1_precision.hpp
│ │ │ │ │ ├── vector_double2.hpp
│ │ │ │ │ ├── vector_double2_precision.hpp
│ │ │ │ │ ├── vector_double3.hpp
│ │ │ │ │ ├── vector_double3_precision.hpp
│ │ │ │ │ ├── vector_double4.hpp
│ │ │ │ │ ├── vector_double4_precision.hpp
│ │ │ │ │ ├── vector_float1.hpp
│ │ │ │ │ ├── vector_float1_precision.hpp
│ │ │ │ │ ├── vector_float2.hpp
│ │ │ │ │ ├── vector_float2_precision.hpp
│ │ │ │ │ ├── vector_float3.hpp
│ │ │ │ │ ├── vector_float3_precision.hpp
│ │ │ │ │ ├── vector_float4.hpp
│ │ │ │ │ ├── vector_float4_precision.hpp
│ │ │ │ │ ├── vector_int1.hpp
│ │ │ │ │ ├── vector_int1_sized.hpp
│ │ │ │ │ ├── vector_int2.hpp
│ │ │ │ │ ├── vector_int2_sized.hpp
│ │ │ │ │ ├── vector_int3.hpp
│ │ │ │ │ ├── vector_int3_sized.hpp
│ │ │ │ │ ├── vector_int4.hpp
│ │ │ │ │ ├── vector_int4_sized.hpp
│ │ │ │ │ ├── vector_integer.hpp
│ │ │ │ │ ├── vector_integer.inl
│ │ │ │ │ ├── vector_packing.hpp
│ │ │ │ │ ├── vector_packing.inl
│ │ │ │ │ ├── vector_reciprocal.hpp
│ │ │ │ │ ├── vector_reciprocal.inl
│ │ │ │ │ ├── vector_relational.hpp
│ │ │ │ │ ├── vector_relational.inl
│ │ │ │ │ ├── vector_uint1.hpp
│ │ │ │ │ ├── vector_uint1_sized.hpp
│ │ │ │ │ ├── vector_uint2.hpp
│ │ │ │ │ ├── vector_uint2_sized.hpp
│ │ │ │ │ ├── vector_uint3.hpp
│ │ │ │ │ ├── vector_uint3_sized.hpp
│ │ │ │ │ ├── vector_uint4.hpp
│ │ │ │ │ ├── vector_uint4_sized.hpp
│ │ │ │ │ ├── vector_ulp.hpp
│ │ │ │ │ └── vector_ulp.inl
│ │ │ │ ├── ext.hpp
│ │ │ │ ├── fwd.hpp
│ │ │ │ ├── geometric.hpp
│ │ │ │ ├── glm.hpp
│ │ │ │ ├── gtc/
│ │ │ │ │ ├── bitfield.hpp
│ │ │ │ │ ├── bitfield.inl
│ │ │ │ │ ├── color_space.hpp
│ │ │ │ │ ├── color_space.inl
│ │ │ │ │ ├── constants.hpp
│ │ │ │ │ ├── constants.inl
│ │ │ │ │ ├── epsilon.hpp
│ │ │ │ │ ├── epsilon.inl
│ │ │ │ │ ├── integer.hpp
│ │ │ │ │ ├── integer.inl
│ │ │ │ │ ├── matrix_access.hpp
│ │ │ │ │ ├── matrix_access.inl
│ │ │ │ │ ├── matrix_integer.hpp
│ │ │ │ │ ├── matrix_inverse.hpp
│ │ │ │ │ ├── matrix_inverse.inl
│ │ │ │ │ ├── matrix_transform.hpp
│ │ │ │ │ ├── matrix_transform.inl
│ │ │ │ │ ├── noise.hpp
│ │ │ │ │ ├── noise.inl
│ │ │ │ │ ├── packing.hpp
│ │ │ │ │ ├── packing.inl
│ │ │ │ │ ├── quaternion.hpp
│ │ │ │ │ ├── quaternion.inl
│ │ │ │ │ ├── quaternion_simd.inl
│ │ │ │ │ ├── random.hpp
│ │ │ │ │ ├── random.inl
│ │ │ │ │ ├── reciprocal.hpp
│ │ │ │ │ ├── round.hpp
│ │ │ │ │ ├── round.inl
│ │ │ │ │ ├── type_aligned.hpp
│ │ │ │ │ ├── type_precision.hpp
│ │ │ │ │ ├── type_precision.inl
│ │ │ │ │ ├── type_ptr.hpp
│ │ │ │ │ ├── type_ptr.inl
│ │ │ │ │ ├── ulp.hpp
│ │ │ │ │ ├── ulp.inl
│ │ │ │ │ └── vec1.hpp
│ │ │ │ ├── gtx/
│ │ │ │ │ ├── associated_min_max.hpp
│ │ │ │ │ ├── associated_min_max.inl
│ │ │ │ │ ├── bit.hpp
│ │ │ │ │ ├── bit.inl
│ │ │ │ │ ├── closest_point.hpp
│ │ │ │ │ ├── closest_point.inl
│ │ │ │ │ ├── color_encoding.hpp
│ │ │ │ │ ├── color_encoding.inl
│ │ │ │ │ ├── color_space.hpp
│ │ │ │ │ ├── color_space.inl
│ │ │ │ │ ├── color_space_YCoCg.hpp
│ │ │ │ │ ├── color_space_YCoCg.inl
│ │ │ │ │ ├── common.hpp
│ │ │ │ │ ├── common.inl
│ │ │ │ │ ├── compatibility.hpp
│ │ │ │ │ ├── compatibility.inl
│ │ │ │ │ ├── component_wise.hpp
│ │ │ │ │ ├── component_wise.inl
│ │ │ │ │ ├── dual_quaternion.hpp
│ │ │ │ │ ├── dual_quaternion.inl
│ │ │ │ │ ├── easing.hpp
│ │ │ │ │ ├── easing.inl
│ │ │ │ │ ├── euler_angles.hpp
│ │ │ │ │ ├── euler_angles.inl
│ │ │ │ │ ├── extend.hpp
│ │ │ │ │ ├── extend.inl
│ │ │ │ │ ├── extended_min_max.hpp
│ │ │ │ │ ├── extended_min_max.inl
│ │ │ │ │ ├── exterior_product.hpp
│ │ │ │ │ ├── exterior_product.inl
│ │ │ │ │ ├── fast_exponential.hpp
│ │ │ │ │ ├── fast_exponential.inl
│ │ │ │ │ ├── fast_square_root.hpp
│ │ │ │ │ ├── fast_square_root.inl
│ │ │ │ │ ├── fast_trigonometry.hpp
│ │ │ │ │ ├── fast_trigonometry.inl
│ │ │ │ │ ├── float_notmalize.inl
│ │ │ │ │ ├── functions.hpp
│ │ │ │ │ ├── functions.inl
│ │ │ │ │ ├── gradient_paint.hpp
│ │ │ │ │ ├── gradient_paint.inl
│ │ │ │ │ ├── handed_coordinate_space.hpp
│ │ │ │ │ ├── handed_coordinate_space.inl
│ │ │ │ │ ├── hash.hpp
│ │ │ │ │ ├── hash.inl
│ │ │ │ │ ├── integer.hpp
│ │ │ │ │ ├── integer.inl
│ │ │ │ │ ├── intersect.hpp
│ │ │ │ │ ├── intersect.inl
│ │ │ │ │ ├── io.hpp
│ │ │ │ │ ├── io.inl
│ │ │ │ │ ├── log_base.hpp
│ │ │ │ │ ├── log_base.inl
│ │ │ │ │ ├── matrix_cross_product.hpp
│ │ │ │ │ ├── matrix_cross_product.inl
│ │ │ │ │ ├── matrix_decompose.hpp
│ │ │ │ │ ├── matrix_decompose.inl
│ │ │ │ │ ├── matrix_factorisation.hpp
│ │ │ │ │ ├── matrix_factorisation.inl
│ │ │ │ │ ├── matrix_interpolation.hpp
│ │ │ │ │ ├── matrix_interpolation.inl
│ │ │ │ │ ├── matrix_major_storage.hpp
│ │ │ │ │ ├── matrix_major_storage.inl
│ │ │ │ │ ├── matrix_operation.hpp
│ │ │ │ │ ├── matrix_operation.inl
│ │ │ │ │ ├── matrix_query.hpp
│ │ │ │ │ ├── matrix_query.inl
│ │ │ │ │ ├── matrix_transform_2d.hpp
│ │ │ │ │ ├── matrix_transform_2d.inl
│ │ │ │ │ ├── mixed_product.hpp
│ │ │ │ │ ├── mixed_product.inl
│ │ │ │ │ ├── norm.hpp
│ │ │ │ │ ├── norm.inl
│ │ │ │ │ ├── normal.hpp
│ │ │ │ │ ├── normal.inl
│ │ │ │ │ ├── normalize_dot.hpp
│ │ │ │ │ ├── normalize_dot.inl
│ │ │ │ │ ├── number_precision.hpp
│ │ │ │ │ ├── number_precision.inl
│ │ │ │ │ ├── optimum_pow.hpp
│ │ │ │ │ ├── optimum_pow.inl
│ │ │ │ │ ├── orthonormalize.hpp
│ │ │ │ │ ├── orthonormalize.inl
│ │ │ │ │ ├── pca.hpp
│ │ │ │ │ ├── pca.inl
│ │ │ │ │ ├── perpendicular.hpp
│ │ │ │ │ ├── perpendicular.inl
│ │ │ │ │ ├── polar_coordinates.hpp
│ │ │ │ │ ├── polar_coordinates.inl
│ │ │ │ │ ├── projection.hpp
│ │ │ │ │ ├── projection.inl
│ │ │ │ │ ├── quaternion.hpp
│ │ │ │ │ ├── quaternion.inl
│ │ │ │ │ ├── range.hpp
│ │ │ │ │ ├── raw_data.hpp
│ │ │ │ │ ├── raw_data.inl
│ │ │ │ │ ├── rotate_normalized_axis.hpp
│ │ │ │ │ ├── rotate_normalized_axis.inl
│ │ │ │ │ ├── rotate_vector.hpp
│ │ │ │ │ ├── rotate_vector.inl
│ │ │ │ │ ├── scalar_multiplication.hpp
│ │ │ │ │ ├── scalar_relational.hpp
│ │ │ │ │ ├── scalar_relational.inl
│ │ │ │ │ ├── spline.hpp
│ │ │ │ │ ├── spline.inl
│ │ │ │ │ ├── std_based_type.hpp
│ │ │ │ │ ├── std_based_type.inl
│ │ │ │ │ ├── string_cast.hpp
│ │ │ │ │ ├── string_cast.inl
│ │ │ │ │ ├── texture.hpp
│ │ │ │ │ ├── texture.inl
│ │ │ │ │ ├── transform.hpp
│ │ │ │ │ ├── transform.inl
│ │ │ │ │ ├── transform2.hpp
│ │ │ │ │ ├── transform2.inl
│ │ │ │ │ ├── type_aligned.hpp
│ │ │ │ │ ├── type_aligned.inl
│ │ │ │ │ ├── type_trait.hpp
│ │ │ │ │ ├── type_trait.inl
│ │ │ │ │ ├── vec_swizzle.hpp
│ │ │ │ │ ├── vector_angle.hpp
│ │ │ │ │ ├── vector_angle.inl
│ │ │ │ │ ├── vector_query.hpp
│ │ │ │ │ ├── vector_query.inl
│ │ │ │ │ ├── wrap.hpp
│ │ │ │ │ └── wrap.inl
│ │ │ │ ├── integer.hpp
│ │ │ │ ├── mat2x2.hpp
│ │ │ │ ├── mat2x3.hpp
│ │ │ │ ├── mat2x4.hpp
│ │ │ │ ├── mat3x2.hpp
│ │ │ │ ├── mat3x3.hpp
│ │ │ │ ├── mat3x4.hpp
│ │ │ │ ├── mat4x2.hpp
│ │ │ │ ├── mat4x3.hpp
│ │ │ │ ├── mat4x4.hpp
│ │ │ │ ├── matrix.hpp
│ │ │ │ ├── packing.hpp
│ │ │ │ ├── simd/
│ │ │ │ │ ├── common.h
│ │ │ │ │ ├── exponential.h
│ │ │ │ │ ├── geometric.h
│ │ │ │ │ ├── integer.h
│ │ │ │ │ ├── matrix.h
│ │ │ │ │ ├── neon.h
│ │ │ │ │ ├── packing.h
│ │ │ │ │ ├── platform.h
│ │ │ │ │ ├── trigonometric.h
│ │ │ │ │ └── vector_relational.h
│ │ │ │ ├── trigonometric.hpp
│ │ │ │ ├── vec2.hpp
│ │ │ │ ├── vec3.hpp
│ │ │ │ ├── vec4.hpp
│ │ │ │ └── vector_relational.hpp
│ │ │ ├── manual.md
│ │ │ ├── readme.md
│ │ │ ├── test/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── bug/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ └── bug_ms_vec_static.cpp
│ │ │ │ ├── cmake/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ └── test_find_glm.cpp
│ │ │ │ ├── core/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── core_cpp_constexpr.cpp
│ │ │ │ │ ├── core_cpp_defaulted_ctor.cpp
│ │ │ │ │ ├── core_force_aligned_gentypes.cpp
│ │ │ │ │ ├── core_force_arch_unknown.cpp
│ │ │ │ │ ├── core_force_compiler_unknown.cpp
│ │ │ │ │ ├── core_force_ctor_init.cpp
│ │ │ │ │ ├── core_force_cxx03.cpp
│ │ │ │ │ ├── core_force_cxx98.cpp
│ │ │ │ │ ├── core_force_cxx_unknown.cpp
│ │ │ │ │ ├── core_force_depth_zero_to_one.cpp
│ │ │ │ │ ├── core_force_explicit_ctor.cpp
│ │ │ │ │ ├── core_force_inline.cpp
│ │ │ │ │ ├── core_force_left_handed.cpp
│ │ │ │ │ ├── core_force_platform_unknown.cpp
│ │ │ │ │ ├── core_force_pure.cpp
│ │ │ │ │ ├── core_force_quat_xyzw.cpp
│ │ │ │ │ ├── core_force_size_t_length.cpp
│ │ │ │ │ ├── core_force_unrestricted_gentype.cpp
│ │ │ │ │ ├── core_force_xyzw_only.cpp
│ │ │ │ │ ├── core_func_common.cpp
│ │ │ │ │ ├── core_func_exponential.cpp
│ │ │ │ │ ├── core_func_geometric.cpp
│ │ │ │ │ ├── core_func_integer.cpp
│ │ │ │ │ ├── core_func_integer_bit_count.cpp
│ │ │ │ │ ├── core_func_integer_find_lsb.cpp
│ │ │ │ │ ├── core_func_integer_find_msb.cpp
│ │ │ │ │ ├── core_func_matrix.cpp
│ │ │ │ │ ├── core_func_noise.cpp
│ │ │ │ │ ├── core_func_packing.cpp
│ │ │ │ │ ├── core_func_swizzle.cpp
│ │ │ │ │ ├── core_func_trigonometric.cpp
│ │ │ │ │ ├── core_func_vector_relational.cpp
│ │ │ │ │ ├── core_setup_force_cxx98.cpp
│ │ │ │ │ ├── core_setup_force_size_t_length.cpp
│ │ │ │ │ ├── core_setup_message.cpp
│ │ │ │ │ ├── core_setup_platform_unknown.cpp
│ │ │ │ │ ├── core_setup_precision.cpp
│ │ │ │ │ ├── core_type_aligned.cpp
│ │ │ │ │ ├── core_type_cast.cpp
│ │ │ │ │ ├── core_type_ctor.cpp
│ │ │ │ │ ├── core_type_int.cpp
│ │ │ │ │ ├── core_type_length.cpp
│ │ │ │ │ ├── core_type_mat2x2.cpp
│ │ │ │ │ ├── core_type_mat2x3.cpp
│ │ │ │ │ ├── core_type_mat2x4.cpp
│ │ │ │ │ ├── core_type_mat3x2.cpp
│ │ │ │ │ ├── core_type_mat3x3.cpp
│ │ │ │ │ ├── core_type_mat3x4.cpp
│ │ │ │ │ ├── core_type_mat4x2.cpp
│ │ │ │ │ ├── core_type_mat4x3.cpp
│ │ │ │ │ ├── core_type_mat4x4.cpp
│ │ │ │ │ ├── core_type_vec1.cpp
│ │ │ │ │ ├── core_type_vec2.cpp
│ │ │ │ │ ├── core_type_vec3.cpp
│ │ │ │ │ └── core_type_vec4.cpp
│ │ │ │ ├── ext/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── ext_matrix_clip_space.cpp
│ │ │ │ │ ├── ext_matrix_common.cpp
│ │ │ │ │ ├── ext_matrix_int2x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_int2x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_int2x4_sized.cpp
│ │ │ │ │ ├── ext_matrix_int3x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_int3x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_int3x4_sized.cpp
│ │ │ │ │ ├── ext_matrix_int4x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_int4x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_int4x4_sized.cpp
│ │ │ │ │ ├── ext_matrix_integer.cpp
│ │ │ │ │ ├── ext_matrix_projection.cpp
│ │ │ │ │ ├── ext_matrix_relational.cpp
│ │ │ │ │ ├── ext_matrix_transform.cpp
│ │ │ │ │ ├── ext_matrix_uint2x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint2x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint2x4_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint3x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint3x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint3x4_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint4x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint4x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint4x4_sized.cpp
│ │ │ │ │ ├── ext_quaternion_common.cpp
│ │ │ │ │ ├── ext_quaternion_exponential.cpp
│ │ │ │ │ ├── ext_quaternion_geometric.cpp
│ │ │ │ │ ├── ext_quaternion_relational.cpp
│ │ │ │ │ ├── ext_quaternion_transform.cpp
│ │ │ │ │ ├── ext_quaternion_trigonometric.cpp
│ │ │ │ │ ├── ext_quaternion_type.cpp
│ │ │ │ │ ├── ext_scalar_common.cpp
│ │ │ │ │ ├── ext_scalar_constants.cpp
│ │ │ │ │ ├── ext_scalar_int_sized.cpp
│ │ │ │ │ ├── ext_scalar_integer.cpp
│ │ │ │ │ ├── ext_scalar_packing.cpp
│ │ │ │ │ ├── ext_scalar_reciprocal.cpp
│ │ │ │ │ ├── ext_scalar_relational.cpp
│ │ │ │ │ ├── ext_scalar_uint_sized.cpp
│ │ │ │ │ ├── ext_scalar_ulp.cpp
│ │ │ │ │ ├── ext_vec1.cpp
│ │ │ │ │ ├── ext_vector_bool1.cpp
│ │ │ │ │ ├── ext_vector_common.cpp
│ │ │ │ │ ├── ext_vector_iec559.cpp
│ │ │ │ │ ├── ext_vector_int1_sized.cpp
│ │ │ │ │ ├── ext_vector_int2_sized.cpp
│ │ │ │ │ ├── ext_vector_int3_sized.cpp
│ │ │ │ │ ├── ext_vector_int4_sized.cpp
│ │ │ │ │ ├── ext_vector_integer.cpp
│ │ │ │ │ ├── ext_vector_integer_sized.cpp
│ │ │ │ │ ├── ext_vector_packing.cpp
│ │ │ │ │ ├── ext_vector_reciprocal.cpp
│ │ │ │ │ ├── ext_vector_relational.cpp
│ │ │ │ │ ├── ext_vector_uint1_sized.cpp
│ │ │ │ │ ├── ext_vector_uint2_sized.cpp
│ │ │ │ │ ├── ext_vector_uint3_sized.cpp
│ │ │ │ │ ├── ext_vector_uint4_sized.cpp
│ │ │ │ │ └── ext_vector_ulp.cpp
│ │ │ │ ├── glm.cppcheck
│ │ │ │ ├── gtc/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── gtc_bitfield.cpp
│ │ │ │ │ ├── gtc_color_space.cpp
│ │ │ │ │ ├── gtc_constants.cpp
│ │ │ │ │ ├── gtc_epsilon.cpp
│ │ │ │ │ ├── gtc_integer.cpp
│ │ │ │ │ ├── gtc_matrix_access.cpp
│ │ │ │ │ ├── gtc_matrix_integer.cpp
│ │ │ │ │ ├── gtc_matrix_inverse.cpp
│ │ │ │ │ ├── gtc_matrix_transform.cpp
│ │ │ │ │ ├── gtc_noise.cpp
│ │ │ │ │ ├── gtc_packing.cpp
│ │ │ │ │ ├── gtc_quaternion.cpp
│ │ │ │ │ ├── gtc_random.cpp
│ │ │ │ │ ├── gtc_reciprocal.cpp
│ │ │ │ │ ├── gtc_round.cpp
│ │ │ │ │ ├── gtc_type_aligned.cpp
│ │ │ │ │ ├── gtc_type_precision.cpp
│ │ │ │ │ ├── gtc_type_ptr.cpp
│ │ │ │ │ ├── gtc_ulp.cpp
│ │ │ │ │ ├── gtc_user_defined_types.cpp
│ │ │ │ │ └── gtc_vec1.cpp
│ │ │ │ ├── gtx/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── gtx.cpp
│ │ │ │ │ ├── gtx_associated_min_max.cpp
│ │ │ │ │ ├── gtx_closest_point.cpp
│ │ │ │ │ ├── gtx_color_encoding.cpp
│ │ │ │ │ ├── gtx_color_space.cpp
│ │ │ │ │ ├── gtx_color_space_YCoCg.cpp
│ │ │ │ │ ├── gtx_common.cpp
│ │ │ │ │ ├── gtx_compatibility.cpp
│ │ │ │ │ ├── gtx_component_wise.cpp
│ │ │ │ │ ├── gtx_dual_quaternion.cpp
│ │ │ │ │ ├── gtx_easing.cpp
│ │ │ │ │ ├── gtx_euler_angle.cpp
│ │ │ │ │ ├── gtx_extend.cpp
│ │ │ │ │ ├── gtx_extended_min_max.cpp
│ │ │ │ │ ├── gtx_extented_min_max.cpp
│ │ │ │ │ ├── gtx_exterior_product.cpp
│ │ │ │ │ ├── gtx_fast_exponential.cpp
│ │ │ │ │ ├── gtx_fast_square_root.cpp
│ │ │ │ │ ├── gtx_fast_trigonometry.cpp
│ │ │ │ │ ├── gtx_functions.cpp
│ │ │ │ │ ├── gtx_gradient_paint.cpp
│ │ │ │ │ ├── gtx_handed_coordinate_space.cpp
│ │ │ │ │ ├── gtx_hash.cpp
│ │ │ │ │ ├── gtx_int_10_10_10_2.cpp
│ │ │ │ │ ├── gtx_integer.cpp
│ │ │ │ │ ├── gtx_intersect.cpp
│ │ │ │ │ ├── gtx_io.cpp
│ │ │ │ │ ├── gtx_load.cpp
│ │ │ │ │ ├── gtx_log_base.cpp
│ │ │ │ │ ├── gtx_matrix_cross_product.cpp
│ │ │ │ │ ├── gtx_matrix_decompose.cpp
│ │ │ │ │ ├── gtx_matrix_factorisation.cpp
│ │ │ │ │ ├── gtx_matrix_interpolation.cpp
│ │ │ │ │ ├── gtx_matrix_major_storage.cpp
│ │ │ │ │ ├── gtx_matrix_operation.cpp
│ │ │ │ │ ├── gtx_matrix_query.cpp
│ │ │ │ │ ├── gtx_matrix_transform_2d.cpp
│ │ │ │ │ ├── gtx_mixed_product.cpp
│ │ │ │ │ ├── gtx_norm.cpp
│ │ │ │ │ ├── gtx_normal.cpp
│ │ │ │ │ ├── gtx_normalize_dot.cpp
│ │ │ │ │ ├── gtx_number_precision.cpp
│ │ │ │ │ ├── gtx_optimum_pow.cpp
│ │ │ │ │ ├── gtx_orthonormalize.cpp
│ │ │ │ │ ├── gtx_pca.cpp
│ │ │ │ │ ├── gtx_perpendicular.cpp
│ │ │ │ │ ├── gtx_polar_coordinates.cpp
│ │ │ │ │ ├── gtx_projection.cpp
│ │ │ │ │ ├── gtx_quaternion.cpp
│ │ │ │ │ ├── gtx_random.cpp
│ │ │ │ │ ├── gtx_range.cpp
│ │ │ │ │ ├── gtx_rotate_normalized_axis.cpp
│ │ │ │ │ ├── gtx_rotate_vector.cpp
│ │ │ │ │ ├── gtx_scalar_multiplication.cpp
│ │ │ │ │ ├── gtx_scalar_relational.cpp
│ │ │ │ │ ├── gtx_simd_mat4.cpp
│ │ │ │ │ ├── gtx_simd_vec4.cpp
│ │ │ │ │ ├── gtx_spline.cpp
│ │ │ │ │ ├── gtx_string_cast.cpp
│ │ │ │ │ ├── gtx_texture.cpp
│ │ │ │ │ ├── gtx_type_aligned.cpp
│ │ │ │ │ ├── gtx_type_trait.cpp
│ │ │ │ │ ├── gtx_vec_swizzle.cpp
│ │ │ │ │ ├── gtx_vector_angle.cpp
│ │ │ │ │ ├── gtx_vector_query.cpp
│ │ │ │ │ └── gtx_wrap.cpp
│ │ │ │ └── perf/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── perf_matrix_div.cpp
│ │ │ │ ├── perf_matrix_inverse.cpp
│ │ │ │ ├── perf_matrix_mul.cpp
│ │ │ │ ├── perf_matrix_mul_vector.cpp
│ │ │ │ ├── perf_matrix_transpose.cpp
│ │ │ │ └── perf_vector_mul_matrix.cpp
│ │ │ └── util/
│ │ │ ├── autoexp.txt
│ │ │ └── glm.natvis
│ │ └── stbi_image_write.h
│ ├── simple-knn/
│ │ ├── dist/
│ │ │ └── simple_knn-0.0.0-py3.7-linux-x86_64.egg
│ │ ├── ext.cpp
│ │ ├── setup.py
│ │ ├── simple_knn/
│ │ │ └── .gitkeep
│ │ ├── simple_knn.cu
│ │ ├── simple_knn.egg-info/
│ │ │ ├── PKG-INFO
│ │ │ ├── SOURCES.txt
│ │ │ ├── dependency_links.txt
│ │ │ └── top_level.txt
│ │ ├── simple_knn.h
│ │ ├── spatial.cu
│ │ └── spatial.h
│ └── simple-waymo-open-dataset-reader/
│ ├── LICENSE
│ ├── README.md
│ ├── examples/
│ │ ├── count_frames.py
│ │ ├── extract_merged_pointclouds.py
│ │ ├── groundtruth_extraction.py
│ │ ├── requirements.txt
│ │ ├── visualise_labels.py
│ │ ├── visualise_labels_and_lidar.py
│ │ └── visualise_pcl.py
│ ├── generate_proto.sh
│ ├── setup.py
│ ├── simple_waymo_open_dataset_reader/
│ │ ├── __init__.py
│ │ ├── dataset.proto
│ │ ├── dataset_pb2.py
│ │ ├── label.proto
│ │ ├── label_pb2.py
│ │ └── utils.py
│ └── simple_waymo_open_dataset_reader.egg-info/
│ ├── PKG-INFO
│ ├── SOURCES.txt
│ ├── dependency_links.txt
│ ├── requires.txt
│ └── top_level.txt
├── test_render_window.py
├── test_render_window_cv2.py
├── train.py
├── utils/
│ ├── __init__.py
│ ├── activations.py
│ ├── augmentations.py
│ ├── autoanchor.py
│ ├── autobatch.py
│ ├── aws/
│ │ ├── __init__.py
│ │ ├── mime.sh
│ │ ├── resume.py
│ │ └── userdata.sh
│ ├── callbacks.py
│ ├── dataloaders.py
│ ├── docker/
│ │ ├── Dockerfile
│ │ ├── Dockerfile-arm64
│ │ └── Dockerfile-cpu
│ ├── downloads.py
│ ├── flask_rest_api/
│ │ ├── README.md
│ │ ├── example_request.py
│ │ └── restapi.py
│ ├── general.py
│ ├── google_app_engine/
│ │ ├── Dockerfile
│ │ ├── additional_requirements.txt
│ │ └── app.yaml
│ ├── loggers/
│ │ ├── __init__.py
│ │ ├── clearml/
│ │ │ ├── README.md
│ │ │ ├── __init__.py
│ │ │ ├── clearml_utils.py
│ │ │ └── hpo.py
│ │ ├── comet/
│ │ │ ├── README.md
│ │ │ ├── __init__.py
│ │ │ ├── comet_utils.py
│ │ │ ├── hpo.py
│ │ │ └── optimizer_config.json
│ │ └── wandb/
│ │ ├── __init__.py
│ │ └── wandb_utils.py
│ ├── loss.py
│ ├── metrics.py
│ ├── plots.py
│ ├── segment/
│ │ ├── __init__.py
│ │ ├── augmentations.py
│ │ ├── dataloaders.py
│ │ ├── general.py
│ │ ├── loss.py
│ │ ├── metrics.py
│ │ └── plots.py
│ ├── torch_utils.py
│ └── triton.py
└── weights/
├── __init__.py
└── yolov5s.pt
Showing preview only (363K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (3840 symbols across 594 files)
FILE: lib/config/yacs.py
class CfgNode (line 63) | class CfgNode(dict):
method __init__ (line 74) | def __init__(self, init_dict=None, key_list=None, new_allowed=True):
method _create_config_tree_from_dict (line 112) | def _create_config_tree_from_dict(cls, dic, key_list):
method __getattr__ (line 137) | def __getattr__(self, name):
method __setattr__ (line 143) | def __setattr__(self, name, value):
method __str__ (line 164) | def __str__(self):
method __repr__ (line 185) | def __repr__(self):
method dump (line 188) | def dump(self, **kwargs):
method merge_from_file (line 209) | def merge_from_file(self, cfg_filename):
method merge_from_other_cfg (line 215) | def merge_from_other_cfg(self, cfg_other):
method merge_from_list (line 219) | def merge_from_list(self, cfg_list):
method freeze (line 250) | def freeze(self):
method defrost (line 254) | def defrost(self):
method is_frozen (line 258) | def is_frozen(self):
method _immutable (line 262) | def _immutable(self, is_immutable):
method clone (line 275) | def clone(self):
method register_deprecated_key (line 279) | def register_deprecated_key(self, key):
method register_renamed_key (line 289) | def register_renamed_key(self, old_name, new_name, message=None):
method key_is_deprecated (line 303) | def key_is_deprecated(self, full_key):
method key_is_renamed (line 310) | def key_is_renamed(self, full_key):
method raise_key_rename_error (line 314) | def raise_key_rename_error(self, full_key):
method is_new_allowed (line 327) | def is_new_allowed(self):
method set_new_allowed (line 330) | def set_new_allowed(self, is_new_allowed):
method load_cfg (line 345) | def load_cfg(cls, cfg_file_obj_or_str):
method _load_cfg_from_file (line 370) | def _load_cfg_from_file(cls, file_obj):
method _load_cfg_from_yaml_str (line 384) | def _load_cfg_from_yaml_str(cls, str_obj):
method _load_cfg_py_source (line 390) | def _load_cfg_py_source(cls, filename):
method _decode_cfg_value (line 407) | def _decode_cfg_value(cls, value):
function _valid_type (line 450) | def _valid_type(value, allow_cfg_node=False):
function _merge_a_into_b (line 456) | def _merge_a_into_b(a, b, root, key_list):
function _check_and_coerce_cfg_value_type (line 496) | def _check_and_coerce_cfg_value_type(replacement, original, key, full_key):
function _assert_with_logging (line 544) | def _assert_with_logging(cond, msg):
function _load_module_from_file (line 550) | def _load_module_from_file(name, filename):
FILE: lib/datasets/base_readers.py
class CameraInfo (line 6) | class CameraInfo(NamedTuple):
class SceneInfo (line 22) | class SceneInfo(NamedTuple):
function getNerfppNorm (line 31) | def getNerfppNorm(cam_info):
function get_PCA_Norm (line 58) | def get_PCA_Norm(xyz):
function get_Sphere_Norm (line 73) | def get_Sphere_Norm(xyz):
function fetchPly (line 88) | def fetchPly(path):
function storePly (line 96) | def storePly(path, xyz, rgb):
FILE: lib/datasets/blender_readers.py
function readCamerasFromTransforms (line 12) | def readCamerasFromTransforms(path, transformsfile, white_background, ex...
function readNerfSyntheticInfo (line 49) | def readNerfSyntheticInfo(path, eval, extension=".png", **kwargs):
FILE: lib/datasets/colmap_readers.py
function readColmapCameras (line 11) | def readColmapCameras(cam_extrinsics, cam_intrinsics, images_folder):
function readColmapSceneInfo (line 57) | def readColmapSceneInfo(path, images='images', split_test=8, **kwargs):
FILE: lib/datasets/dataset.py
class Dataset (line 17) | class Dataset():
method __init__ (line 18) | def __init__(self):
FILE: lib/datasets/waymo_full_readers.py
function readWaymoFullInfo (line 16) | def readWaymoFullInfo(path, images='images', split_train=-1, split_test=...
FILE: lib/models/actor_pose.py
class ActorPose (line 8) | class ActorPose(nn.Module):
method __init__ (line 9) | def __init__(self, tracklets, tracklet_timestamps, camera_timestamps, ...
method save_state_dict (line 32) | def save_state_dict(self, is_final):
method load_state_dict (line 40) | def load_state_dict(self, state_dict):
method training_setup (line 46) | def training_setup(self):
method update_learning_rate (line 68) | def update_learning_rate(self, iteration):
method update_optimizer (line 78) | def update_optimizer(self):
method find_closest_indices (line 83) | def find_closest_indices(self, track_id, timestamp):
method find_closest_camera_timestamps (line 93) | def find_closest_camera_timestamps(self, track_id, camera: Camera):
method get_tracking_translation_ (line 107) | def get_tracking_translation_(self, track_id, timestamp):
method get_tracking_translation (line 124) | def get_tracking_translation(self, track_id, camera: Camera):
method get_tracking_rotation_ (line 138) | def get_tracking_rotation_(self, track_id, timestamp):
method get_tracking_rotation (line 166) | def get_tracking_rotation(self, track_id, camera: Camera):
FILE: lib/models/camera_pose.py
class PoseCorrection (line 7) | class PoseCorrection(nn.Module):
method __init__ (line 8) | def __init__(self, metadata):
method save_state_dict (line 27) | def save_state_dict(self, is_final):
method load_state_dict (line 35) | def load_state_dict(self, state_dict):
method training_setup (line 40) | def training_setup(self):
method update_learning_rate (line 60) | def update_learning_rate(self, iteration):
method update_optimizer (line 65) | def update_optimizer(self):
method get_id (line 69) | def get_id(self, camera: Camera):
method forward (line 77) | def forward(self, camera: Camera):
method correct_gaussian_xyz (line 89) | def correct_gaussian_xyz(self, camera: Camera, xyz: torch.Tensor):
method correct_gaussian_rotation (line 106) | def correct_gaussian_rotation(self, camera: Camera, rotation: torch.Te...
method regularization_loss (line 116) | def regularization_loss(self):
FILE: lib/models/color_correction.py
class ColorCorrection (line 7) | class ColorCorrection(nn.Module):
method __init__ (line 8) | def __init__(self, metadata):
method save_state_dict (line 57) | def save_state_dict(self, is_final):
method load_state_dict (line 64) | def load_state_dict(self, state_dict):
method training_setup (line 69) | def training_setup(self):
method update_learning_rate (line 92) | def update_learning_rate(self, iteration):
method update_optimizer (line 97) | def update_optimizer(self):
method get_id (line 101) | def get_id(self, camera: Camera):
method get_affine_trans (line 109) | def get_affine_trans(self, camera: Camera, use_sky=False):
method forward (line 129) | def forward(self, camera: Camera, image: torch.Tensor, use_sky=False):
method regularization_loss (line 134) | def regularization_loss(self, camera: Camera):
FILE: lib/models/gaussian_model.py
class GaussianModel (line 17) | class GaussianModel(nn.Module):
method __init__ (line 18) | def __init__(self, model_name='background', num_classes=1):
method create_from_pcd (line 54) | def create_from_pcd(self, pcd : BasicPointCloud, spatial_lr_scale : fl...
method make_ply (line 80) | def make_ply(self):
method save_ply (line 98) | def save_ply(self, path):
method load_ply (line 104) | def load_ply(self, path=None, input_ply=None):
method load_state_dict (line 157) | def load_state_dict(self, state_dict):
method state_dict (line 182) | def state_dict(self, is_final=False):
method setup_functions (line 207) | def setup_functions(self):
method get_scaling (line 225) | def get_scaling(self):
method get_rotation (line 229) | def get_rotation(self):
method get_xyz (line 233) | def get_xyz(self):
method get_features (line 237) | def get_features(self):
method get_semantic (line 243) | def get_semantic(self):
method get_opacity (line 250) | def get_opacity(self):
method get_covariance (line 253) | def get_covariance(self, scaling_modifier = 1):
method get_normals (line 256) | def get_normals(self, camera: Camera):
method scale_flatten_loss (line 271) | def scale_flatten_loss(self):
method oneupSHdegree (line 282) | def oneupSHdegree(self):
method training_setup (line 286) | def training_setup(self):
method update_optimizer (line 316) | def update_optimizer(self):
method update_learning_rate (line 320) | def update_learning_rate(self, iteration):
method construct_list_of_attributes (line 327) | def construct_list_of_attributes(self):
method reset_optimizer (line 344) | def reset_optimizer(self, tensors_dict):
method prune_optimizer (line 363) | def prune_optimizer(self, mask, prune_list = None):
method cat_optimizer (line 384) | def cat_optimizer(self, tensors_dict):
method reset_opacity (line 410) | def reset_opacity(self):
method prune_points (line 416) | def prune_points(self, mask):
method densification_postfix (line 434) | def densification_postfix(self, tensors_dict):
method densify_and_split (line 453) | def densify_and_split(self, grads, grad_threshold, scene_extent, N=2):
method densify_and_clone (line 494) | def densify_and_clone(self, grads, grad_threshold, scene_extent):
method densify_and_prune (line 522) | def densify_and_prune(self, max_grad, min_opacity, extent, max_screen_...
method add_densification_stats (line 555) | def add_densification_stats(self, viewspace_point_tensor, update_filter):
method add_densification_stats_grad (line 559) | def add_densification_stats_grad(self, viewspace_point_tensor_grad, up...
method parse_camera (line 563) | def parse_camera(self, camera: Camera):
FILE: lib/models/gaussian_model_actor.py
class GaussianModelActor (line 13) | class GaussianModelActor(GaussianModel):
method __init__ (line 14) | def __init__(
method get_extent (line 53) | def get_extent(self):
method get_semantic (line 64) | def get_semantic(self):
method get_features_fourier (line 73) | def get_features_fourier(self, frame=0):
method create_from_pcd (line 84) | def create_from_pcd(self, spatial_lr_scale):
method training_setup (line 165) | def training_setup(self):
method densify_and_prune (line 206) | def densify_and_prune(self, max_grad, min_opacity, prune_big_points):
method set_max_radii (line 265) | def set_max_radii(self, visibility_obj, max_radii2D):
method box_reg_loss (line 268) | def box_reg_loss(self):
FILE: lib/models/gaussian_model_bkgd.py
class GaussianModelBkgd (line 11) | class GaussianModelBkgd(GaussianModel):
method __init__ (line 12) | def __init__(
method create_from_pcd (line 29) | def create_from_pcd(self, pcd: BasicPointCloud, spatial_lr_scale: float):
method set_background_mask (line 41) | def set_background_mask(self, camera: Camera):
method get_scaling (line 45) | def get_scaling(self):
method get_rotation (line 50) | def get_rotation(self):
method get_xyz (line 55) | def get_xyz(self):
method get_features (line 60) | def get_features(self):
method get_opacity (line 65) | def get_opacity(self):
method get_semantic (line 70) | def get_semantic(self):
method densify_and_prune (line 74) | def densify_and_prune(self, max_grad, min_opacity, prune_big_points):
FILE: lib/models/gaussian_model_sky.py
class GaussinaModelSky (line 10) | class GaussinaModelSky(GaussianModel):
method __init__ (line 11) | def __init__(
method create_from_pcd (line 22) | def create_from_pcd(self, pcd: BasicPointCloud, spatial_lr_scale: float):
method get_extent (line 36) | def get_extent(self):
method get_scaling (line 51) | def get_scaling(self):
method get_xyz (line 57) | def get_xyz(self):
method densify_and_prune (line 64) | def densify_and_prune(self, max_grad, min_opacity, prune_big_points):
FILE: lib/models/gaussian_renderer.py
class GaussianRenderer (line 12) | class GaussianRenderer():
method __init__ (line 13) | def __init__(
method render (line 18) | def render(
FILE: lib/models/network_gui.py
function init (line 26) | def init(wish_host, wish_port):
function try_connect (line 34) | def try_connect():
function read (line 43) | def read():
function send (line 50) | def send(message_bytes, verify):
function receive (line 57) | def receive():
FILE: lib/models/scene.py
class Scene (line 10) | class Scene:
method __init__ (line 15) | def __init__(self, gaussians: Union[GaussianModel, StreetGaussianModel...
method save (line 51) | def save(self, iteration):
method getTrainCameras (line 55) | def getTrainCameras(self, scale=1):
method getTestCameras (line 58) | def getTestCameras(self, scale=1):
method getNovelViewCameras (line 61) | def getNovelViewCameras(self, scale=1):
FILE: lib/models/sky_cubemap.py
class SkyCubeMap (line 14) | class SkyCubeMap(nn.Module):
method __init__ (line 15) | def __init__(self):
method save_state_dict (line 36) | def save_state_dict(self, is_final):
method load_state_dict (line 48) | def load_state_dict(self, state_dict):
method training_setup (line 53) | def training_setup(self):
method update_learning_rate (line 67) | def update_learning_rate(self, iteration):
method update_optimizer (line 73) | def update_optimizer(self):
method forward (line 77) | def forward(self, camera: Camera, acc=None):
function dot (line 128) | def dot(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
function reflect (line 131) | def reflect(x: torch.Tensor, n: torch.Tensor) -> torch.Tensor:
function length (line 134) | def length(x: torch.Tensor, eps: float =1e-20) -> torch.Tensor:
function safe_normalize (line 137) | def safe_normalize(x: torch.Tensor, eps: float =1e-20) -> torch.Tensor:
function to_hvec (line 140) | def to_hvec(x: torch.Tensor, w: float) -> torch.Tensor:
function length (line 147) | def length(x: torch.Tensor, eps: float =1e-20) -> torch.Tensor:
function safe_normalize (line 150) | def safe_normalize(x: torch.Tensor, eps: float =1e-20) -> torch.Tensor:
function cube_to_dir (line 153) | def cube_to_dir(s, x, y):
function latlong_to_cubemap (line 162) | def latlong_to_cubemap(latlong_map, res):
function cubemap_to_latlong (line 177) | def cubemap_to_latlong(cubemap, res):
class SkyCubeMap_codebook (line 193) | class SkyCubeMap_codebook(nn.Module):
method __init__ (line 194) | def __init__(self):
method save_state_dict (line 226) | def save_state_dict(self, is_final):
method load_state_dict (line 242) | def load_state_dict(self, state_dict):
method training_setup (line 247) | def training_setup(self):
method update_learning_rate (line 276) | def update_learning_rate(self, iteration):
method update_optimizer (line 285) | def update_optimizer(self):
method forward_train (line 289) | def forward_train(self, camera: Camera, acc):
method forward_inference (line 337) | def forward_inference(self, camera: Camera, acc):
method forward (line 368) | def forward(self, camera: Camera, acc):
FILE: lib/models/street_gaussian_model.py
class StreetGaussianModel (line 29) | class StreetGaussianModel(nn.Module):
method __init__ (line 30) | def __init__(self, metadata):
method set_visibility (line 64) | def set_visibility(self, include_list):
method get_visibility (line 67) | def get_visibility(self, model_name):
method create_from_pcd (line 86) | def create_from_pcd(self, pcd: BasicPointCloud, spatial_lr_scale: float):
method save_ply (line 94) | def save_ply(self, path):
method load_ply (line 107) | def load_ply(self, path):
method load_state_dict (line 119) | def load_state_dict(self, state_dict, exclude_list=[]):
method save_state_dict (line 138) | def save_state_dict(self, is_final, exclude_list=[]):
method setup_functions (line 161) | def setup_functions(self):
method parse_camera (line 219) | def parse_camera(self, camera: Camera):
method get_scaling (line 296) | def get_scaling(self):
method get_rotation (line 314) | def get_rotation(self):
method get_xyz (line 341) | def get_xyz(self):
method get_features (line 370) | def get_features(self):
method get_colors (line 386) | def get_colors(self, camera_center):
method get_semantic (line 421) | def get_semantic(self):
method get_opacity (line 438) | def get_opacity(self):
method get_covariance (line 455) | def get_covariance(self, scaling_modifier = 1):
method get_normals (line 463) | def get_normals(self, camera: Camera):
method oneupSHdegree (line 486) | def oneupSHdegree(self, exclude_list=[]):
method training_setup (line 496) | def training_setup(self, exclude_list=[]):
method update_learning_rate (line 517) | def update_learning_rate(self, iteration, exclude_list=[]):
method update_optimizer (line 536) | def update_optimizer(self, exclude_list=[]):
method set_max_radii2D (line 555) | def set_max_radii2D(self, radii, visibility_filter):
method add_densification_stats (line 567) | def add_densification_stats(self, viewspace_point_tensor, visibility_f...
method densify_and_prune (line 580) | def densify_and_prune(self, max_grad, min_opacity, prune_big_points, e...
method get_box_reg_loss (line 595) | def get_box_reg_loss(self):
method reset_opacity (line 604) | def reset_opacity(self, exclude_list=[]):
FILE: lib/models/street_gaussian_renderer.py
class StreetGaussianRenderer (line 7) | class StreetGaussianRenderer():
method __init__ (line 8) | def __init__(
method render_all (line 13) | def render_all(
method render_object (line 42) | def render_object(
method render_background (line 58) | def render_background(
method render_sky (line 73) | def render_sky(
method render (line 87) | def render(
method render_kernel (line 120) | def render_kernel(
class StreetGaussianRendererLite (line 276) | class StreetGaussianRendererLite():
method __init__ (line 277) | def __init__(
method render_all (line 282) | def render_all(
method render_sky (line 302) | def render_sky(
method render (line 317) | def render(
method render_kernel (line 350) | def render_kernel(
FILE: lib/utils/box_utils.py
function get_bound_2d_mask (line 4) | def get_bound_2d_mask(corners_3d, K, pose, H, W):
function scale_to_corrner (line 20) | def scale_to_corrner(scale):
function bbox_to_corner3d (line 35) | def bbox_to_corner3d(bbox):
function points_to_bbox (line 51) | def points_to_bbox(points):
function inbbox_points (line 57) | def inbbox_points(points, corner3d):
FILE: lib/utils/camera_utils.py
class Camera (line 18) | class Camera(nn.Module):
method __init__ (line 19) | def __init__(
method set_extrinsic (line 69) | def set_extrinsic(self, c2w):
method set_intrinsic (line 83) | def set_intrinsic(self, K):
method get_extrinsic (line 88) | def get_extrinsic(self):
method get_intrinsic (line 95) | def get_intrinsic(self):
class MiniCam (line 100) | class MiniCam:
method __init__ (line 101) | def __init__(self, width, height, fovy, fovx, znear, zfar, world_view_...
function loadmask (line 113) | def loadmask(cam_info: CameraInfo, resolution, resize_mode):
function loadmetadata (line 143) | def loadmetadata(metadata, resolution):
function loadCam (line 167) | def loadCam(cam_info: CameraInfo, resolution_scale):
function cameraList_from_camInfos (line 209) | def cameraList_from_camInfos(cam_infos, resolution_scale):
function camera_to_JSON (line 217) | def camera_to_JSON(id, camera: CameraInfo):
function make_rasterizer (line 239) | def make_rasterizer(
FILE: lib/utils/cfg_utils.py
function parse_cfg (line 5) | def parse_cfg(cfg, args):
function make_cfg (line 79) | def make_cfg(cfg, args):
function save_cfg (line 101) | def save_cfg(cfg, model_dir, epoch=0):
FILE: lib/utils/colmap_utils.py
function qvec2rotmat (line 34) | def qvec2rotmat(qvec):
function rotmat2qvec (line 46) | def rotmat2qvec(R):
class Image (line 59) | class Image(BaseImage):
method qvec2rotmat (line 60) | def qvec2rotmat(self):
function read_next_bytes (line 63) | def read_next_bytes(fid, num_bytes, format_char_sequence, endian_charact...
function read_points3D_text (line 74) | def read_points3D_text(path):
function read_points3D_binary (line 104) | def read_points3D_binary(path_to_model_file):
function read_intrinsics_text (line 135) | def read_intrinsics_text(path):
function read_extrinsics_binary (line 159) | def read_extrinsics_binary(path_to_model_file):
function read_intrinsics_binary (line 194) | def read_intrinsics_binary(path_to_model_file):
function read_extrinsics_text (line 223) | def read_extrinsics_text(path):
function read_colmap_bin_array (line 252) | def read_colmap_bin_array(path):
function parse_colmap_camera_params (line 277) | def parse_colmap_camera_params(camera):
function load_colmap_camera (line 470) | def load_colmap_camera(colmap_dir, sort_colmap=False, height=None, width...
function image_ids_to_pair_id (line 634) | def image_ids_to_pair_id(image_id1, image_id2):
function pair_id_to_image_ids (line 640) | def pair_id_to_image_ids(pair_id):
function array_to_blob (line 646) | def array_to_blob(array):
function blob_to_array (line 653) | def blob_to_array(blob, dtype, shape=(-1,)):
class COLMAPDatabase (line 660) | class COLMAPDatabase(sqlite3.Connection):
method connect (line 663) | def connect(database_path):
method __init__ (line 667) | def __init__(self, *args, **kwargs):
method add_camera (line 689) | def add_camera(self, model, width, height, params,
method add_image (line 698) | def add_image(self, name, camera_id,
method add_keypoints (line 706) | def add_keypoints(self, image_id, keypoints):
method add_descriptors (line 715) | def add_descriptors(self, image_id, descriptors, dtype):
method add_global_VLAD (line 721) | def add_global_VLAD(self, image_id, descriptors, dtype):
method add_local_VLAD (line 729) | def add_local_VLAD(self, image_id, descriptors, dtype):
method add_matches (line 737) | def add_matches(self, image_id1, image_id2, matches):
method add_two_view_geometry (line 750) | def add_two_view_geometry(self, image_id1, image_id2, matches,
FILE: lib/utils/data_utils.py
function to_cuda (line 10) | def to_cuda(batch):
function get_split_data (line 27) | def get_split_data(split_train, split_test, data):
function get_val_frames (line 36) | def get_val_frames(num_frames: int, test_every: int, train_every: int):
FILE: lib/utils/general_utils.py
function inverse_sigmoid (line 28) | def inverse_sigmoid(x):
function PILtoTorch (line 31) | def PILtoTorch(pil_image, resolution=None, resize_mode=Image.BILINEAR):
function NumpytoTorch (line 41) | def NumpytoTorch(image, resolution, resize_mode=cv2.INTER_AREA):
function get_expon_lr_func (line 53) | def get_expon_lr_func(
function strip_lowerdiag (line 88) | def strip_lowerdiag(L):
function strip_symmetric (line 99) | def strip_symmetric(sym):
function quaternion_to_matrix_numpy (line 103) | def quaternion_to_matrix_numpy(r):
function quaternion_to_matrix (line 125) | def quaternion_to_matrix(r):
function _sqrt_positive_part (line 148) | def _sqrt_positive_part(x: torch.Tensor) -> torch.Tensor:
function matrix_to_quaternion (line 159) | def matrix_to_quaternion(matrix: torch.Tensor) -> torch.Tensor:
function quaternion_raw_multiply (line 220) | def quaternion_raw_multiply(a: torch.Tensor, b: torch.Tensor) -> torch.T...
function quaternion_invert (line 240) | def quaternion_invert(quaternion: torch.Tensor) -> torch.Tensor:
function quaternion_slerp (line 256) | def quaternion_slerp(q0: torch.Tensor, q1: torch.Tensor, step=0.5) -> to...
function build_scaling_rotation (line 278) | def build_scaling_rotation(s, r):
function safe_state (line 289) | def safe_state(silent):
function startswith_any (line 312) | def startswith_any(k, l):
function exp_map_SO3xR3 (line 319) | def exp_map_SO3xR3(tangent_vector):
function matrix_to_axis_angle (line 356) | def matrix_to_axis_angle(matrix):
function quaternion_to_axis_angle (line 364) | def quaternion_to_axis_angle(quaternions: torch.Tensor) -> torch.Tensor:
FILE: lib/utils/graphics_utils.py
class BasicPointCloud (line 17) | class BasicPointCloud(NamedTuple):
function geom_transform_points (line 22) | def geom_transform_points(points, transf_matrix):
function getWorld2View (line 31) | def getWorld2View(R, t):
function getWorld2View2 (line 38) | def getWorld2View2(R, t, translate=np.array([.0, .0, .0]), scale=1.0):
function getProjectionMatrix (line 51) | def getProjectionMatrix(znear, zfar, fovX, fovY):
function getProjectionMatrixK (line 72) | def getProjectionMatrixK(K, H, W, znear, zfar):
function fov2focal (line 96) | def fov2focal(fov, pixels):
function focal2fov (line 99) | def focal2fov(focal, pixels):
function project_numpy (line 102) | def project_numpy(xyz, K, RT, H, W):
function project_torch (line 125) | def project_torch(xyz, K, RT, H, W):
function sphere_intersection (line 148) | def sphere_intersection(rays_o, rays_d, center, radius):
function get_rays (line 163) | def get_rays(H, W, K, R, T, perturb=False):
function get_rays_torch (line 186) | def get_rays_torch(H, W, K, R, T, perturb=False):
FILE: lib/utils/img_utils.py
function save_img_torch (line 10) | def save_img_torch(x, name='out.png'):
function save_img_numpy (line 20) | def save_img_numpy(x, name='out.png'):
function unnormalize_img (line 30) | def unnormalize_img(img, mean, std):
function bgr_to_rgb (line 43) | def bgr_to_rgb(img):
function rgb_to_bgr (line 51) | def rgb_to_bgr(img):
function horizon_concate (line 61) | def horizon_concate(inp0, inp1):
function recover_shape (line 75) | def recover_shape(pixel_value, H, W, mask_at_box=None):
function vertical_concate (line 112) | def vertical_concate(inp0, inp1):
function save_image (line 126) | def save_image(pred, gt, save_dir, save_name, concat=False):
function transparent_cmap (line 137) | def transparent_cmap(cmap):
function set_grid (line 147) | def set_grid(ax, h, w, interval=8):
function visualize_depth_numpy (line 242) | def visualize_depth_numpy(depth, minmax=None, cmap=cv2.COLORMAP_JET):
function normalize_img (line 257) | def normalize_img(img):
function linear_to_srgb (line 263) | def linear_to_srgb(linear, eps=None):
function srgb_to_linear (line 273) | def srgb_to_linear(srgb, eps=None):
function draw_3d_box_on_img (line 281) | def draw_3d_box_on_img(vertices, img, color=(255, 128, 128), thickness=1):
FILE: lib/utils/loss_utils.py
function l1_loss (line 21) | def l1_loss(network_output, gt, mask=None):
function l2_loss (line 39) | def l2_loss(network_output, gt, mask=None):
function mse (line 58) | def mse(img1, img2):
function psnr (line 61) | def psnr(img1, img2, mask=None):
function gaussian (line 81) | def gaussian(window_size, sigma):
function create_window (line 85) | def create_window(window_size, channel):
function ssim (line 91) | def ssim(img1, img2, window_size=11, size_average=True, mask=None):
function _ssim (line 106) | def _ssim(img1, img2, window, window_size, channel, size_average=True):
FILE: lib/utils/lpipsPyTorch/__init__.py
function lpips (line 6) | def lpips(x: torch.Tensor,
FILE: lib/utils/lpipsPyTorch/modules/lpips.py
class LPIPS (line 8) | class LPIPS(nn.Module):
method __init__ (line 17) | def __init__(self, net_type: str = 'alex', version: str = '0.1'):
method forward (line 30) | def forward(self, x: torch.Tensor, y: torch.Tensor):
FILE: lib/utils/lpipsPyTorch/modules/networks.py
function get_network (line 12) | def get_network(net_type: str):
class LinLayers (line 23) | class LinLayers(nn.ModuleList):
method __init__ (line 24) | def __init__(self, n_channels_list: Sequence[int]):
class BaseNet (line 36) | class BaseNet(nn.Module):
method __init__ (line 37) | def __init__(self):
method set_requires_grad (line 46) | def set_requires_grad(self, state: bool):
method z_score (line 50) | def z_score(self, x: torch.Tensor):
method forward (line 53) | def forward(self, x: torch.Tensor):
class SqueezeNet (line 66) | class SqueezeNet(BaseNet):
method __init__ (line 67) | def __init__(self):
class AlexNet (line 77) | class AlexNet(BaseNet):
method __init__ (line 78) | def __init__(self):
class VGG16 (line 88) | class VGG16(BaseNet):
method __init__ (line 89) | def __init__(self):
FILE: lib/utils/lpipsPyTorch/modules/utils.py
function normalize_activation (line 6) | def normalize_activation(x, eps=1e-10):
function get_state_dict (line 11) | def get_state_dict(net_type: str = 'alex', version: str = '0.1'):
FILE: lib/utils/sem_utils.py
function get_labe2color (line 11) | def get_labe2color():
function vis_semantic_label (line 16) | def vis_semantic_label(semantics):
function vis_semantic_gt (line 29) | def vis_semantic_gt(semantic_gt):
function get_semantic_label (line 43) | def get_semantic_label(semantic_path):
FILE: lib/utils/sh_utils.py
function eval_sh (line 57) | def eval_sh(deg, sh, dirs):
function RGB2SH (line 114) | def RGB2SH(rgb):
function SH2RGB (line 117) | def SH2RGB(sh):
function IDFT (line 120) | def IDFT(time, dim):
FILE: lib/utils/system_utils.py
function mkdir_p (line 16) | def mkdir_p(folder_path):
function searchForMaxIteration (line 26) | def searchForMaxIteration(folder):
FILE: lib/utils/vq_utils.py
class VectorQuantization (line 4) | class VectorQuantization(Function):
method forward (line 6) | def forward(ctx, inputs, codebook):
method backward (line 25) | def backward(ctx, grad_output):
class VectorQuantizationStraightThrough (line 31) | class VectorQuantizationStraightThrough(Function):
method forward (line 33) | def forward(ctx, inputs, codebook):
method backward (line 46) | def backward(ctx, grad_output, grad_indices):
FILE: lib/utils/waymo_utils.py
function load_camera_info (line 41) | def load_camera_info(datadir):
function make_obj_pose (line 84) | def make_obj_pose(ego_pose, box_info):
function get_obj_pose_tracking (line 112) | def get_obj_pose_tracking(datadir, selected_frames, ego_poses, cameras=[...
function padding_tracklets (line 274) | def padding_tracklets(tracklets, frame_timestamps, min_timestamp, max_ti...
function generate_dataparser_outputs (line 291) | def generate_dataparser_outputs(
FILE: lib/visualizers/base_visualizer.py
class BaseVisualizer (line 13) | class BaseVisualizer():
method __init__ (line 14) | def __init__(self, save_dir):
method visualize (line 28) | def visualize(self, result, camera: Camera):
method visualize_diff (line 43) | def visualize_diff(self, result, camera: Camera):
method visualize_depth (line 66) | def visualize_depth(self, result, camera: Camera):
method save_video_from_frames (line 78) | def save_video_from_frames(self, frames, name, visualize_func=None):
method summarize (line 124) | def summarize(self):
FILE: lib/visualizers/street_gaussian_visualizer.py
class StreetGaussianVisualizer (line 12) | class StreetGaussianVisualizer():
method __init__ (line 13) | def __init__(self, save_dir):
method visualize (line 35) | def visualize(self, result, camera: Camera):
method visualize_novel_view (line 69) | def visualize_novel_view(self, result, camera: Camera):
method visualize_diff (line 86) | def visualize_diff(self, result, camera: Camera):
method visualize_depth (line 109) | def visualize_depth(self, result, camera: Camera):
method visualize_normal (line 121) | def visualize_normal(self, result, camera: Camera):
method save_video_from_frames (line 139) | def save_video_from_frames(self, frames, name, visualize_func=None):
method summarize (line 183) | def summarize(self):
class StreetGaussianVisualizerLite (line 193) | class StreetGaussianVisualizerLite():
method __init__ (line 194) | def __init__(self, save_dir):
method visualize (line 205) | def visualize(self, result, camera: Camera):
method visualize_novel_view (line 218) | def visualize_novel_view(self, result, camera: Camera):
method save_video_from_frames (line 233) | def save_video_from_frames(self, frames, name, visualize_func=None):
method summarize (line 277) | def summarize(self):
FILE: metrics.py
function evaluate (line 26) | def evaluate(split='test'):
FILE: models/common.py
function autopad (line 25) | def autopad(k, p=None): # kernel, padding
function DWConv (line 32) | def DWConv(c1, c2, k=1, s=1, act=True):
class Conv (line 37) | class Conv(nn.Module):
method __init__ (line 39) | def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True): # ch_in,...
method forward (line 45) | def forward(self, x):
method fuseforward (line 48) | def fuseforward(self, x):
class TransformerLayer (line 52) | class TransformerLayer(nn.Module):
method __init__ (line 54) | def __init__(self, c, num_heads):
method forward (line 63) | def forward(self, x):
class TransformerBlock (line 69) | class TransformerBlock(nn.Module):
method __init__ (line 71) | def __init__(self, c1, c2, num_heads, num_layers):
method forward (line 80) | def forward(self, x):
class Bottleneck (line 98) | class Bottleneck(nn.Module):
method __init__ (line 100) | def __init__(self, c1, c2, shortcut=True, g=1, e=0.5): # ch_in, ch_ou...
method forward (line 107) | def forward(self, x):
class BottleneckCSP (line 111) | class BottleneckCSP(nn.Module):
method __init__ (line 113) | def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5): # ch_in, ...
method forward (line 124) | def forward(self, x):
class C3 (line 130) | class C3(nn.Module):
method __init__ (line 132) | def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5): # ch_in, ...
method forward (line 141) | def forward(self, x):
class C3TR (line 145) | class C3TR(C3):
method __init__ (line 147) | def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
class SPP (line 153) | class SPP(nn.Module):
method __init__ (line 155) | def __init__(self, c1, c2, k=(5, 9, 13)):
method forward (line 162) | def forward(self, x):
class Focus (line 167) | class Focus(nn.Module):
method __init__ (line 169) | def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True): # ch_in,...
method forward (line 174) | def forward(self, x): # x(b,c,w,h) -> y(b,4c,w/2,h/2)
class Contract (line 179) | class Contract(nn.Module):
method __init__ (line 181) | def __init__(self, gain=2):
method forward (line 185) | def forward(self, x):
class Expand (line 193) | class Expand(nn.Module):
method __init__ (line 195) | def __init__(self, gain=2):
method forward (line 199) | def forward(self, x):
class Concat (line 207) | class Concat(nn.Module):
method __init__ (line 209) | def __init__(self, dimension=1):
method forward (line 213) | def forward(self, x):
class NMS (line 217) | class NMS(nn.Module):
method __init__ (line 224) | def __init__(self):
method forward (line 227) | def forward(self, x):
class AutoShape (line 231) | class AutoShape(nn.Module):
method __init__ (line 238) | def __init__(self, model):
method autoshape (line 242) | def autoshape(self):
method forward (line 247) | def forward(self, imgs, size=640, augment=False, profile=False):
class Detections (line 302) | class Detections:
method __init__ (line 304) | def __init__(self, imgs, pred, files, times=None, names=None, shape=No...
method display (line 320) | def display(self, pprint=False, show=False, save=False, crop=False, re...
method print (line 347) | def print(self):
method show (line 351) | def show(self):
method save (line 354) | def save(self, save_dir='runs/hub/exp'):
method crop (line 358) | def crop(self, save_dir='runs/hub/exp'):
method render (line 363) | def render(self):
method pandas (line 367) | def pandas(self):
method tolist (line 377) | def tolist(self):
method __len__ (line 385) | def __len__(self):
class Classify (line 389) | class Classify(nn.Module):
method __init__ (line 391) | def __init__(self, c1, c2, k=1, s=1, p=None, g=1): # ch_in, ch_out, k...
method forward (line 397) | def forward(self, x):
class SPPF (line 405) | class SPPF(nn.Module):
method __init__ (line 407) | def __init__(self, c1, c2, k=5): # equivalent to SPP(k=(5, 9, 13))
method forward (line 414) | def forward(self, x):
FILE: models/experimental.py
class CrossConv (line 12) | class CrossConv(nn.Module):
method __init__ (line 14) | def __init__(self, c1, c2, k=3, s=1, g=1, e=1.0, shortcut=False):
method forward (line 22) | def forward(self, x):
class Sum (line 26) | class Sum(nn.Module):
method __init__ (line 28) | def __init__(self, n, weight=False): # n: number of inputs
method forward (line 35) | def forward(self, x):
class GhostConv (line 47) | class GhostConv(nn.Module):
method __init__ (line 49) | def __init__(self, c1, c2, k=1, s=1, g=1, act=True): # ch_in, ch_out,...
method forward (line 55) | def forward(self, x):
class GhostBottleneck (line 60) | class GhostBottleneck(nn.Module):
method __init__ (line 62) | def __init__(self, c1, c2, k=3, s=1): # ch_in, ch_out, kernel, stride
method forward (line 71) | def forward(self, x):
class MixConv2d (line 75) | class MixConv2d(nn.Module):
method __init__ (line 77) | def __init__(self, c1, c2, k=(1, 3), s=1, equal_ch=True):
method forward (line 95) | def forward(self, x):
class Ensemble (line 99) | class Ensemble(nn.ModuleList):
method __init__ (line 101) | def __init__(self):
method forward (line 104) | def forward(self, x, augment=False):
function attempt_load (line 114) | def attempt_load(weights, map_location=None, inplace=True):
FILE: models/export.py
function export (line 27) | def export(weights='./yolov5s.pt', # weights path
FILE: models/yolo.py
class Detect (line 31) | class Detect(nn.Module):
method __init__ (line 35) | def __init__(self, nc=80, anchors=(), ch=(), inplace=True): # detecti...
method forward (line 48) | def forward(self, x):
method _make_grid (line 73) | def _make_grid(nx=20, ny=20):
class Model (line 78) | class Model(nn.Module):
method __init__ (line 79) | def __init__(self, cfg='yolov5s.yaml', ch=3, nc=None, anchors=None): ...
method forward (line 119) | def forward(self, x, augment=False, profile=False):
method forward_augment (line 125) | def forward_augment(self, x):
method forward_once (line 138) | def forward_once(self, x, profile=False):
method _descale_pred (line 161) | def _descale_pred(self, p, flips, scale, img_size):
method _initialize_biases (line 178) | def _initialize_biases(self, cf=None): # initialize biases into Detec...
method _print_biases (line 188) | def _print_biases(self):
method fuse (line 200) | def fuse(self): # fuse model Conv2d() + BatchNorm2d() layers
method nms (line 210) | def nms(self, mode=True): # add or remove NMS module
method autoshape (line 224) | def autoshape(self): # add AutoShape module
method info (line 230) | def info(self, verbose=False, img_size=640): # print model information
function parse_model (line 234) | def parse_model(d, ch): # model_dict, input_channels(3)
FILE: networks/depth_decoder.py
class DepthDecoder (line 17) | class DepthDecoder(nn.Module):
method __init__ (line 18) | def __init__(self, num_ch_enc, scales=range(4), num_output_channels=1,...
method forward (line 50) | def forward(self, input_features):
FILE: networks/pose_cnn.py
class PoseCNN (line 13) | class PoseCNN(nn.Module):
method __init__ (line 14) | def __init__(self, num_input_frames):
method forward (line 36) | def forward(self, out):
FILE: networks/pose_decoder.py
class PoseDecoder (line 14) | class PoseDecoder(nn.Module):
method __init__ (line 15) | def __init__(self, num_ch_enc, num_input_features, num_frames_to_predi...
method forward (line 35) | def forward(self, input_features):
FILE: networks/resnet_encoder.py
class ResNetMultiImageInput (line 17) | class ResNetMultiImageInput(models.ResNet):
method __init__ (line 21) | def __init__(self, block, layers, num_classes=1000, num_input_images=1):
function resnet_multiimage_input (line 42) | def resnet_multiimage_input(num_layers, pretrained=False, num_input_imag...
class ResnetEncoder (line 62) | class ResnetEncoder(nn.Module):
method __init__ (line 65) | def __init__(self, num_layers, pretrained, num_input_images=1):
method forward (line 87) | def forward(self, input_image):
FILE: nodes/src/dummy_controllers/dummy_controllers/AEB_controller.py
class Controller (line 21) | class Controller(Node):
method __init__ (line 23) | def __init__(self):
method perception_callback (line 52) | def perception_callback(self, msg):
method pose_callback (line 90) | def pose_callback(self, msg):
method final_call (line 99) | def final_call(self):
function main (line 102) | def main(args=None):
FILE: nodes/src/dummy_controllers/dummy_controllers/object_detector.py
class ObjectDetector (line 34) | class ObjectDetector(Node):
method __init__ (line 36) | def __init__(self):
method object_point_world_position (line 90) | def object_point_world_position(self, u, v, w, h, p, k):
method distance (line 123) | def distance(self, bbox, xw=5, yw=0.1):
method image_callback (line 143) | def image_callback(self, msg):
method final_call (line 236) | def final_call(self):
function main (line 240) | def main(args=None):
FILE: nodes/src/dummy_controllers/test/test_copyright.py
function test_copyright (line 23) | def test_copyright():
FILE: nodes/src/dummy_controllers/test/test_flake8.py
function test_flake8 (line 21) | def test_flake8():
FILE: nodes/src/dummy_controllers/test/test_pep257.py
function test_pep257 (line 21) | def test_pep257():
FILE: nodes/src/simulator/simulator/evaluation.py
class Evaluation (line 22) | class Evaluation(Node):
method __init__ (line 24) | def __init__(self):
method cam_pose_callback (line 48) | def cam_pose_callback(self, msg):
method distance_gt_callback (line 53) | def distance_gt_callback(self, msg):
method final_call (line 58) | def final_call(self):
function main (line 61) | def main(args=None):
FILE: nodes/src/simulator/simulator/groundtruth.py
class GroundTruth (line 27) | class GroundTruth(Node):
method __init__ (line 29) | def __init__(self):
method transform_pose (line 92) | def transform_pose(self, ego_pose):
method listener_callback (line 106) | def listener_callback(self, msg):
method final_call (line 129) | def final_call(self):
function main (line 132) | def main(args=None):
FILE: nodes/src/simulator/simulator/simulator.py
class MainFrame (line 53) | class MainFrame(Node):
method __init__ (line 55) | def __init__(self):
method object_point_world_position (line 163) | def object_point_world_position(self, u, v, w, h, p, k):
method distance (line 196) | def distance(self, bbox, xw=5, yw=0.1):
method next_frame (line 215) | def next_frame(self):
method render (line 309) | def render(self):
method control_callback (line 422) | def control_callback(self, msg):
method final_call (line 428) | def final_call(self):
function main (line 432) | def main(args=None):
FILE: nodes/src/simulator/simulator/simulator_hil.py
class MainFrame (line 57) | class MainFrame(Node):
method __init__ (line 59) | def __init__(self):
method next_frame (line 139) | def next_frame(self):
method render (line 238) | def render(self):
method control_callback (line 264) | def control_callback(self, msg):
method final_call (line 270) | def final_call(self):
function main (line 274) | def main(args=None):
FILE: nodes/src/simulator/test/test_copyright.py
function test_copyright (line 23) | def test_copyright():
FILE: nodes/src/simulator/test/test_flake8.py
function test_flake8 (line 21) | def test_flake8():
FILE: nodes/src/simulator/test/test_pep257.py
function test_pep257 (line 21) | def test_pep257():
FILE: on_board/nodes/src/dummy_controllers/dummy_controllers/AEB_controller.py
class Controller (line 21) | class Controller(Node):
method __init__ (line 23) | def __init__(self):
method perception_callback (line 53) | def perception_callback(self, msg):
method pose_callback (line 92) | def pose_callback(self, msg):
method final_call (line 101) | def final_call(self):
function main (line 104) | def main(args=None):
FILE: on_board/nodes/src/dummy_controllers/dummy_controllers/object_detector.py
class hbSysMem_t (line 31) | class hbSysMem_t(ctypes.Structure):
class hbDNNQuantiShift_yt (line 38) | class hbDNNQuantiShift_yt(ctypes.Structure):
class hbDNNQuantiScale_t (line 44) | class hbDNNQuantiScale_t(ctypes.Structure):
class hbDNNTensorShape_t (line 52) | class hbDNNTensorShape_t(ctypes.Structure):
class hbDNNTensorProperties_t (line 58) | class hbDNNTensorProperties_t(ctypes.Structure):
class hbDNNTensor_t (line 72) | class hbDNNTensor_t(ctypes.Structure):
class Yolov5PostProcessInfo_t (line 79) | class Yolov5PostProcessInfo_t(ctypes.Structure):
function signal_handler (line 91) | def signal_handler(signal, frame):
class ObjectDetector (line 95) | class ObjectDetector(Node):
method __init__ (line 97) | def __init__(self):
method get_TensorLayout (line 160) | def get_TensorLayout(self, Layout):
method bgr2nv12_opencv (line 167) | def bgr2nv12_opencv(self, image):
method get_hw (line 181) | def get_hw(self, pro):
method is_usb_camera (line 187) | def is_usb_camera(self, device):
method find_first_usb_camera (line 197) | def find_first_usb_camera(self):
method plot_one_box (line 205) | def plot_one_box(self, x, img, color=None, label=None, line_thickness=...
method object_point_world_position (line 215) | def object_point_world_position(self, u, v, w, h, p, k):
method distance (line 248) | def distance(self, bbox, xw=5, yw=0.1):
method timer_callback (line 268) | def timer_callback(self):
method final_call (line 369) | def final_call(self):
function main (line 373) | def main(args=None):
FILE: on_board/nodes/src/dummy_controllers/dummy_controllers/test_yolov5.py
class hbSysMem_t (line 11) | class hbSysMem_t(ctypes.Structure):
class hbDNNQuantiShift_yt (line 18) | class hbDNNQuantiShift_yt(ctypes.Structure):
class hbDNNQuantiScale_t (line 24) | class hbDNNQuantiScale_t(ctypes.Structure):
class hbDNNTensorShape_t (line 32) | class hbDNNTensorShape_t(ctypes.Structure):
class hbDNNTensorProperties_t (line 38) | class hbDNNTensorProperties_t(ctypes.Structure):
class hbDNNTensor_t (line 52) | class hbDNNTensor_t(ctypes.Structure):
class Yolov5PostProcessInfo_t (line 59) | class Yolov5PostProcessInfo_t(ctypes.Structure):
function get_TensorLayout (line 77) | def get_TensorLayout(Layout):
function bgr2nv12_opencv (line 84) | def bgr2nv12_opencv(image):
function get_hw (line 98) | def get_hw(pro):
function print_properties (line 105) | def print_properties(pro):
FILE: on_board/nodes/src/dummy_controllers/test/test_copyright.py
function test_copyright (line 23) | def test_copyright():
FILE: on_board/nodes/src/dummy_controllers/test/test_flake8.py
function test_flake8 (line 21) | def test_flake8():
FILE: on_board/nodes/src/dummy_controllers/test/test_pep257.py
function test_pep257 (line 21) | def test_pep257():
FILE: render.py
function render_sets (line 15) | def render_sets():
function render_trajectory (line 62) | def render_trajectory():
FILE: render_lite.py
function camera_to_JSON (line 19) | def camera_to_JSON(id, camera: Camera):
function camera_to_tape (line 39) | def camera_to_tape(id, camera: Camera):
function tape_upsampling (line 52) | def tape_upsampling(cams_pose_list, rate):
function render_sets (line 89) | def render_sets():
function render_trajectory (line 136) | def render_trajectory():
FILE: script/kitti/colmap_kitti.py
function image_to_mask (line 15) | def image_to_mask(datadir, image_filename):
function run_colmap_kitti (line 25) | def run_colmap_kitti(result=None):
FILE: script/waymo/colmap_waymo_full.py
function convert_filename (line 20) | def convert_filename(filename):
function run_colmap_waymo (line 26) | def run_colmap_waymo(result):
FILE: script/waymo/generate_lidar_depth.py
function load_calibration (line 13) | def load_calibration(datadir):
function generate_lidar_depth (line 33) | def generate_lidar_depth(datadir):
FILE: script/waymo/generate_mono_depth.py
function estimate_depth (line 25) | def estimate_depth(img, mode='test'):
function run_midas (line 53) | def run_midas(images_lists, output_dir, ignore_exists):
FILE: script/waymo/generate_sky_mask.py
function setup (line 32) | def setup(args):
function add_to_mask_dict (line 68) | def add_to_mask_dict(masks_dict, mask_path):
function segment_with_text_prompt (line 84) | def segment_with_text_prompt(datadir, BOX_TRESHOLD, TEXT_TRESHOLD, ignor...
FILE: script/waymo/waymo_converter.py
function get_extrinsic (line 47) | def get_extrinsic(camera_calibration):
function get_intrinsic (line 52) | def get_intrinsic(camera_calibration):
function project_label_to_image (line 61) | def project_label_to_image(dim, obj_pose, calibration):
function project_label_to_mask (line 78) | def project_label_to_mask(dim, obj_pose, calibration):
function parse_seq_rawdata (line 97) | def parse_seq_rawdata(process_list, root_dir, seq_name, seq_save_dir, tr...
function main (line 525) | def main():
FILE: submodules/diff-gaussian-rasterization/cuda_rasterizer/auxiliary.h
function ndc2Pix (line 41) | float ndc2Pix(float v, int S)
function getRect (line 46) | void getRect(const float2 p, int max_radius, uint2& rect_min, uint2& rec...
function float3 (line 58) | float3 transformPoint4x3(const float3& p, const float* matrix)
function float4 (line 68) | float4 transformPoint4x4(const float3& p, const float* matrix)
function float3 (line 79) | float3 transformVec4x3(const float3& p, const float* matrix)
function float3 (line 89) | float3 transformVec4x3Transpose(const float3& p, const float* matrix)
function dnormvdz (line 99) | float dnormvdz(float3 v, float3 dv)
function float3 (line 107) | float3 dnormvdv(float3 v, float3 dv)
function float4 (line 119) | float4 dnormvdv(float4 v, float4 dv)
function sigmoid (line 134) | float sigmoid(float x)
function in_frustum (line 139) | bool in_frustum(int idx,
FILE: submodules/diff-gaussian-rasterization/cuda_rasterizer/backward.h
function namespace (line 21) | namespace BACKWARD
FILE: submodules/diff-gaussian-rasterization/cuda_rasterizer/forward.h
function namespace (line 21) | namespace FORWARD
FILE: submodules/diff-gaussian-rasterization/cuda_rasterizer/rasterizer.h
function namespace (line 18) | namespace CudaRasterizer
FILE: submodules/diff-gaussian-rasterization/cuda_rasterizer/rasterizer_impl.h
function namespace (line 19) | namespace CudaRasterizer
FILE: submodules/diff-gaussian-rasterization/diff_gaussian_rasterization/__init__.py
function cpu_deep_copy_tuple (line 17) | def cpu_deep_copy_tuple(input_tuple):
function rasterize_gaussians (line 21) | def rasterize_gaussians(
class _RasterizeGaussians (line 46) | class _RasterizeGaussians(torch.autograd.Function):
method forward (line 48) | def forward(
method backward (line 105) | def backward(ctx, grad_color, grad_radii, grad_depth, grad_alpha, grad...
class GaussianRasterizationSettings (line 167) | class GaussianRasterizationSettings(NamedTuple):
class GaussianRasterizer (line 181) | class GaussianRasterizer(nn.Module):
method __init__ (line 182) | def __init__(self, raster_settings):
method markVisible (line 186) | def markVisible(self, positions):
method forward (line 197) | def forward(self, means3D, means2D, opacities, shs = None, colors_prec...
method visible_filter (line 235) | def visible_filter(self, means3D, scales=None, rotations=None, cov3D_p...
FILE: submodules/diff-gaussian-rasterization/ext.cpp
function PYBIND11_MODULE (line 15) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
FILE: submodules/diff-gaussian-rasterization/third_party/glm/doc/api/dynsections.js
function toggleVisibility (line 1) | function toggleVisibility(linkObj)
function updateStripes (line 22) | function updateStripes()
function toggleLevel (line 28) | function toggleLevel(level)
function toggleFolder (line 49) | function toggleFolder(id)
function toggleInherit (line 84) | function toggleInherit(id)
FILE: submodules/diff-gaussian-rasterization/third_party/glm/doc/api/jquery.js
function b0 (line 16) | function b0(b3,b4){return new b0.fn.init(b3,b4)}
function bw (line 16) | function bw(){if(bF.isReady){return}try{av.documentElement.doScroll("lef...
function X (line 16) | function X(e){var bv=a2[e]={},bw,bx;e=e.split(/\s+/);for(bw=0,bx=e.lengt...
function bD (line 16) | function bD(bF){return function(bG){bx[bF]=arguments.length>1?aJ.call(ar...
function bz (line 16) | function bz(bF){return function(bG){bB[bF]=arguments.length>1?aJ.call(ar...
function a5 (line 16) | function a5(bx,bw,by){if(by===L&&bx.nodeType===1){var bv="data-"+bw.repl...
function S (line 16) | function S(bv){for(var e in bv){if(e==="data"&&b.isEmptyObject(bv[e])){c...
function bi (line 16) | function bi(by,bx,bA){var bw=bx+"defer",bv=bx+"queue",e=bx+"mark",bz=b._...
function bE (line 16) | function bE(){if(!(--bB)){e.resolveWith(bv,[bv])}}
function bk (line 16) | function bk(){return false}
function i (line 16) | function i(){return true}
function bv (line 23) | function bv(bR,bW,bV,bZ,bX,bY){for(var bT=0,bS=bZ.length;bT<bS;bT++){var...
function bN (line 23) | function bN(bR,bW,bV,bZ,bX,bY){for(var bT=0,bS=bZ.length;bT<bS;bT++){var...
function C (line 23) | function C(e){return !e||!e.parentNode||e.parentNode.nodeType===11}
function aG (line 23) | function aG(bx,bw,e){bw=bw||0;if(b.isFunction(bw)){return b.grep(bx,func...
function a (line 23) | function a(e){var bw=aR.split("|"),bv=e.createDocumentFragment();if(bv.c...
function ba (line 23) | function ba(e,bv){return b.nodeName(e,"table")?(e.getElementsByTagName("...
function t (line 23) | function t(bB,bv){if(bv.nodeType!==1||!b.hasData(bB)){return}var by,bx,e...
function ai (line 23) | function ai(bv,e){var bw;if(e.nodeType!==1){return}if(e.clearAttributes)...
function bg (line 23) | function bg(e){if(typeof e.getElementsByTagName!=="undefined"){return e....
function az (line 23) | function az(e){if(e.type==="checkbox"||e.type==="radio"){e.defaultChecke...
function E (line 23) | function E(e){var bv=(e.nodeName||"").toLowerCase();if(bv==="input"){az(...
function al (line 23) | function al(e){var bv=av.createElement("div");ac.appendChild(bv);bv.inne...
function bo (line 23) | function bo(e,bv){if(bv.src){b.ajax({url:bv.src,async:false,dataType:"sc...
function p (line 23) | function p(by,bw,bv){var bA=bw==="width"?by.offsetWidth:by.offsetHeight,...
function f (line 23) | function f(e){return function(by,bA){if(typeof by!=="string"){bA=by;by="...
function aW (line 23) | function aW(bv,bE,bz,bD,bB,bx){bB=bB||bE.dataTypes[0];bx=bx||{};bx[bB]=t...
function am (line 23) | function am(bw,bx){var bv,e,by=b.ajaxSettings.flatOptions||{};for(bv in ...
function bF (line 23) | function bF(bZ,bU,b0,bW){if(bA===2){return}bA=2;if(bE){clearTimeout(bE)}...
function v (line 23) | function v(bw,by,bv,bx){if(b.isArray(by)){b.each(by,function(bA,bz){if(b...
function bj (line 23) | function bj(bD,bC,bz){var bv=bD.contents,bB=bD.dataTypes,bw=bD.responseF...
function G (line 23) | function G(bH,bz){if(bH.dataFilter){bz=bH.dataFilter(bz,bH.dataType)}var...
function aL (line 23) | function aL(){try{return new bb.XMLHttpRequest()}catch(bv){}}
function aj (line 23) | function aj(){try{return new bb.ActiveXObject("Microsoft.XMLHTTP")}catch...
function bv (line 23) | function bv(){if(e.queue===false){b._mark(this)}var bE=b.extend({},e),bK...
function bB (line 23) | function bB(bE,bF,bD){var bC=bF[bD];b.removeData(bE,bD,true);bC.stop(e)}
function bh (line 23) | function bh(){setTimeout(at,0);return(a4=b.now())}
function at (line 23) | function at(){a4=L}
function a0 (line 23) | function a0(bv,e){var bw={};b.each(aH.concat.apply([],aH.slice(0,e)),fun...
function bv (line 23) | function bv(bA){return e.step(bA)}
function x (line 23) | function x(bx){if(!Q[bx]){var e=av.body,bv=b("<"+bx+">").appendTo(e),bw=...
function aK (line 23) | function aK(e){return b.isWindow(e)?e:e.nodeType===9?e.defaultView||e.pa...
function j (line 32) | function j(m,l,i,n){a.each(f,function(){l-=parseFloat(a.curCSS(m,"paddin...
function c (line 32) | function c(g,e){var j=g.nodeName.toLowerCase();if("area"===j){var i=g.pa...
function b (line 32) | function b(e){return !a(e).parents().andSelf().filter(function(){return ...
function a (line 61) | function a(j){j=j||location.href;return"#"+j.replace(/^[^#]*#?(.*)$/,"$1")}
function n (line 61) | function n(){var r=a(),q=o(m);if(r!==m){l(m=r,q);$(e).trigger(c)}else{if...
function h (line 61) | function h(n){j.animate(g,e,d.easing,n&&function(){n.call(this,f,d)})}
function b (line 61) | function b(d){return typeof d=="object"?d:{top:d,left:d}}
function b (line 68) | function b(){var F=this;F.top="auto";F.left="auto";F.right="auto";F.bott...
function t (line 68) | function t(K,N,F){var J=null;function L(P,Q){M();if(!K.data(e)){if(!P){c...
function j (line 68) | function j(){function G(M,L,J,O,P){var K=L.split("-")[0],N=new b(),I;if(...
function x (line 68) | function x(Q){var P=new j(),O=k("#"+Q.popupId);if(O.length===0){O=k("<di...
function q (line 68) | function q(F){return window.SVGElement&&F[0] instanceof SVGElement}
function h (line 68) | function h(){if(!c.mouseTrackingActive){c.mouseTrackingActive=true;k(fun...
function i (line 68) | function i(F){c.currentX=F.pageX;c.currentY=F.pageY}
function v (line 68) | function v(F){var H=F.offset(),J=F[0].getBoundingClientRect(),I=J.right-...
function B (line 68) | function B(I){var G=I.data(y),F=I.data(o),K=I.data(l),H,J;if(G){if(k.isF...
function m (line 68) | function m(M,L,K){var G=c.scrollTop,J=c.scrollLeft,I=G+c.windowHeight,F=...
function a (line 68) | function a(G){var F=0;while(G){G&=G-1;F++}return F}
FILE: submodules/diff-gaussian-rasterization/third_party/glm/doc/api/search/search.js
function convertToId (line 1) | function convertToId(search)
function getXPos (line 24) | function getXPos(item)
function getYPos (line 38) | function getYPos(item)
function SearchBox (line 59) | function SearchBox(name, resultsPath, inFrame, label)
function SearchResults (line 404) | function SearchResults(name)
function setKeyActions (line 709) | function setKeyActions(elem,action)
function setClassAttr (line 716) | function setClassAttr(elem,attr)
function createResults (line 722) | function createResults()
function init_search (line 777) | function init_search()
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/common.hpp
type glm (line 20) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/_noise.hpp
type glm (line 5) | namespace glm{
type detail (line 6) | namespace detail
function GLM_FUNC_QUALIFIER (line 9) | GLM_FUNC_QUALIFIER T mod289(T const& x)
function GLM_FUNC_QUALIFIER (line 15) | GLM_FUNC_QUALIFIER T permute(T const& x)
function GLM_FUNC_QUALIFIER (line 21) | GLM_FUNC_QUALIFIER vec<2, T, Q> permute(vec<2, T, Q> const& x)
function GLM_FUNC_QUALIFIER (line 27) | GLM_FUNC_QUALIFIER vec<3, T, Q> permute(vec<3, T, Q> const& x)
function GLM_FUNC_QUALIFIER (line 33) | GLM_FUNC_QUALIFIER vec<4, T, Q> permute(vec<4, T, Q> const& x)
function GLM_FUNC_QUALIFIER (line 39) | GLM_FUNC_QUALIFIER T taylorInvSqrt(T const& r)
function GLM_FUNC_QUALIFIER (line 45) | GLM_FUNC_QUALIFIER vec<2, T, Q> taylorInvSqrt(vec<2, T, Q> const& r)
function GLM_FUNC_QUALIFIER (line 51) | GLM_FUNC_QUALIFIER vec<3, T, Q> taylorInvSqrt(vec<3, T, Q> const& r)
function GLM_FUNC_QUALIFIER (line 57) | GLM_FUNC_QUALIFIER vec<4, T, Q> taylorInvSqrt(vec<4, T, Q> const& r)
function GLM_FUNC_QUALIFIER (line 63) | GLM_FUNC_QUALIFIER vec<2, T, Q> fade(vec<2, T, Q> const& t)
function GLM_FUNC_QUALIFIER (line 69) | GLM_FUNC_QUALIFIER vec<3, T, Q> fade(vec<3, T, Q> const& t)
function GLM_FUNC_QUALIFIER (line 75) | GLM_FUNC_QUALIFIER vec<4, T, Q> fade(vec<4, T, Q> const& t)
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/_swizzle.hpp
type glm (line 3) | namespace glm{
type detail (line 4) | namespace detail
type _swizzle_base0 (line 8) | struct _swizzle_base0
method GLM_FUNC_QUALIFIER (line 11) | GLM_FUNC_QUALIFIER T& elem(size_t i){ return (reinterpret_cast<T*>...
method GLM_FUNC_QUALIFIER (line 12) | GLM_FUNC_QUALIFIER T const& elem(size_t i) const{ return (reinterp...
type _swizzle_base1 (line 21) | struct _swizzle_base1 : public _swizzle_base0<T, N>
type _swizzle_base1<2, T, Q, E0,E1,-1,-2, Aligned> (line 26) | struct _swizzle_base1<2, T, Q, E0,E1,-1,-2, Aligned> : public _swizz...
method GLM_FUNC_QUALIFIER (line 28) | GLM_FUNC_QUALIFIER vec<2, T, Q> operator ()() const { return vec<...
type _swizzle_base1<3, T, Q, E0,E1,E2,-1, Aligned> (line 32) | struct _swizzle_base1<3, T, Q, E0,E1,E2,-1, Aligned> : public _swizz...
method GLM_FUNC_QUALIFIER (line 34) | GLM_FUNC_QUALIFIER vec<3, T, Q> operator ()() const { return vec<...
type _swizzle_base1<4, T, Q, E0,E1,E2,E3, Aligned> (line 38) | struct _swizzle_base1<4, T, Q, E0,E1,E2,E3, Aligned> : public _swizz...
method GLM_FUNC_QUALIFIER (line 40) | GLM_FUNC_QUALIFIER vec<4, T, Q> operator ()() const { return vec<...
type _swizzle_base2 (line 55) | struct _swizzle_base2 : public _swizzle_base1<N, T, Q, E0,E1,E2,E3, ...
type op_equal (line 57) | struct op_equal
method GLM_FUNC_QUALIFIER (line 59) | GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e = t; }
type op_minus (line 62) | struct op_minus
method GLM_FUNC_QUALIFIER (line 64) | GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e -= t; }
type op_plus (line 67) | struct op_plus
method GLM_FUNC_QUALIFIER (line 69) | GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e += t; }
type op_mul (line 72) | struct op_mul
method GLM_FUNC_QUALIFIER (line 74) | GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e *= t; }
type op_div (line 77) | struct op_div
method GLM_FUNC_QUALIFIER (line 79) | GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e /= t; }
method GLM_FUNC_QUALIFIER (line 83) | GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const T& t)
method GLM_FUNC_QUALIFIER (line 90) | GLM_FUNC_QUALIFIER _swizzle_base2& operator= (vec<N, T, Q> const& ...
method GLM_FUNC_QUALIFIER (line 96) | GLM_FUNC_QUALIFIER void operator -= (vec<N, T, Q> const& that)
method GLM_FUNC_QUALIFIER (line 101) | GLM_FUNC_QUALIFIER void operator += (vec<N, T, Q> const& that)
method GLM_FUNC_QUALIFIER (line 106) | GLM_FUNC_QUALIFIER void operator *= (vec<N, T, Q> const& that)
method GLM_FUNC_QUALIFIER (line 111) | GLM_FUNC_QUALIFIER void operator /= (vec<N, T, Q> const& that)
method GLM_FUNC_QUALIFIER (line 116) | GLM_FUNC_QUALIFIER T& operator[](size_t i)
method GLM_FUNC_QUALIFIER (line 121) | GLM_FUNC_QUALIFIER T operator[](size_t i) const
method GLM_FUNC_QUALIFIER (line 129) | GLM_FUNC_QUALIFIER void _apply_op(vec<N, T, Q> const& that, const ...
type _swizzle_base2<N, T, Q, E0,E1,E2,E3, 1> (line 144) | struct _swizzle_base2<N, T, Q, E0,E1,E2,E3, 1> : public _swizzle_bas...
type Stub (line 146) | struct Stub {}
method GLM_FUNC_QUALIFIER (line 148) | GLM_FUNC_QUALIFIER _swizzle_base2& operator= (Stub const&) { retur...
method GLM_FUNC_QUALIFIER (line 150) | GLM_FUNC_QUALIFIER T operator[] (size_t i) const
type _swizzle (line 158) | struct _swizzle : public _swizzle_base2<N, T, Q, E0, E1, E2, E3, (E0...
method GLM_FUNC_QUALIFIER (line 164) | GLM_FUNC_QUALIFIER operator vec<N, T, Q> () const { return (*this)...
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/_vectorize.hpp
type glm (line 3) | namespace glm{
type detail (line 4) | namespace detail
type functor1 (line 7) | struct functor1{}
type functor1<vec, 1, R, T, Q> (line 10) | struct functor1<vec, 1, R, T, Q>
method call (line 12) | static vec<1, R, Q> call(R (*Func) (T x), vec<1, T, Q> const& v)
type functor1<vec, 2, R, T, Q> (line 19) | struct functor1<vec, 2, R, T, Q>
method call (line 21) | static vec<2, R, Q> call(R (*Func) (T x), vec<2, T, Q> const& v)
type functor1<vec, 3, R, T, Q> (line 28) | struct functor1<vec, 3, R, T, Q>
method call (line 30) | static vec<3, R, Q> call(R (*Func) (T x), vec<3, T, Q> const& v)
type functor1<vec, 4, R, T, Q> (line 37) | struct functor1<vec, 4, R, T, Q>
method call (line 39) | static vec<4, R, Q> call(R (*Func) (T x), vec<4, T, Q> const& v)
type functor2 (line 46) | struct functor2{}
type functor2<vec, 1, T, Q> (line 49) | struct functor2<vec, 1, T, Q>
method call (line 51) | call(T (*Func) (T x, T y), vec<1, T, Q> const& a, vec<1, T, Q> con...
type functor2<vec, 2, T, Q> (line 58) | struct functor2<vec, 2, T, Q>
method call (line 60) | call(T (*Func) (T x, T y), vec<2, T, Q> const& a, vec<2, T, Q> con...
type functor2<vec, 3, T, Q> (line 67) | struct functor2<vec, 3, T, Q>
method call (line 69) | call(T (*Func) (T x, T y), vec<3, T, Q> const& a, vec<3, T, Q> con...
type functor2<vec, 4, T, Q> (line 76) | struct functor2<vec, 4, T, Q>
method call (line 78) | call(T (*Func) (T x, T y), vec<4, T, Q> const& a, vec<4, T, Q> con...
type functor2_vec_sca (line 85) | struct functor2_vec_sca{}
type functor2_vec_sca<vec, 1, T, Q> (line 88) | struct functor2_vec_sca<vec, 1, T, Q>
method call (line 90) | call(T (*Func) (T x, T y), vec<1, T, Q> const& a, T b)
type functor2_vec_sca<vec, 2, T, Q> (line 97) | struct functor2_vec_sca<vec, 2, T, Q>
method call (line 99) | call(T (*Func) (T x, T y), vec<2, T, Q> const& a, T b)
type functor2_vec_sca<vec, 3, T, Q> (line 106) | struct functor2_vec_sca<vec, 3, T, Q>
method call (line 108) | call(T (*Func) (T x, T y), vec<3, T, Q> const& a, T b)
type functor2_vec_sca<vec, 4, T, Q> (line 115) | struct functor2_vec_sca<vec, 4, T, Q>
method call (line 117) | call(T (*Func) (T x, T y), vec<4, T, Q> const& a, T b)
type functor2_vec_int (line 124) | struct functor2_vec_int {}
type functor2_vec_int<1, T, Q> (line 127) | struct functor2_vec_int<1, T, Q>
method call (line 129) | call(int (*Func) (T x, int y), vec<1, T, Q> const& a, vec<1, int, ...
type functor2_vec_int<2, T, Q> (line 136) | struct functor2_vec_int<2, T, Q>
method call (line 138) | call(int (*Func) (T x, int y), vec<2, T, Q> const& a, vec<2, int, ...
type functor2_vec_int<3, T, Q> (line 145) | struct functor2_vec_int<3, T, Q>
method call (line 147) | call(int (*Func) (T x, int y), vec<3, T, Q> const& a, vec<3, int, ...
type functor2_vec_int<4, T, Q> (line 154) | struct functor2_vec_int<4, T, Q>
method call (line 156) | call(int (*Func) (T x, int y), vec<4, T, Q> const& a, vec<4, int, ...
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/compute_common.hpp
type glm (line 6) | namespace glm{
type detail (line 7) | namespace detail
type compute_abs (line 10) | struct compute_abs
type compute_abs<genFIType, true> (line 14) | struct compute_abs<genFIType, true>
method genFIType (line 16) | static genFIType call(genFIType x)
type compute_abs<float, true> (line 29) | struct compute_abs<float, true>
method call (line 31) | static float call(float x)
type compute_abs<genFIType, false> (line 39) | struct compute_abs<genFIType, false>
method genFIType (line 41) | static genFIType call(genFIType x)
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/compute_vector_relational.hpp
type glm (line 7) | namespace glm{
type detail (line 8) | namespace detail
type compute_equal (line 11) | struct compute_equal
method call (line 13) | static bool call(T a, T b)
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/glm.cpp
type glm (line 14) | namespace glm
type vec<1, uint8, lowp> (line 17) | struct vec<1, uint8, lowp>
type vec<1, uint16, lowp> (line 18) | struct vec<1, uint16, lowp>
type vec<1, uint32, lowp> (line 19) | struct vec<1, uint32, lowp>
type vec<1, uint64, lowp> (line 20) | struct vec<1, uint64, lowp>
type vec<1, int8, lowp> (line 21) | struct vec<1, int8, lowp>
type vec<1, int16, lowp> (line 22) | struct vec<1, int16, lowp>
type vec<1, int32, lowp> (line 23) | struct vec<1, int32, lowp>
type vec<1, int64, lowp> (line 24) | struct vec<1, int64, lowp>
type vec<1, float32, lowp> (line 25) | struct vec<1, float32, lowp>
type vec<1, float64, lowp> (line 26) | struct vec<1, float64, lowp>
type vec<1, uint8, mediump> (line 28) | struct vec<1, uint8, mediump>
type vec<1, uint16, mediump> (line 29) | struct vec<1, uint16, mediump>
type vec<1, uint32, mediump> (line 30) | struct vec<1, uint32, mediump>
type vec<1, uint64, mediump> (line 31) | struct vec<1, uint64, mediump>
type vec<1, int8, mediump> (line 32) | struct vec<1, int8, mediump>
type vec<1, int16, mediump> (line 33) | struct vec<1, int16, mediump>
type vec<1, int32, mediump> (line 34) | struct vec<1, int32, mediump>
type vec<1, int64, mediump> (line 35) | struct vec<1, int64, mediump>
type vec<1, float32, mediump> (line 36) | struct vec<1, float32, mediump>
type vec<1, float64, mediump> (line 37) | struct vec<1, float64, mediump>
type vec<1, uint8, highp> (line 39) | struct vec<1, uint8, highp>
type vec<1, uint16, highp> (line 40) | struct vec<1, uint16, highp>
type vec<1, uint32, highp> (line 41) | struct vec<1, uint32, highp>
type vec<1, uint64, highp> (line 42) | struct vec<1, uint64, highp>
type vec<1, int8, highp> (line 43) | struct vec<1, int8, highp>
type vec<1, int16, highp> (line 44) | struct vec<1, int16, highp>
type vec<1, int32, highp> (line 45) | struct vec<1, int32, highp>
type vec<1, int64, highp> (line 46) | struct vec<1, int64, highp>
type vec<1, float32, highp> (line 47) | struct vec<1, float32, highp>
type vec<1, float64, highp> (line 48) | struct vec<1, float64, highp>
type vec<2, uint8, lowp> (line 51) | struct vec<2, uint8, lowp>
type vec<2, uint16, lowp> (line 52) | struct vec<2, uint16, lowp>
type vec<2, uint32, lowp> (line 53) | struct vec<2, uint32, lowp>
type vec<2, uint64, lowp> (line 54) | struct vec<2, uint64, lowp>
type vec<2, int8, lowp> (line 55) | struct vec<2, int8, lowp>
type vec<2, int16, lowp> (line 56) | struct vec<2, int16, lowp>
type vec<2, int32, lowp> (line 57) | struct vec<2, int32, lowp>
type vec<2, int64, lowp> (line 58) | struct vec<2, int64, lowp>
type vec<2, float32, lowp> (line 59) | struct vec<2, float32, lowp>
type vec<2, float64, lowp> (line 60) | struct vec<2, float64, lowp>
type vec<2, uint8, mediump> (line 62) | struct vec<2, uint8, mediump>
type vec<2, uint16, mediump> (line 63) | struct vec<2, uint16, mediump>
type vec<2, uint32, mediump> (line 64) | struct vec<2, uint32, mediump>
type vec<2, uint64, mediump> (line 65) | struct vec<2, uint64, mediump>
type vec<2, int8, mediump> (line 66) | struct vec<2, int8, mediump>
type vec<2, int16, mediump> (line 67) | struct vec<2, int16, mediump>
type vec<2, int32, mediump> (line 68) | struct vec<2, int32, mediump>
type vec<2, int64, mediump> (line 69) | struct vec<2, int64, mediump>
type vec<2, float32, mediump> (line 70) | struct vec<2, float32, mediump>
type vec<2, float64, mediump> (line 71) | struct vec<2, float64, mediump>
type vec<2, uint8, highp> (line 73) | struct vec<2, uint8, highp>
type vec<2, uint16, highp> (line 74) | struct vec<2, uint16, highp>
type vec<2, uint32, highp> (line 75) | struct vec<2, uint32, highp>
type vec<2, uint64, highp> (line 76) | struct vec<2, uint64, highp>
type vec<2, int8, highp> (line 77) | struct vec<2, int8, highp>
type vec<2, int16, highp> (line 78) | struct vec<2, int16, highp>
type vec<2, int32, highp> (line 79) | struct vec<2, int32, highp>
type vec<2, int64, highp> (line 80) | struct vec<2, int64, highp>
type vec<2, float32, highp> (line 81) | struct vec<2, float32, highp>
type vec<2, float64, highp> (line 82) | struct vec<2, float64, highp>
type vec<3, uint8, lowp> (line 85) | struct vec<3, uint8, lowp>
type vec<3, uint16, lowp> (line 86) | struct vec<3, uint16, lowp>
type vec<3, uint32, lowp> (line 87) | struct vec<3, uint32, lowp>
type vec<3, uint64, lowp> (line 88) | struct vec<3, uint64, lowp>
type vec<3, int8, lowp> (line 89) | struct vec<3, int8, lowp>
type vec<3, int16, lowp> (line 90) | struct vec<3, int16, lowp>
type vec<3, int32, lowp> (line 91) | struct vec<3, int32, lowp>
type vec<3, int64, lowp> (line 92) | struct vec<3, int64, lowp>
type vec<3, float32, lowp> (line 93) | struct vec<3, float32, lowp>
type vec<3, float64, lowp> (line 94) | struct vec<3, float64, lowp>
type vec<3, uint8, mediump> (line 96) | struct vec<3, uint8, mediump>
type vec<3, uint16, mediump> (line 97) | struct vec<3, uint16, mediump>
type vec<3, uint32, mediump> (line 98) | struct vec<3, uint32, mediump>
type vec<3, uint64, mediump> (line 99) | struct vec<3, uint64, mediump>
type vec<3, int8, mediump> (line 100) | struct vec<3, int8, mediump>
type vec<3, int16, mediump> (line 101) | struct vec<3, int16, mediump>
type vec<3, int32, mediump> (line 102) | struct vec<3, int32, mediump>
type vec<3, int64, mediump> (line 103) | struct vec<3, int64, mediump>
type vec<3, float32, mediump> (line 104) | struct vec<3, float32, mediump>
type vec<3, float64, mediump> (line 105) | struct vec<3, float64, mediump>
type vec<3, uint8, highp> (line 107) | struct vec<3, uint8, highp>
type vec<3, uint16, highp> (line 108) | struct vec<3, uint16, highp>
type vec<3, uint32, highp> (line 109) | struct vec<3, uint32, highp>
type vec<3, uint64, highp> (line 110) | struct vec<3, uint64, highp>
type vec<3, int8, highp> (line 111) | struct vec<3, int8, highp>
type vec<3, int16, highp> (line 112) | struct vec<3, int16, highp>
type vec<3, int32, highp> (line 113) | struct vec<3, int32, highp>
type vec<3, int64, highp> (line 114) | struct vec<3, int64, highp>
type vec<3, float32, highp> (line 115) | struct vec<3, float32, highp>
type vec<3, float64, highp> (line 116) | struct vec<3, float64, highp>
type vec<4, uint8, lowp> (line 119) | struct vec<4, uint8, lowp>
type vec<4, uint16, lowp> (line 120) | struct vec<4, uint16, lowp>
type vec<4, uint32, lowp> (line 121) | struct vec<4, uint32, lowp>
type vec<4, uint64, lowp> (line 122) | struct vec<4, uint64, lowp>
type vec<4, int8, lowp> (line 123) | struct vec<4, int8, lowp>
type vec<4, int16, lowp> (line 124) | struct vec<4, int16, lowp>
type vec<4, int32, lowp> (line 125) | struct vec<4, int32, lowp>
type vec<4, int64, lowp> (line 126) | struct vec<4, int64, lowp>
type vec<4, float32, lowp> (line 127) | struct vec<4, float32, lowp>
type vec<4, float64, lowp> (line 128) | struct vec<4, float64, lowp>
type vec<4, uint8, mediump> (line 130) | struct vec<4, uint8, mediump>
type vec<4, uint16, mediump> (line 131) | struct vec<4, uint16, mediump>
type vec<4, uint32, mediump> (line 132) | struct vec<4, uint32, mediump>
type vec<4, uint64, mediump> (line 133) | struct vec<4, uint64, mediump>
type vec<4, int8, mediump> (line 134) | struct vec<4, int8, mediump>
type vec<4, int16, mediump> (line 135) | struct vec<4, int16, mediump>
type vec<4, int32, mediump> (line 136) | struct vec<4, int32, mediump>
type vec<4, int64, mediump> (line 137) | struct vec<4, int64, mediump>
type vec<4, float32, mediump> (line 138) | struct vec<4, float32, mediump>
type vec<4, float64, mediump> (line 139) | struct vec<4, float64, mediump>
type vec<4, uint8, highp> (line 141) | struct vec<4, uint8, highp>
type vec<4, uint16, highp> (line 142) | struct vec<4, uint16, highp>
type vec<4, uint32, highp> (line 143) | struct vec<4, uint32, highp>
type vec<4, uint64, highp> (line 144) | struct vec<4, uint64, highp>
type vec<4, int8, highp> (line 145) | struct vec<4, int8, highp>
type vec<4, int16, highp> (line 146) | struct vec<4, int16, highp>
type vec<4, int32, highp> (line 147) | struct vec<4, int32, highp>
type vec<4, int64, highp> (line 148) | struct vec<4, int64, highp>
type vec<4, float32, highp> (line 149) | struct vec<4, float32, highp>
type vec<4, float64, highp> (line 150) | struct vec<4, float64, highp>
type mat<2, 2, float32, lowp> (line 153) | struct mat<2, 2, float32, lowp>
type mat<2, 2, float64, lowp> (line 154) | struct mat<2, 2, float64, lowp>
type mat<2, 2, float32, mediump> (line 156) | struct mat<2, 2, float32, mediump>
type mat<2, 2, float64, mediump> (line 157) | struct mat<2, 2, float64, mediump>
type mat<2, 2, float32, highp> (line 159) | struct mat<2, 2, float32, highp>
type mat<2, 2, float64, highp> (line 160) | struct mat<2, 2, float64, highp>
type mat<2, 3, float32, lowp> (line 163) | struct mat<2, 3, float32, lowp>
type mat<2, 3, float64, lowp> (line 164) | struct mat<2, 3, float64, lowp>
type mat<2, 3, float32, mediump> (line 166) | struct mat<2, 3, float32, mediump>
type mat<2, 3, float64, mediump> (line 167) | struct mat<2, 3, float64, mediump>
type mat<2, 3, float32, highp> (line 169) | struct mat<2, 3, float32, highp>
type mat<2, 3, float64, highp> (line 170) | struct mat<2, 3, float64, highp>
type mat<2, 4, float32, lowp> (line 173) | struct mat<2, 4, float32, lowp>
type mat<2, 4, float64, lowp> (line 174) | struct mat<2, 4, float64, lowp>
type mat<2, 4, float32, mediump> (line 176) | struct mat<2, 4, float32, mediump>
type mat<2, 4, float64, mediump> (line 177) | struct mat<2, 4, float64, mediump>
type mat<2, 4, float32, highp> (line 179) | struct mat<2, 4, float32, highp>
type mat<2, 4, float64, highp> (line 180) | struct mat<2, 4, float64, highp>
type mat<3, 2, float32, lowp> (line 183) | struct mat<3, 2, float32, lowp>
type mat<3, 2, float64, lowp> (line 184) | struct mat<3, 2, float64, lowp>
type mat<3, 2, float32, mediump> (line 186) | struct mat<3, 2, float32, mediump>
type mat<3, 2, float64, mediump> (line 187) | struct mat<3, 2, float64, mediump>
type mat<3, 2, float32, highp> (line 189) | struct mat<3, 2, float32, highp>
type mat<3, 2, float64, highp> (line 190) | struct mat<3, 2, float64, highp>
type mat<3, 3, float32, lowp> (line 193) | struct mat<3, 3, float32, lowp>
type mat<3, 3, float64, lowp> (line 194) | struct mat<3, 3, float64, lowp>
type mat<3, 3, float32, mediump> (line 196) | struct mat<3, 3, float32, mediump>
type mat<3, 3, float64, mediump> (line 197) | struct mat<3, 3, float64, mediump>
type mat<3, 3, float32, highp> (line 199) | struct mat<3, 3, float32, highp>
type mat<3, 3, float64, highp> (line 200) | struct mat<3, 3, float64, highp>
type mat<3, 4, float32, lowp> (line 203) | struct mat<3, 4, float32, lowp>
type mat<3, 4, float64, lowp> (line 204) | struct mat<3, 4, float64, lowp>
type mat<3, 4, float32, mediump> (line 206) | struct mat<3, 4, float32, mediump>
type mat<3, 4, float64, mediump> (line 207) | struct mat<3, 4, float64, mediump>
type mat<3, 4, float32, highp> (line 209) | struct mat<3, 4, float32, highp>
type mat<3, 4, float64, highp> (line 210) | struct mat<3, 4, float64, highp>
type mat<4, 2, float32, lowp> (line 213) | struct mat<4, 2, float32, lowp>
type mat<4, 2, float64, lowp> (line 214) | struct mat<4, 2, float64, lowp>
type mat<4, 2, float32, mediump> (line 216) | struct mat<4, 2, float32, mediump>
type mat<4, 2, float64, mediump> (line 217) | struct mat<4, 2, float64, mediump>
type mat<4, 2, float32, highp> (line 219) | struct mat<4, 2, float32, highp>
type mat<4, 2, float64, highp> (line 220) | struct mat<4, 2, float64, highp>
type mat<4, 3, float32, lowp> (line 223) | struct mat<4, 3, float32, lowp>
type mat<4, 3, float64, lowp> (line 224) | struct mat<4, 3, float64, lowp>
type mat<4, 3, float32, mediump> (line 226) | struct mat<4, 3, float32, mediump>
type mat<4, 3, float64, mediump> (line 227) | struct mat<4, 3, float64, mediump>
type mat<4, 3, float32, highp> (line 229) | struct mat<4, 3, float32, highp>
type mat<4, 3, float64, highp> (line 230) | struct mat<4, 3, float64, highp>
type mat<4, 4, float32, lowp> (line 233) | struct mat<4, 4, float32, lowp>
type mat<4, 4, float64, lowp> (line 234) | struct mat<4, 4, float64, lowp>
type mat<4, 4, float32, mediump> (line 236) | struct mat<4, 4, float32, mediump>
type mat<4, 4, float64, mediump> (line 237) | struct mat<4, 4, float64, mediump>
type mat<4, 4, float32, highp> (line 239) | struct mat<4, 4, float32, highp>
type mat<4, 4, float64, highp> (line 240) | struct mat<4, 4, float64, highp>
type qua<float32, lowp> (line 243) | struct qua<float32, lowp>
type qua<float64, lowp> (line 244) | struct qua<float64, lowp>
type qua<float32, mediump> (line 246) | struct qua<float32, mediump>
type qua<float64, mediump> (line 247) | struct qua<float64, mediump>
type qua<float32, highp> (line 249) | struct qua<float32, highp>
type qua<float64, highp> (line 250) | struct qua<float64, highp>
type tdualquat<float32, lowp> (line 253) | struct tdualquat<float32, lowp>
type tdualquat<float64, lowp> (line 254) | struct tdualquat<float64, lowp>
type tdualquat<float32, mediump> (line 256) | struct tdualquat<float32, mediump>
type tdualquat<float64, mediump> (line 257) | struct tdualquat<float64, mediump>
type tdualquat<float32, highp> (line 259) | struct tdualquat<float32, highp>
type tdualquat<float64, highp> (line 260) | struct tdualquat<float64, highp>
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/qualifier.hpp
type glm (line 5) | namespace glm
type qualifier (line 8) | enum qualifier
type vec (line 35) | struct vec
type mat (line 36) | struct mat
type qua (line 37) | struct qua
type detail (line 56) | namespace detail
type is_aligned (line 59) | struct is_aligned
type is_aligned<glm::aligned_lowp> (line 66) | struct is_aligned<glm::aligned_lowp>
type is_aligned<glm::aligned_mediump> (line 72) | struct is_aligned<glm::aligned_mediump>
type is_aligned<glm::aligned_highp> (line 78) | struct is_aligned<glm::aligned_highp>
type storage (line 85) | struct storage
type type (line 87) | struct type {
type storage<L, T, true> (line 94) | struct storage<L, T, true>
type type (line 96) | struct alignas(L * sizeof(T)) type {
type storage<3, T, true> (line 102) | struct storage<3, T, true>
type type (line 104) | struct alignas(4 * sizeof(T)) type {
type storage<4, float, true> (line 112) | struct storage<4, float, true>
type storage<4, int, true> (line 118) | struct storage<4, int, true>
type storage<4, unsigned int, true> (line 124) | struct storage<4, unsigned int, true>
type storage<2, double, true> (line 130) | struct storage<2, double, true>
type storage<2, detail::int64, true> (line 136) | struct storage<2, detail::int64, true>
type storage<2, detail::uint64, true> (line 142) | struct storage<2, detail::uint64, true>
type storage<4, double, true> (line 149) | struct storage<4, double, true>
type storage<4, detail::int64, true> (line 157) | struct storage<4, detail::int64, true>
type storage<4, detail::uint64, true> (line 163) | struct storage<4, detail::uint64, true>
type storage<4, float, true> (line 171) | struct storage<4, float, true>
type storage<4, int, true> (line 177) | struct storage<4, int, true>
type storage<4, unsigned int, true> (line 183) | struct storage<4, unsigned int, true>
type genTypeEnum (line 189) | enum genTypeEnum
type genTypeTrait (line 197) | struct genTypeTrait
type genTypeTrait<mat<C, R, T> > (line 201) | struct genTypeTrait<mat<C, R, T> >
type init_gentype (line 207) | struct init_gentype
type init_gentype<genType, GENTYPE_QUAT> (line 212) | struct init_gentype<genType, GENTYPE_QUAT>
method genType (line 214) | static genType identity()
type init_gentype<genType, GENTYPE_MAT> (line 221) | struct init_gentype<genType, GENTYPE_MAT>
method genType (line 223) | static genType identity()
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/setup.hpp
type glm (line 580) | namespace glm {
type std (line 581) | namespace std {
function countof (line 647) | constexpr std::size_t countof(T const (&)[N])
type detail (line 667) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 699) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 732) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 741) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type glm (line 628) | namespace glm
type std (line 581) | namespace std {
function countof (line 647) | constexpr std::size_t countof(T const (&)[N])
type detail (line 667) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 699) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 732) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 741) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type glm (line 644) | namespace glm
type std (line 581) | namespace std {
function countof (line 647) | constexpr std::size_t countof(T const (&)[N])
type detail (line 667) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 699) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 732) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 741) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type glm (line 666) | namespace glm{
type std (line 581) | namespace std {
function countof (line 647) | constexpr std::size_t countof(T const (&)[N])
type detail (line 667) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 699) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 732) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 741) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type glm (line 698) | namespace glm{
type std (line 581) | namespace std {
function countof (line 647) | constexpr std::size_t countof(T const (&)[N])
type detail (line 667) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 699) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 732) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 741) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type glm (line 731) | namespace glm{
type std (line 581) | namespace std {
function countof (line 647) | constexpr std::size_t countof(T const (&)[N])
type detail (line 667) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 699) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 732) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 741) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type glm (line 740) | namespace glm{
type std (line 581) | namespace std {
function countof (line 647) | constexpr std::size_t countof(T const (&)[N])
type detail (line 667) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 699) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 732) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 741) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/type_float.hpp
type glm (line 10) | namespace glm{
type detail (line 11) | namespace detail
function GLM_CONSTEXPR (line 24) | GLM_CONSTEXPR float_t(float_type Num = 0.0f) : f(Num) {}
function GLM_CONSTEXPR (line 26) | GLM_CONSTEXPR float_t& operator=(float_t const& x)
function GLM_CONSTEXPR (line 33) | GLM_CONSTEXPR bool negative() const { return i < 0; }
function GLM_CONSTEXPR (line 34) | GLM_CONSTEXPR int_type mantissa() const { return i & ((1 << 23) - 1); }
function GLM_CONSTEXPR (line 35) | GLM_CONSTEXPR int_type exponent() const { return (i >> 23) & ((1 << ...
function GLM_CONSTEXPR (line 47) | GLM_CONSTEXPR float_t(float_type Num = static_cast<float_type>(0)) :...
function GLM_CONSTEXPR (line 49) | GLM_CONSTEXPR float_t& operator=(float_t const& x)
function GLM_CONSTEXPR (line 56) | GLM_CONSTEXPR bool negative() const { return i < 0; }
function GLM_CONSTEXPR (line 57) | GLM_CONSTEXPR int_type mantissa() const { return i & ((int_type(1) <...
function GLM_CONSTEXPR (line 58) | GLM_CONSTEXPR int_type exponent() const { return (i >> 52) & ((int_t...
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/type_half.hpp
type glm (line 5) | namespace glm{
type detail (line 6) | namespace detail
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/type_mat2x2.hpp
type glm (line 10) | namespace glm
type mat<2, 2, T, Q> (line 13) | struct mat<2, 2, T, Q>
method length_type (line 28) | length_type length() { return 2; }
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/type_mat2x3.hpp
type glm (line 11) | namespace glm
type mat<2, 3, T, Q> (line 14) | struct mat<2, 3, T, Q>
method length_type (line 29) | length_type length() { return 2; }
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/type_mat2x4.hpp
type glm (line 11) | namespace glm
type mat<2, 4, T, Q> (line 14) | struct mat<2, 4, T, Q>
method length_type (line 29) | length_type length() { return 2; }
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/type_mat3x2.hpp
type glm (line 11) | namespace glm
type mat<3, 2, T, Q> (line 14) | struct mat<3, 2, T, Q>
method length_type (line 29) | length_type length() { return 3; }
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/type_mat3x3.hpp
type glm (line 10) | namespace glm
type mat<3, 3, T, Q> (line 13) | struct mat<3, 3, T, Q>
method length_type (line 28) | length_type length() { return 3; }
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/type_mat3x4.hpp
type glm (line 11) | namespace glm
type mat<3, 4, T, Q> (line 14) | struct mat<3, 4, T, Q>
method length_type (line 29) | length_type length() { return 3; }
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/type_mat4x2.hpp
type glm (line 11) | namespace glm
type mat<4, 2, T, Q> (line 14) | struct mat<4, 2, T, Q>
method length_type (line 29) | length_type length() { return 4; }
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/type_mat4x3.hpp
type glm (line 11) | namespace glm
type mat<4, 3, T, Q> (line 14) | struct mat<4, 3, T, Q>
method length_type (line 29) | length_type length() { return 4; }
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/type_mat4x4.hpp
type glm (line 10) | namespace glm
type mat<4, 4, T, Q> (line 13) | struct mat<4, 4, T, Q>
method length_type (line 28) | length_type length(){return 4;}
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/type_quat.hpp
type glm (line 16) | namespace glm
type qua (line 19) | struct qua
method length_type (line 76) | length_type length(){return 4;}
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/type_vec1.hpp
type glm (line 14) | namespace glm
type vec<1, T, Q> (line 17) | struct vec<1, T, Q>
method length_type (line 88) | length_type length(){return 1;}
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/type_vec2.hpp
type glm (line 14) | namespace glm
type vec<2, T, Q> (line 17) | struct vec<2, T, Q>
method length_type (line 90) | length_type length(){return 2;}
method GLM_FUNC_DECL (line 138) | GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1,-1,...
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/type_vec3.hpp
type glm (line 14) | namespace glm
type vec<3, T, Q> (line 17) | struct vec<3, T, Q>
method length_type (line 94) | length_type length(){return 3;}
method GLM_FUNC_DECL (line 159) | GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<3, T, Q, E0, E1, E2...
method GLM_FUNC_DECL (line 165) | GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1, -1...
method GLM_FUNC_DECL (line 171) | GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& scalar, detail::_swizzle<2,...
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/detail/type_vec4.hpp
type glm (line 14) | namespace glm
type vec<4, T, Q> (line 17) | struct vec<4, T, Q>
method length_type (line 93) | length_type length(){return 4;}
method GLM_FUNC_DECL (line 208) | GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<4, T, Q, E0, E1, E2...
method GLM_FUNC_DECL (line 214) | GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1, -1...
method GLM_FUNC_DECL (line 220) | GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& x, T const& y, detail::_swi...
method GLM_FUNC_DECL (line 226) | GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& x, detail::_swizzle<2, T, Q...
method GLM_FUNC_DECL (line 232) | GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1, -1...
method GLM_FUNC_DECL (line 238) | GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<3, T, Q, E0, E1, E2...
method GLM_FUNC_DECL (line 244) | GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& x, detail::_swizzle<3, T, Q...
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/exponential.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/_matrix_vectorize.hpp
type glm (line 3) | namespace glm {
type detail (line 5) | namespace detail {
type matrix_functor_1 (line 8) | struct matrix_functor_1 {
type matrix_functor_1<mat, 2, 2, Ret, T, Q> (line 12) | struct matrix_functor_1<mat, 2, 2, Ret, T, Q> {
method call (line 13) | static mat<2, 2, T, Q> call(Ret (*Func)(T x), mat<2, 2, T, Q> cons...
type matrix_functor_1<mat, 2, 3, Ret, T, Q> (line 22) | struct matrix_functor_1<mat, 2, 3, Ret, T, Q> {
method call (line 24) | static mat<2, 3, T, Q> call(Ret (*Func)(T x), mat<2, 3, T, Q> cons...
type matrix_functor_1<mat, 2, 4, Ret, T, Q> (line 34) | struct matrix_functor_1<mat, 2, 4, Ret, T, Q> {
method call (line 36) | static mat<2, 4, T, Q> call(Ret (*Func)(T x), mat<2, 4, T, Q> cons...
type matrix_functor_1<mat, 3, 2, Ret, T, Q> (line 46) | struct matrix_functor_1<mat, 3, 2, Ret, T, Q> {
method call (line 48) | static mat<3, 2, T, Q> call(Ret (*Func)(T x), mat<3, 2, T, Q> cons...
type matrix_functor_1<mat, 3, 3, Ret, T, Q> (line 59) | struct matrix_functor_1<mat, 3, 3, Ret, T, Q> {
method call (line 61) | static mat<3, 3, T, Q> call(Ret (*Func)(T x), mat<3, 3, T, Q> cons...
type matrix_functor_1<mat, 3, 4, Ret, T, Q> (line 72) | struct matrix_functor_1<mat, 3, 4, Ret, T, Q> {
method call (line 74) | static mat<3, 4, T, Q> call(Ret (*Func)(T x), mat<3, 4, T, Q> cons...
type matrix_functor_1<mat, 4, 2, Ret, T, Q> (line 85) | struct matrix_functor_1<mat, 4, 2, Ret, T, Q> {
method call (line 87) | static mat<4, 2, T, Q> call(Ret (*Func)(T x), mat<4, 2, T, Q> cons...
type matrix_functor_1<mat, 4, 3, Ret, T, Q> (line 99) | struct matrix_functor_1<mat, 4, 3, Ret, T, Q> {
method call (line 101) | static mat<4, 3, T, Q> call(Ret (*Func)(T x), mat<4, 3, T, Q> cons...
type matrix_functor_1<mat, 4, 4, Ret, T, Q> (line 113) | struct matrix_functor_1<mat, 4, 4, Ret, T, Q> {
method call (line 115) | static mat<4, 4, T, Q> call(Ret (*Func)(T x), mat<4, 4, T, Q> cons...
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_clip_space.hpp
type glm (line 31) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_common.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_double2x2.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_double2x2_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_double2x3.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_double2x3_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_double2x4.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_double2x4_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_double3x2.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_double3x2_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_double3x3.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_double3x3_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_double3x4.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_double3x4_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_double4x2.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_double4x2_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_double4x3.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_double4x3_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_double4x4.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_double4x4_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_float2x2.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_float2x2_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_float2x3.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_float2x3_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_float2x4.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_float2x4_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_float3x2.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_float3x2_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_float3x3.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_float3x3_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_float3x4.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_float3x4_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_float4x2.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_float4x2_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_float4x3.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_float4x3_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_float4x4.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_float4x4_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_int2x2.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_int2x2_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_int2x3.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_int2x3_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_int2x4.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_int2x4_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_int3x2.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_int3x2_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_int3x3.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_int3x3_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_int3x4.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_int3x4_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_int4x2.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_int4x2_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_int4x3.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_int4x3_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_int4x4.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_int4x4_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_integer.hpp
type glm (line 32) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_projection.hpp
type glm (line 32) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_relational.hpp
type glm (line 24) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_transform.hpp
type glm (line 32) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_uint2x2.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_uint2x2_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_uint2x3.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_uint2x3_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_uint2x4.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_uint2x4_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_uint3x2.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_uint3x2_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_uint3x3.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_uint3x3_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_uint3x4.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_uint3x4_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_uint4x2.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_uint4x2_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_uint4x3.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_uint4x3_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_uint4x4.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/matrix_uint4x4_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/quaternion_common.hpp
type glm (line 35) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/quaternion_double.hpp
type glm (line 29) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/quaternion_double_precision.hpp
type glm (line 20) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/quaternion_exponential.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/quaternion_float.hpp
type glm (line 29) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/quaternion_float_precision.hpp
type glm (line 20) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/quaternion_geometric.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/quaternion_relational.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/quaternion_transform.hpp
type glm (line 29) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/quaternion_trigonometric.hpp
type glm (line 31) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/scalar_common.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/scalar_constants.hpp
type glm (line 20) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/scalar_int_sized.hpp
type glm (line 21) | namespace glm{
type detail (line 22) | namespace detail
type is_int<int8> (line 35) | struct is_int<int8>
type test (line 37) | enum test {value = ~0}
type is_int<int16> (line 41) | struct is_int<int16>
type test (line 43) | enum test {value = ~0}
type is_int<int64> (line 47) | struct is_int<int64>
type test (line 49) | enum test {value = ~0}
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/scalar_integer.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/scalar_packing.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/scalar_reciprocal.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/scalar_relational.hpp
type glm (line 24) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/scalar_uint_sized.hpp
type glm (line 21) | namespace glm{
type detail (line 22) | namespace detail
type is_int<uint8> (line 35) | struct is_int<uint8>
type test (line 37) | enum test {value = ~0}
type is_int<uint16> (line 41) | struct is_int<uint16>
type test (line 43) | enum test {value = ~0}
type is_int<uint64> (line 47) | struct is_int<uint64>
type test (line 49) | enum test {value = ~0}
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/scalar_ulp.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_bool1.hpp
type glm (line 21) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_bool1_precision.hpp
type glm (line 19) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_bool2.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_bool2_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_bool3.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_bool3_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_bool4.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_bool4_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_common.hpp
type glm (line 24) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_double1.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_double1_precision.hpp
type glm (line 21) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_double2.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_double2_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_double3.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_double3_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_double4.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_double4_precision.hpp
type glm (line 8) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_float1.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_float1_precision.hpp
type glm (line 21) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_float2.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_float2_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_float3.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_float3_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_float4.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_float4_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_int1.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_int1_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_int2.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_int2_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_int3.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_int3_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_int4.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_int4_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_integer.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_packing.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_reciprocal.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_relational.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_uint1.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_uint1_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_uint2.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_uint2_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_uint3.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_uint3_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_uint4.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_uint4_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/ext/vector_ulp.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/fwd.hpp
type glm (line 5) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/geometric.hpp
type glm (line 17) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtc/bitfield.hpp
type glm (line 30) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtc/color_space.hpp
type glm (line 28) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtc/constants.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtc/epsilon.hpp
type glm (line 24) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtc/integer.hpp
type glm (line 30) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtc/matrix_access.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtc/matrix_integer.hpp
type glm (line 30) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtc/matrix_inverse.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtc/noise.hpp
type glm (line 34) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtc/packing.hpp
type glm (line 24) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtc/quaternion.hpp
type glm (line 38) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtc/random.hpp
type glm (line 25) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtc/round.hpp
type glm (line 28) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtc/type_aligned.hpp
type glm (line 37) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtc/type_precision.hpp
type glm (line 46) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtc/type_ptr.hpp
type glm (line 57) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtc/ulp.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/associated_min_max.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/bit.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/closest_point.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/color_encoding.hpp
type glm (line 30) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/color_space.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/color_space_YCoCg.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/common.hpp
type glm (line 29) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/compatibility.hpp
type glm (line 36) | namespace glm
function GLM_FUNC_QUALIFIER (line 41) | GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);}
function GLM_FUNC_QUALIFIER (line 42) | GLM_FUNC_QUALIFIER vec<2, T, Q> lerp(const vec<2, T, Q>& x, const vec<...
function GLM_FUNC_QUALIFIER (line 44) | GLM_FUNC_QUALIFIER vec<3, T, Q> lerp(const vec<3, T, Q>& x, const vec<...
function GLM_FUNC_QUALIFIER (line 45) | GLM_FUNC_QUALIFIER vec<4, T, Q> lerp(const vec<4, T, Q>& x, const vec<...
function GLM_FUNC_QUALIFIER (line 46) | GLM_FUNC_QUALIFIER vec<2, T, Q> lerp(const vec<2, T, Q>& x, const vec<...
function GLM_FUNC_QUALIFIER (line 47) | GLM_FUNC_QUALIFIER vec<3, T, Q> lerp(const vec<3, T, Q>& x, const vec<...
function GLM_FUNC_QUALIFIER (line 48) | GLM_FUNC_QUALIFIER vec<4, T, Q> lerp(const vec<4, T, Q>& x, const vec<...
function GLM_FUNC_QUALIFIER (line 50) | GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));}
function GLM_FUNC_QUALIFIER (line 51) | GLM_FUNC_QUALIFIER vec<2, T, Q> saturate(const vec<2, T, Q>& x){return...
function GLM_FUNC_QUALIFIER (line 52) | GLM_FUNC_QUALIFIER vec<3, T, Q> saturate(const vec<3, T, Q>& x){return...
function GLM_FUNC_QUALIFIER (line 53) | GLM_FUNC_QUALIFIER vec<4, T, Q> saturate(const vec<4, T, Q>& x){return...
function GLM_FUNC_QUALIFIER (line 55) | GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);}
function GLM_FUNC_QUALIFIER (line 56) | GLM_FUNC_QUALIFIER vec<2, T, Q> atan2(const vec<2, T, Q>& x, const vec...
function GLM_FUNC_QUALIFIER (line 57) | GLM_FUNC_QUALIFIER vec<3, T, Q> atan2(const vec<3, T, Q>& x, const vec...
function GLM_FUNC_QUALIFIER (line 58) | GLM_FUNC_QUALIFIER vec<4, T, Q> atan2(const vec<4, T, Q>& x, const vec...
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/component_wise.hpp
type glm (line 29) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/dual_quaternion.hpp
type glm (line 31) | namespace glm
type tdualquat (line 37) | struct tdualquat
method length_type (line 52) | length_type length(){return 2;}
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/easing.hpp
type glm (line 32) | namespace glm{
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/euler_angles.hpp
type glm (line 29) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/extend.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/extended_min_max.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/exterior_product.hpp
type glm (line 28) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/fast_exponential.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/fast_square_root.hpp
type glm (line 30) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/fast_trigonometry.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/functions.hpp
type glm (line 29) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/gradient_paint.hpp
type glm (line 28) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/handed_coordinate_space.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/hash.hpp
type std (line 49) | namespace std
type hash<glm::vec<1, T,Q> > (line 52) | struct hash<glm::vec<1, T,Q> >
type hash<glm::vec<2, T,Q> > (line 58) | struct hash<glm::vec<2, T,Q> >
type hash<glm::vec<3, T,Q> > (line 64) | struct hash<glm::vec<3, T,Q> >
type hash<glm::vec<4, T,Q> > (line 70) | struct hash<glm::vec<4, T,Q> >
type hash<glm::qua<T,Q>> (line 76) | struct hash<glm::qua<T,Q>>
type hash<glm::tdualquat<T,Q> > (line 82) | struct hash<glm::tdualquat<T,Q> >
type hash<glm::mat<2, 2, T,Q> > (line 88) | struct hash<glm::mat<2, 2, T,Q> >
type hash<glm::mat<2, 3, T,Q> > (line 94) | struct hash<glm::mat<2, 3, T,Q> >
type hash<glm::mat<2, 4, T,Q> > (line 100) | struct hash<glm::mat<2, 4, T,Q> >
type hash<glm::mat<3, 2, T,Q> > (line 106) | struct hash<glm::mat<3, 2, T,Q> >
type hash<glm::mat<3, 3, T,Q> > (line 112) | struct hash<glm::mat<3, 3, T,Q> >
type hash<glm::mat<3, 4, T,Q> > (line 118) | struct hash<glm::mat<3, 4, T,Q> >
type hash<glm::mat<4, 2, T,Q> > (line 124) | struct hash<glm::mat<4, 2, T,Q> >
type hash<glm::mat<4, 3, T,Q> > (line 130) | struct hash<glm::mat<4, 3, T,Q> >
type hash<glm::mat<4, 4, T,Q> > (line 136) | struct hash<glm::mat<4, 4, T,Q> >
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/integer.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/intersect.hpp
type glm (line 32) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/io.hpp
type glm (line 38) | namespace glm
type io (line 43) | namespace io
type order_type (line 45) | enum order_type { column_major, row_major}
class format_punct (line 48) | class format_punct : public std::locale::facet
class basic_state_saver (line 71) | class basic_state_saver {
class basic_format_saver (line 100) | class basic_format_saver
type precision (line 117) | struct precision
type width (line 124) | struct width
type delimeter (line 132) | struct delimeter
type order (line 139) | struct order
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/log_base.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/matrix_cross_product.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/matrix_decompose.hpp
type glm (line 31) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/matrix_factorisation.hpp
type glm (line 32) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/matrix_interpolation.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/matrix_major_storage.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/matrix_operation.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/matrix_query.hpp
type glm (line 29) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/matrix_transform_2d.hpp
type glm (line 28) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/mixed_product.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/norm.hpp
type glm (line 30) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/normal.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/normalize_dot.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/number_precision.hpp
type glm (line 29) | namespace glm{
type gtx (line 30) | namespace gtx
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/optimum_pow.hpp
type glm (line 26) | namespace glm{
type gtx (line 27) | namespace gtx
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/orthonormalize.hpp
type glm (line 29) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/pca.hpp
type glm (line 54) | namespace glm {
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/perpendicular.hpp
type glm (line 28) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/polar_coordinates.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/projection.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/quaternion.hpp
type glm (line 31) | namespace glm
function GLM_FUNC_QUALIFIER (line 113) | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> toMat3(
function GLM_FUNC_QUALIFIER (line 120) | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> toMat4(
function GLM_FUNC_QUALIFIER (line 127) | GLM_FUNC_QUALIFIER qua<T, Q> toQuat(
function GLM_FUNC_QUALIFIER (line 134) | GLM_FUNC_QUALIFIER qua<T, Q> toQuat(
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/range.hpp
type glm (line 29) | namespace glm
function length_t (line 40) | inline length_t components(vec<1, T, Q> const& v)
function length_t (line 46) | inline length_t components(vec<2, T, Q> const& v)
function length_t (line 52) | inline length_t components(vec<3, T, Q> const& v)
function length_t (line 58) | inline length_t components(vec<4, T, Q> const& v)
function length_t (line 64) | inline length_t components(genType const& m)
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/raw_data.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/rotate_normalized_axis.hpp
type glm (line 30) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/rotate_vector.hpp
type glm (line 30) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/scalar_multiplication.hpp
type glm (line 36) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/scalar_relational.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/spline.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/std_based_type.hpp
type glm (line 28) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/string_cast.hpp
type glm (line 33) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/texture.hpp
type glm (line 28) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/transform.hpp
type glm (line 30) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/transform2.hpp
type glm (line 28) | namespace glm
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/type_trait.hpp
type glm (line 28) | namespace glm
type type (line 34) | struct type
type type<vec<L, T, Q> > (line 45) | struct type<vec<L, T, Q> >
type type<mat<C, R, T, Q> > (line 54) | struct type<mat<C, R, T, Q> >
type type<qua<T, Q> > (line 65) | struct type<qua<T, Q> >
type type<tdualquat<T, Q> > (line 74) | struct type<tdualquat<T, Q> >
FILE: submodules/diff-gaussian-rasterization/third_party/glm/glm/gtx/vec_swizzle.hpp
type glm (line 25) | namespace glm {
function GLM_INLINE (line 31) | GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<1, T, Q> &v) {
function GLM_INLINE (line 36) | GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 41) | GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 46) | GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 52) | GLM_INLINE glm::vec<2, T, Q> xy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 57) | GLM_INLINE glm::vec<2, T, Q> xy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 62) | GLM_INLINE glm::vec<2, T, Q> xy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 68) | GLM_INLINE glm::vec<2, T, Q> xz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 73) | GLM_INLINE glm::vec<2, T, Q> xz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 79) | GLM_INLINE glm::vec<2, T, Q> xw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 85) | GLM_INLINE glm::vec<2, T, Q> yx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 90) | GLM_INLINE glm::vec<2, T, Q> yx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 95) | GLM_INLINE glm::vec<2, T, Q> yx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 101) | GLM_INLINE glm::vec<2, T, Q> yy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 106) | GLM_INLINE glm::vec<2, T, Q> yy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 111) | GLM_INLINE glm::vec<2, T, Q> yy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 117) | GLM_INLINE glm::vec<2, T, Q> yz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 122) | GLM_INLINE glm::vec<2, T, Q> yz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 128) | GLM_INLINE glm::vec<2, T, Q> yw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 134) | GLM_INLINE glm::vec<2, T, Q> zx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 139) | GLM_INLINE glm::vec<2, T, Q> zx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 145) | GLM_INLINE glm::vec<2, T, Q> zy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 150) | GLM_INLINE glm::vec<2, T, Q> zy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 156) | GLM_INLINE glm::vec<2, T, Q> zz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 161) | GLM_INLINE glm::vec<2, T, Q> zz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 167) | GLM_INLINE glm::vec<2, T, Q> zw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 173) | GLM_INLINE glm::vec<2, T, Q> wx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 179) | GLM_INLINE glm::vec<2, T, Q> wy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 185) | GLM_INLINE glm::vec<2, T, Q> wz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 191) | GLM_INLINE glm::vec<2, T, Q> ww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 197) | GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<1, T, Q> &v) {
function GLM_INLINE (line 202) | GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 207) | GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 212) | GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 218) | GLM_INLINE glm::vec<3, T, Q> xxy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 223) | GLM_INLINE glm::vec<3, T, Q> xxy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 228) | GLM_INLINE glm::vec<3, T, Q> xxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 234) | GLM_INLINE glm::vec<3, T, Q> xxz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 239) | GLM_INLINE glm::vec<3, T, Q> xxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 245) | GLM_INLINE glm::vec<3, T, Q> xxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 251) | GLM_INLINE glm::vec<3, T, Q> xyx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 256) | GLM_INLINE glm::vec<3, T, Q> xyx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 261) | GLM_INLINE glm::vec<3, T, Q> xyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 267) | GLM_INLINE glm::vec<3, T, Q> xyy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 272) | GLM_INLINE glm::vec<3, T, Q> xyy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 277) | GLM_INLINE glm::vec<3, T, Q> xyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 283) | GLM_INLINE glm::vec<3, T, Q> xyz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 288) | GLM_INLINE glm::vec<3, T, Q> xyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 294) | GLM_INLINE glm::vec<3, T, Q> xyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 300) | GLM_INLINE glm::vec<3, T, Q> xzx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 305) | GLM_INLINE glm::vec<3, T, Q> xzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 311) | GLM_INLINE glm::vec<3, T, Q> xzy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 316) | GLM_INLINE glm::vec<3, T, Q> xzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 322) | GLM_INLINE glm::vec<3, T, Q> xzz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 327) | GLM_INLINE glm::vec<3, T, Q> xzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 333) | GLM_INLINE glm::vec<3, T, Q> xzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 339) | GLM_INLINE glm::vec<3, T, Q> xwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 345) | GLM_INLINE glm::vec<3, T, Q> xwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 351) | GLM_INLINE glm::vec<3, T, Q> xwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 357) | GLM_INLINE glm::vec<3, T, Q> xww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 363) | GLM_INLINE glm::vec<3, T, Q> yxx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 368) | GLM_INLINE glm::vec<3, T, Q> yxx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 373) | GLM_INLINE glm::vec<3, T, Q> yxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 379) | GLM_INLINE glm::vec<3, T, Q> yxy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 384) | GLM_INLINE glm::vec<3, T, Q> yxy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 389) | GLM_INLINE glm::vec<3, T, Q> yxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 395) | GLM_INLINE glm::vec<3, T, Q> yxz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 400) | GLM_INLINE glm::vec<3, T, Q> yxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 406) | GLM_INLINE glm::vec<3, T, Q> yxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 412) | GLM_INLINE glm::vec<3, T, Q> yyx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 417) | GLM_INLINE glm::vec<3, T, Q> yyx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 422) | GLM_INLINE glm::vec<3, T, Q> yyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 428) | GLM_INLINE glm::vec<3, T, Q> yyy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 433) | GLM_INLINE glm::vec<3, T, Q> yyy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 438) | GLM_INLINE glm::vec<3, T, Q> yyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 444) | GLM_INLINE glm::vec<3, T, Q> yyz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 449) | GLM_INLINE glm::vec<3, T, Q> yyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 455) | GLM_INLINE glm::vec<3, T, Q> yyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 461) | GLM_INLINE glm::vec<3, T, Q> yzx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 466) | GLM_INLINE glm::vec<3, T, Q> yzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 472) | GLM_INLINE glm::vec<3, T, Q> yzy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 477) | GLM_INLINE glm::vec<3, T, Q> yzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 483) | GLM_INLINE glm::vec<3, T, Q> yzz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 488) | GLM_INLINE glm::vec<3, T, Q> yzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 494) | GLM_INLINE glm::vec<3, T, Q> yzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 500) | GLM_INLINE glm::vec<3, T, Q> ywx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 506) | GLM_INLINE glm::vec<3, T, Q> ywy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 512) | GLM_INLINE glm::vec<3, T, Q> ywz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 518) | GLM_INLINE glm::vec<3, T, Q> yww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 524) | GLM_INLINE glm::vec<3, T, Q> zxx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 529) | GLM_INLINE glm::vec<3, T, Q> zxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 535) | GLM_INLINE glm::vec<3, T, Q> zxy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 540) | GLM_INLINE glm::vec<3, T, Q> zxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 546) | GLM_INLINE glm::vec<3, T, Q> zxz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 551) | GLM_INLINE glm::vec<3, T, Q> zxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 557) | GLM_INLINE glm::vec<3, T, Q> zxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 563) | GLM_INLINE glm::vec<3, T, Q> zyx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 568) | GLM_INLINE glm::vec<3, T, Q> zyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 574) | GLM_INLINE glm::vec<3, T, Q> zyy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 579) | GLM_INLINE glm::vec<3, T, Q> zyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 585) | GLM_INLINE glm::vec<3, T, Q> zyz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 590) | GLM_INLINE glm::vec<3, T, Q> zyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 596) | GLM_INLINE glm::vec<3, T, Q> zyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 602) | GLM_INLINE glm::vec<3, T, Q> zzx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 607) | GLM_INLINE glm::vec<3, T, Q> zzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 613) | GLM_INLINE glm::vec<3, T, Q> zzy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 618) | GLM_INLINE glm::vec<3, T, Q> zzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 624) | GLM_INLINE glm::vec<3, T, Q> zzz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 629) | GLM_INLINE glm::vec<3, T, Q> zzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 635) | GLM_INLINE glm::vec<3, T, Q> zzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 641) | GLM_INLINE glm::vec<3, T, Q> zwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 647) | GLM_INLINE glm::vec<3, T, Q> zwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 653) | GLM_INLINE glm::vec<3, T, Q> zwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 659) | GLM_INLINE glm::vec<3, T, Q> zww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 665) | GLM_INLINE glm::vec<3, T, Q> wxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 671) | GLM_INLINE glm::vec<3, T, Q> wxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 677) | GLM_INLINE glm::vec<3, T, Q> wxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 683) | GLM_INLINE glm::vec<3, T, Q> wxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 689) | GLM_INLINE glm::vec<3, T, Q> wyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 695) | GLM_INLINE glm::vec<3, T, Q> wyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 701) | GLM_INLINE glm::vec<3, T, Q> wyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 707) | GLM_INLINE glm::vec<3, T, Q> wyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 713) | GLM_INLINE glm::vec<3, T, Q> wzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 719) | GLM_INLINE glm::vec<3, T, Q> wzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 725) | GLM_INLINE glm::vec<3, T, Q> wzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 731) | GLM_INLINE glm::vec<3, T, Q> wzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 737) | GLM_INLINE glm::vec<3, T, Q> wwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 743) | GLM_INLINE glm::vec<3, T, Q> wwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 749) | GLM_INLINE glm::vec<3, T, Q> wwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 755) | GLM_INLINE glm::vec<3, T, Q> www(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 761) | GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<1, T, Q> &v) {
function GLM_INLINE (line 766) | GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 771) | GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 776) | GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 782) | GLM_INLINE glm::vec<4, T, Q> xxxy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 787) | GLM_INLINE glm::vec<4, T, Q> xxxy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 792) | GLM_INLINE glm::vec<4, T, Q> xxxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 798) | GLM_INLINE glm::vec<4, T, Q> xxxz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 803) | GLM_INLINE glm::vec<4, T, Q> xxxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 809) | GLM_INLINE glm::vec<4, T, Q> xxxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 815) | GLM_INLINE glm::vec<4, T, Q> xxyx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 820) | GLM_INLINE glm::vec<4, T, Q> xxyx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 825) | GLM_INLINE glm::vec<4, T, Q> xxyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 831) | GLM_INLINE glm::vec<4, T, Q> xxyy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 836) | GLM_INLINE glm::vec<4, T, Q> xxyy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 841) | GLM_INLINE glm::vec<4, T, Q> xxyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 847) | GLM_INLINE glm::vec<4, T, Q> xxyz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 852) | GLM_INLINE glm::vec<4, T, Q> xxyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 858) | GLM_INLINE glm::vec<4, T, Q> xxyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 864) | GLM_INLINE glm::vec<4, T, Q> xxzx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 869) | GLM_INLINE glm::vec<4, T, Q> xxzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 875) | GLM_INLINE glm::vec<4, T, Q> xxzy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 880) | GLM_INLINE glm::vec<4, T, Q> xxzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 886) | GLM_INLINE glm::vec<4, T, Q> xxzz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 891) | GLM_INLINE glm::vec<4, T, Q> xxzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 897) | GLM_INLINE glm::vec<4, T, Q> xxzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 903) | GLM_INLINE glm::vec<4, T, Q> xxwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 909) | GLM_INLINE glm::vec<4, T, Q> xxwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 915) | GLM_INLINE glm::vec<4, T, Q> xxwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 921) | GLM_INLINE glm::vec<4, T, Q> xxww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 927) | GLM_INLINE glm::vec<4, T, Q> xyxx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 932) | GLM_INLINE glm::vec<4, T, Q> xyxx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 937) | GLM_INLINE glm::vec<4, T, Q> xyxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 943) | GLM_INLINE glm::vec<4, T, Q> xyxy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 948) | GLM_INLINE glm::vec<4, T, Q> xyxy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 953) | GLM_INLINE glm::vec<4, T, Q> xyxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 959) | GLM_INLINE glm::vec<4, T, Q> xyxz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 964) | GLM_INLINE glm::vec<4, T, Q> xyxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 970) | GLM_INLINE glm::vec<4, T, Q> xyxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 976) | GLM_INLINE glm::vec<4, T, Q> xyyx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 981) | GLM_INLINE glm::vec<4, T, Q> xyyx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 986) | GLM_INLINE glm::vec<4, T, Q> xyyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 992) | GLM_INLINE glm::vec<4, T, Q> xyyy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 997) | GLM_INLINE glm::vec<4, T, Q> xyyy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1002) | GLM_INLINE glm::vec<4, T, Q> xyyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1008) | GLM_INLINE glm::vec<4, T, Q> xyyz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1013) | GLM_INLINE glm::vec<4, T, Q> xyyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1019) | GLM_INLINE glm::vec<4, T, Q> xyyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1025) | GLM_INLINE glm::vec<4, T, Q> xyzx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1030) | GLM_INLINE glm::vec<4, T, Q> xyzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1036) | GLM_INLINE glm::vec<4, T, Q> xyzy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1041) | GLM_INLINE glm::vec<4, T, Q> xyzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1047) | GLM_INLINE glm::vec<4, T, Q> xyzz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1052) | GLM_INLINE glm::vec<4, T, Q> xyzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1058) | GLM_INLINE glm::vec<4, T, Q> xyzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1064) | GLM_INLINE glm::vec<4, T, Q> xywx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1070) | GLM_INLINE glm::vec<4, T, Q> xywy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1076) | GLM_INLINE glm::vec<4, T, Q> xywz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1082) | GLM_INLINE glm::vec<4, T, Q> xyww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1088) | GLM_INLINE glm::vec<4, T, Q> xzxx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1093) | GLM_INLINE glm::vec<4, T, Q> xzxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1099) | GLM_INLINE glm::vec<4, T, Q> xzxy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1104) | GLM_INLINE glm::vec<4, T, Q> xzxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1110) | GLM_INLINE glm::vec<4, T, Q> xzxz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1115) | GLM_INLINE glm::vec<4, T, Q> xzxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1121) | GLM_INLINE glm::vec<4, T, Q> xzxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1127) | GLM_INLINE glm::vec<4, T, Q> xzyx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1132) | GLM_INLINE glm::vec<4, T, Q> xzyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1138) | GLM_INLINE glm::vec<4, T, Q> xzyy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1143) | GLM_INLINE glm::vec<4, T, Q> xzyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1149) | GLM_INLINE glm::vec<4, T, Q> xzyz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1154) | GLM_INLINE glm::vec<4, T, Q> xzyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1160) | GLM_INLINE glm::vec<4, T, Q> xzyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1166) | GLM_INLINE glm::vec<4, T, Q> xzzx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1171) | GLM_INLINE glm::vec<4, T, Q> xzzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1177) | GLM_INLINE glm::vec<4, T, Q> xzzy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1182) | GLM_INLINE glm::vec<4, T, Q> xzzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1188) | GLM_INLINE glm::vec<4, T, Q> xzzz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1193) | GLM_INLINE glm::vec<4, T, Q> xzzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1199) | GLM_INLINE glm::vec<4, T, Q> xzzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1205) | GLM_INLINE glm::vec<4, T, Q> xzwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1211) | GLM_INLINE glm::vec<4, T, Q> xzwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1217) | GLM_INLINE glm::vec<4, T, Q> xzwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1223) | GLM_INLINE glm::vec<4, T, Q> xzww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1229) | GLM_INLINE glm::vec<4, T, Q> xwxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1235) | GLM_INLINE glm::vec<4, T, Q> xwxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1241) | GLM_INLINE glm::vec<4, T, Q> xwxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1247) | GLM_INLINE glm::vec<4, T, Q> xwxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1253) | GLM_INLINE glm::vec<4, T, Q> xwyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1259) | GLM_INLINE glm::vec<4, T, Q> xwyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1265) | GLM_INLINE glm::vec<4, T, Q> xwyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1271) | GLM_INLINE glm::vec<4, T, Q> xwyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1277) | GLM_INLINE glm::vec<4, T, Q> xwzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1283) | GLM_INLINE glm::vec<4, T, Q> xwzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1289) | GLM_INLINE glm::vec<4, T, Q> xwzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1295) | GLM_INLINE glm::vec<4, T, Q> xwzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1301) | GLM_INLINE glm::vec<4, T, Q> xwwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1307) | GLM_INLINE glm::vec<4, T, Q> xwwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1313) | GLM_INLINE glm::vec<4, T, Q> xwwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1319) | GLM_INLINE glm::vec<4, T, Q> xwww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1325) | GLM_INLINE glm::vec<4, T, Q> yxxx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 1330) | GLM_INLINE glm::vec<4, T, Q> yxxx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1335) | GLM_INLINE glm::vec<4, T, Q> yxxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1341) | GLM_INLINE glm::vec<4, T, Q> yxxy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 1346) | GLM_INLINE glm::vec<4, T, Q> yxxy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1351) | GLM_INLINE glm::vec<4, T, Q> yxxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1357) | GLM_INLINE glm::vec<4, T, Q> yxxz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1362) | GLM_INLINE glm::vec<4, T, Q> yxxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1368) | GLM_INLINE glm::vec<4, T, Q> yxxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1374) | GLM_INLINE glm::vec<4, T, Q> yxyx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 1379) | GLM_INLINE glm::vec<4, T, Q> yxyx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1384) | GLM_INLINE glm::vec<4, T, Q> yxyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1390) | GLM_INLINE glm::vec<4, T, Q> yxyy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 1395) | GLM_INLINE glm::vec<4, T, Q> yxyy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1400) | GLM_INLINE glm::vec<4, T, Q> yxyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1406) | GLM_INLINE glm::vec<4, T, Q> yxyz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1411) | GLM_INLINE glm::vec<4, T, Q> yxyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1417) | GLM_INLINE glm::vec<4, T, Q> yxyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1423) | GLM_INLINE glm::vec<4, T, Q> yxzx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1428) | GLM_INLINE glm::vec<4, T, Q> yxzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1434) | GLM_INLINE glm::vec<4, T, Q> yxzy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1439) | GLM_INLINE glm::vec<4, T, Q> yxzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1445) | GLM_INLINE glm::vec<4, T, Q> yxzz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1450) | GLM_INLINE glm::vec<4, T, Q> yxzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1456) | GLM_INLINE glm::vec<4, T, Q> yxzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1462) | GLM_INLINE glm::vec<4, T, Q> yxwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1468) | GLM_INLINE glm::vec<4, T, Q> yxwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1474) | GLM_INLINE glm::vec<4, T, Q> yxwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1480) | GLM_INLINE glm::vec<4, T, Q> yxww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1486) | GLM_INLINE glm::vec<4, T, Q> yyxx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 1491) | GLM_INLINE glm::vec<4, T, Q> yyxx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1496) | GLM_INLINE glm::vec<4, T, Q> yyxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1502) | GLM_INLINE glm::vec<4, T, Q> yyxy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 1507) | GLM_INLINE glm::vec<4, T, Q> yyxy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1512) | GLM_INLINE glm::vec<4, T, Q> yyxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1518) | GLM_INLINE glm::vec<4, T, Q> yyxz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1523) | GLM_INLINE glm::vec<4, T, Q> yyxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1529) | GLM_INLINE glm::vec<4, T, Q> yyxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1535) | GLM_INLINE glm::vec<4, T, Q> yyyx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 1540) | GLM_INLINE glm::vec<4, T, Q> yyyx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1545) | GLM_INLINE glm::vec<4, T, Q> yyyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1551) | GLM_INLINE glm::vec<4, T, Q> yyyy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 1556) | GLM_INLINE glm::vec<4, T, Q> yyyy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1561) | GLM_INLINE glm::vec<4, T, Q> yyyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1567) | GLM_INLINE glm::vec<4, T, Q> yyyz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1572) | GLM_INLINE glm::vec<4, T, Q> yyyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1578) | GLM_INLINE glm::vec<4, T, Q> yyyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1584) | GLM_INLINE glm::vec<4, T, Q> yyzx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1589) | GLM_INLINE glm::vec<4, T, Q> yyzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1595) | GLM_INLINE glm::vec<4, T, Q> yyzy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1600) | GLM_INLINE glm::vec<4, T, Q> yyzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1606) | GLM_INLINE glm::vec<4, T, Q> yyzz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1611) | GLM_INLINE glm::vec<4, T, Q> yyzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1617) | GLM_INLINE glm::vec<4, T, Q> yyzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1623) | GLM_INLINE glm::vec<4, T, Q> yywx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1629) | GLM_INLINE glm::vec<4, T, Q> yywy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1635) | GLM_INLINE glm::vec<4, T, Q> yywz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1641) | GLM_INLINE glm::vec<4, T, Q> yyww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1647) | GLM_INLINE glm::vec<4, T, Q> yzxx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1652) | GLM_INLINE glm::vec<4, T, Q> yzxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1658) | GLM_INLINE glm::vec<4, T, Q> yzxy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1663) | GLM_INLINE glm::vec<4, T, Q> yzxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1669) | GLM_INLINE glm::vec<4, T, Q> yzxz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1674) | GLM_INLINE glm::vec<4, T, Q> yzxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1680) | GLM_INLINE glm::vec<4, T, Q> yzxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1686) | GLM_INLINE glm::vec<4, T, Q> yzyx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1691) | GLM_INLINE glm::vec<4, T, Q> yzyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1697) | GLM_INLINE glm::vec<4, T, Q> yzyy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1702) | GLM_INLINE glm::vec<4, T, Q> yzyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1708) | GLM_INLINE glm::vec<4, T, Q> yzyz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1713) | GLM_INLINE glm::vec<4, T, Q> yzyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1719) | GLM_INLINE glm::vec<4, T, Q> yzyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1725) | GLM_INLINE glm::vec<4, T, Q> yzzx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1730) | GLM_INLINE glm::vec<4, T, Q> yzzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1736) | GLM_INLINE glm::vec<4, T, Q> yzzy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1741) | GLM_INLINE glm::vec<4, T, Q> yzzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1747) | GLM_INLINE glm::vec<4, T, Q> yzzz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1752) | GLM_INLINE glm::vec<4, T, Q> yzzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1758) | GLM_INLINE glm::vec<4, T, Q> yzzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1764) | GLM_INLINE glm::vec<4, T, Q> yzwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1770) | GLM_INLINE glm::vec<4, T, Q> yzwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1776) | GLM_INLINE glm::vec<4, T, Q> yzwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1782) | GLM_INLINE glm::vec<4, T, Q> yzww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1788) | GLM_INLINE glm::vec<4, T, Q> ywxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1794) | GLM_INLINE glm::vec<4, T, Q> ywxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1800) | GLM_INLINE glm::vec<4, T, Q> ywxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1806) | GLM_INLINE glm::vec<4, T, Q> ywxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1812) | GLM_INLINE glm::vec<4, T, Q> ywyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1818) | GLM_INLINE glm::vec<4, T, Q> ywyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1824) | GLM_INLINE glm::vec<4, T, Q> ywyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1830) | GLM_INLINE glm::vec<4, T, Q> ywyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1836) | GLM_INLINE glm::vec<4, T, Q> ywzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1842) | GLM_INLINE glm::vec<4, T, Q> ywzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1848) | GLM_INLINE glm::vec<4, T, Q> ywzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1854) | GLM_INLINE glm::vec<4, T, Q> ywzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1860) | GLM_INLINE glm::vec<4, T, Q> ywwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1866) | GLM_INLINE glm::vec<4, T, Q> ywwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1872) | GLM_INLINE glm::vec<4, T, Q> ywwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1878) | GLM_INLINE glm::vec<4, T, Q> ywww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1884) | GLM_INLINE glm::vec<4, T, Q> zxxx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1889) | GLM_INLINE glm::vec<4, T, Q> zxxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1895) | GLM_INLINE glm::vec<4, T, Q> zxxy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1900) | GLM_INLINE glm::vec<4, T, Q> zxxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1906) | GLM_INLINE glm::vec<4, T, Q> zxxz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1911) | GLM
Copy disabled (too large)
Download .json
Condensed preview — 1718 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (19,682K chars).
[
{
"path": ".gitignore",
"chars": 148,
"preview": "*.pyc\n.vscode\noutput\ndata\nbuild\ninstall\nlog\ndiff_rasterization/diff_rast.egg-info\ndiff_rasterization/dist\ntensorboard_3d"
},
{
"path": ".idea/.gitignore",
"chars": 47,
"preview": "# Default ignored files\n/shelf/\n/workspace.xml\n"
},
{
"path": ".idea/inspectionProfiles/profiles_settings.xml",
"chars": 174,
"preview": "<component name=\"InspectionProjectProfileManager\">\n <settings>\n <option name=\"USE_PROJECT_PROFILE\" value=\"false\" />\n"
},
{
"path": ".idea/misc.xml",
"chars": 294,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project version=\"4\">\n <component name=\"Black\">\n <option name=\"sdkName\" value"
},
{
"path": ".idea/modules.xml",
"chars": 284,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project version=\"4\">\n <component name=\"ProjectModuleManager\">\n <modules>\n "
},
{
"path": ".idea/street_gaussians.iml",
"chars": 584,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<module type=\"PYTHON_MODULE\" version=\"4\">\n <component name=\"NewModuleRootManager"
},
{
"path": ".idea/vcs.xml",
"chars": 167,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project version=\"4\">\n <component name=\"VcsDirectoryMappings\">\n <mapping dire"
},
{
"path": "README.md",
"chars": 10851,
"preview": "# GaussianRPG: 3D Gaussian Rendering PlayGround\n\nThis is an open-source autonomous driving closed-loop simulator demo us"
},
{
"path": "configs/example/waymo_train_002.yaml",
"chars": 1669,
"preview": "task: waymo_full_exp\nsource_path: ./data/waymo/training/002\nexp_name: waymo_train_002\n\ndata:\n split_test: -1\n split_tr"
},
{
"path": "configs/example/waymo_train_002_1cam.yaml",
"chars": 1986,
"preview": "task: waymo_full_exp\nmain_workspace: /home/junchuan/nerf/street_gaussians\nsource_path: /home/junchuan/nerf/street_gaussi"
},
{
"path": "configs/example/waymo_train_031.yaml",
"chars": 1622,
"preview": "task: waymo_full_exp\nsource_path: ./data/waymo/training/031\nexp_name: waymo_train_031\n\ndata:\n split_test: -1\n split_tr"
},
{
"path": "configs/example/waymo_train_124_1cam.yaml",
"chars": 1986,
"preview": "task: waymo_full_exp\nmain_workspace: /home/junchuan/nerf/street_gaussians\nsource_path: /home/junchuan/nerf/street_gaussi"
},
{
"path": "configs/example/waymo_train_149_1cam.yaml",
"chars": 1987,
"preview": "task: waymo_full_exp\nmain_workspace: /home/junchuan/nerf/street_gaussians\nsource_path: /home/junchuan/nerf/street_gaussi"
},
{
"path": "configs/experiments_waymo/waymo_val_006.yaml",
"chars": 1403,
"preview": "task: waymo_exp\nsource_path: ./data/waymo/validation/006\nexp_name: waymo_val_006\n\ndata:\n split_train: -1\n split_test: "
},
{
"path": "configs/experiments_waymo/waymo_val_026.yaml",
"chars": 1497,
"preview": "task: waymo_exp\nsource_path: ./data/waymo/validation/026\nexp_name: waymo_val_026\n\ndata:\n split_train: -1\n split_test: "
},
{
"path": "configs/experiments_waymo/waymo_val_090.yaml",
"chars": 1480,
"preview": "task: waymo_exp\nsource_path: ./data/waymo/validation/090\nexp_name: waymo_val_090\n\ndata:\n split_train: -1\n split_test: "
},
{
"path": "configs/experiments_waymo/waymo_val_105.yaml",
"chars": 1481,
"preview": "task: waymo_exp\nsource_path: ./data/waymo/validation/105\nexp_name: waymo_val_105\n\ndata:\n split_train: -1\n split_test: "
},
{
"path": "configs/experiments_waymo/waymo_val_108.yaml",
"chars": 1553,
"preview": "task: waymo_exp\nsource_path: ./data/waymo/validation/108\nexp_name: waymo_val_108\n\ndata:\n split_train: -1\n split_test: "
},
{
"path": "configs/experiments_waymo/waymo_val_134.yaml",
"chars": 1428,
"preview": "task: waymo_exp\nsource_path: ./data/waymo/validation/134\nexp_name: waymo_val_134\n\ndata:\n split_train: -1\n split_test: "
},
{
"path": "configs/experiments_waymo/waymo_val_150.yaml",
"chars": 1570,
"preview": "task: waymo_exp\nsource_path: ./data/waymo/validation/150\nexp_name: waymo_val_150\n\ndata:\n split_train: -1\n split_test: "
},
{
"path": "configs/experiments_waymo/waymo_val_181.yaml",
"chars": 1406,
"preview": "task: waymo_exp\nsource_path: ./data/waymo/validation/181\nexp_name: waymo_val_181\n\ndata:\n split_train: -1\n split_test: "
},
{
"path": "lib/config/__init__.py",
"chars": 30,
"preview": "from .config import cfg, args\n"
},
{
"path": "lib/config/config.py",
"chars": 5997,
"preview": "from .yacs import CfgNode as CN\nimport argparse\nimport os\nimport numpy as np\n\nfrom lib.utils.cfg_utils import make_cfg\n\n"
},
{
"path": "lib/config/yacs.py",
"chars": 20462,
"preview": "# Copyright (c) 2018-present, Facebook, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you m"
},
{
"path": "lib/datasets/base_readers.py",
"chars": 3322,
"preview": "import numpy as np\nfrom typing import NamedTuple\nfrom lib.utils.graphics_utils import getWorld2View2, focal2fov, fov2foc"
},
{
"path": "lib/datasets/blender_readers.py",
"chars": 3327,
"preview": "import os\nimport numpy as np\nimport json\nfrom PIL import Image\nfrom lib.utils.graphics_utils import getWorld2View2, foca"
},
{
"path": "lib/datasets/colmap_readers.py",
"chars": 4678,
"preview": "import os\nimport sys\nimport numpy as np\nfrom PIL import Image\nfrom lib.utils.graphics_utils import getWorld2View2, focal"
},
{
"path": "lib/datasets/dataset.py",
"chars": 2578,
"preview": "import os\nimport random\nimport json\nfrom lib.utils.camera_utils import camera_to_JSON, cameraList_from_camInfos\nfrom lib"
},
{
"path": "lib/datasets/waymo_full_readers.py",
"chars": 10212,
"preview": "from lib.utils.waymo_utils import generate_dataparser_outputs\nfrom lib.utils.graphics_utils import focal2fov, BasicPoint"
},
{
"path": "lib/models/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "lib/models/actor_pose.py",
"chars": 9135,
"preview": "import torch\nimport torch.nn as nn\nimport numpy as np\nfrom lib.utils.general_utils import quaternion_raw_multiply, get_e"
},
{
"path": "lib/models/camera_pose.py",
"chars": 5534,
"preview": "import torch\nimport torch.nn as nn\nfrom lib.config import cfg\nfrom lib.utils.camera_utils import Camera\nfrom lib.utils.g"
},
{
"path": "lib/models/color_correction.py",
"chars": 5770,
"preview": "import torch\nimport torch.nn as nn\nfrom lib.config import cfg\nfrom lib.utils.camera_utils import Camera\nfrom lib.utils.g"
},
{
"path": "lib/models/gaussian_model.py",
"chars": 26871,
"preview": "import torch\nimport torch.nn as nn\nimport numpy as np\nimport os\nfrom simple_knn._C import distCUDA2\nfrom lib.config impo"
},
{
"path": "lib/models/gaussian_model_actor.py",
"chars": 14024,
"preview": "import torch\nimport torch.nn as nn\nimport numpy as np\nimport os\nfrom lib.config import cfg\nfrom lib.models.gaussian_mode"
},
{
"path": "lib/models/gaussian_model_bkgd.py",
"chars": 4763,
"preview": "import torch\nimport numpy as np\nimport os\nfrom lib.config import cfg\nfrom lib.utils.graphics_utils import BasicPointClou"
},
{
"path": "lib/models/gaussian_model_sky.py",
"chars": 5693,
"preview": "import torch\nimport numpy as np\nimport os\nfrom lib.config import cfg\nfrom lib.utils.graphics_utils import BasicPointClou"
},
{
"path": "lib/models/gaussian_renderer.py",
"chars": 4823,
"preview": "import torch\nimport math\nfrom diff_gaussian_rasterization import GaussianRasterizationSettings, GaussianRasterizer\nfrom "
},
{
"path": "lib/models/network_gui.py",
"chars": 2725,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "lib/models/scene.py",
"chars": 2788,
"preview": "import os\nimport torch\nfrom typing import Union\nfrom lib.datasets.dataset import Dataset\nfrom lib.models.gaussian_model "
},
{
"path": "lib/models/sky_cubemap.py",
"chars": 16043,
"preview": "import torch\nimport torch.nn as nn\nimport numpy as np\nimport imageio\nimport os\nimport cv2\nimport nvdiffrast.torch as dr "
},
{
"path": "lib/models/street_gaussian_model.py",
"chars": 24471,
"preview": "import torch\nimport torch.nn as nn\nimport numpy as np\nimport os\nfrom simple_knn._C import distCUDA2\nfrom lib.config impo"
},
{
"path": "lib/models/street_gaussian_renderer.py",
"chars": 20081,
"preview": "import torch\nfrom lib.utils.sh_utils import eval_sh\nfrom lib.models.street_gaussian_model import StreetGaussianModel\nfro"
},
{
"path": "lib/utils/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "lib/utils/box_utils.py",
"chars": 1980,
"preview": "import numpy as np\nimport cv2\n\ndef get_bound_2d_mask(corners_3d, K, pose, H, W):\n corners_3d = np.dot(corners_3d, pos"
},
{
"path": "lib/utils/camera_utils.py",
"chars": 10079,
"preview": "import numpy as np\nimport torch\nimport copy\nimport torch.nn as nn\nimport cv2\nimport math\nfrom PIL import Image\nfrom tqdm"
},
{
"path": "lib/utils/cfg_utils.py",
"chars": 4257,
"preview": "import os\nimport numpy as np\nfrom lib.config import yacs\n\ndef parse_cfg(cfg, args):\n if len(cfg.task) == 0:\n r"
},
{
"path": "lib/utils/colmap_utils.py",
"chars": 28727,
"preview": "import numpy as np\nimport collections\nimport struct\nimport os\nfrom tqdm import tqdm\n\nCameraModel = collections.namedtupl"
},
{
"path": "lib/utils/data_utils.py",
"chars": 1740,
"preview": "import numpy as np\nimport torch\nimport os\nimport math\nfrom lib.utils.graphics_utils import focal2fov\nfrom lib.datasets.b"
},
{
"path": "lib/utils/general_utils.py",
"chars": 12755,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "lib/utils/graphics_utils.py",
"chars": 6405,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "lib/utils/img_utils.py",
"chars": 8841,
"preview": "import torch\nimport imageio\nfrom matplotlib import cm\nimport matplotlib.pyplot as plt\nimport matplotlib.patches as patch"
},
{
"path": "lib/utils/loss_utils.py",
"chars": 3759,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "lib/utils/lpipsPyTorch/__init__.py",
"chars": 635,
"preview": "import torch\n\nfrom .modules.lpips import LPIPS\n\n\ndef lpips(x: torch.Tensor,\n y: torch.Tensor,\n net_typ"
},
{
"path": "lib/utils/lpipsPyTorch/modules/lpips.py",
"chars": 1151,
"preview": "import torch\nimport torch.nn as nn\n\nfrom .networks import get_network, LinLayers\nfrom .utils import get_state_dict\n\n\ncla"
},
{
"path": "lib/utils/lpipsPyTorch/modules/networks.py",
"chars": 2692,
"preview": "from typing import Sequence\n\nfrom itertools import chain\n\nimport torch\nimport torch.nn as nn\nfrom torchvision import mod"
},
{
"path": "lib/utils/lpipsPyTorch/modules/utils.py",
"chars": 885,
"preview": "from collections import OrderedDict\n\nimport torch\n\n\ndef normalize_activation(x, eps=1e-10):\n norm_factor = torch.sqrt"
},
{
"path": "lib/utils/sem_utils.py",
"chars": 1733,
"preview": "import torch\nimport cv2\nimport numpy as np\nfrom imgviz import label_colormap\nfrom lib.config import cfg\nfrom bidict impo"
},
{
"path": "lib/utils/sh_utils.py",
"chars": 4783,
"preview": "# Copyright 2021 The PlenOctree Authors.\n# Redistribution and use in source and binary forms, with or without\n# modif"
},
{
"path": "lib/utils/system_utils.py",
"chars": 799,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "lib/utils/vq_utils.py",
"chars": 2469,
"preview": "import torch\nfrom torch.autograd import Function\n\nclass VectorQuantization(Function):\n @staticmethod\n def forward("
},
{
"path": "lib/utils/waymo_utils.py",
"chars": 32356,
"preview": "import os\nimport numpy as np\nimport cv2\nimport torch\nimport json\nimport open3d as o3d\nimport math\nfrom glob import glob\n"
},
{
"path": "lib/visualizers/base_visualizer.py",
"chars": 5329,
"preview": "import os\nimport torchvision\nimport cv2\nimport torch\nimport imageio\nimport numpy as np\n\nfrom lib.utils.camera_utils impo"
},
{
"path": "lib/visualizers/street_gaussian_visualizer.py",
"chars": 12059,
"preview": "import os\nimport torchvision\nimport cv2\nimport torch\nimport imageio\nimport numpy as np\n\nfrom lib.utils.camera_utils impo"
},
{
"path": "make_ply.py",
"chars": 3193,
"preview": "import numpy as np\nimport os\nimport shutil\nfrom lib.config import cfg\nfrom lib.models.street_gaussian_model import Stree"
},
{
"path": "metrics.py",
"chars": 3810,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "models/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "models/common.py",
"chars": 17715,
"preview": "# YOLOv5 common modules\n\nimport math\nfrom copy import copy\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as"
},
{
"path": "models/experimental.py",
"chars": 5351,
"preview": "# YOLOv5 experimental modules\n\nimport numpy as np\nimport torch\nimport torch.nn as nn\n\nfrom models.common import Conv, DW"
},
{
"path": "models/export.py",
"chars": 7918,
"preview": "\"\"\"Export a YOLOv5 *.pt model to TorchScript, ONNX, CoreML formats\n\nUsage:\n $ python path/to/models/export.py --weigh"
},
{
"path": "models/hub/anchors.yaml",
"chars": 3356,
"preview": "# Default YOLOv5 anchors for COCO data\n\n\n# P5 --------------------------------------------------------------------------"
},
{
"path": "models/hub/yolov3-spp.yaml",
"chars": 1531,
"preview": "# parameters\nnc: 80 # number of classes\ndepth_multiple: 1.0 # model depth multiple\nwidth_multiple: 1.0 # layer channe"
},
{
"path": "models/hub/yolov3-tiny.yaml",
"chars": 1196,
"preview": "# parameters\nnc: 80 # number of classes\ndepth_multiple: 1.0 # model depth multiple\nwidth_multiple: 1.0 # layer channe"
},
{
"path": "models/hub/yolov3.yaml",
"chars": 1524,
"preview": "# parameters\nnc: 80 # number of classes\ndepth_multiple: 1.0 # model depth multiple\nwidth_multiple: 1.0 # layer channe"
},
{
"path": "models/hub/yolov5-fpn.yaml",
"chars": 1245,
"preview": "# parameters\nnc: 80 # number of classes\ndepth_multiple: 1.0 # model depth multiple\nwidth_multiple: 1.0 # layer channe"
},
{
"path": "models/hub/yolov5-p2.yaml",
"chars": 1738,
"preview": "# parameters\nnc: 80 # number of classes\ndepth_multiple: 1.0 # model depth multiple\nwidth_multiple: 1.0 # layer channe"
},
{
"path": "models/hub/yolov5-p6.yaml",
"chars": 1809,
"preview": "# parameters\nnc: 80 # number of classes\ndepth_multiple: 1.0 # model depth multiple\nwidth_multiple: 1.0 # layer channe"
},
{
"path": "models/hub/yolov5-p7.yaml",
"chars": 2232,
"preview": "# parameters\nnc: 80 # number of classes\ndepth_multiple: 1.0 # model depth multiple\nwidth_multiple: 1.0 # layer channe"
},
{
"path": "models/hub/yolov5-panet.yaml",
"chars": 1459,
"preview": "# parameters\nnc: 80 # number of classes\ndepth_multiple: 1.0 # model depth multiple\nwidth_multiple: 1.0 # layer channe"
},
{
"path": "models/hub/yolov5l6.yaml",
"chars": 1977,
"preview": "# parameters\nnc: 80 # number of classes\ndepth_multiple: 1.0 # model depth multiple\nwidth_multiple: 1.0 # layer channe"
},
{
"path": "models/hub/yolov5m6.yaml",
"chars": 1979,
"preview": "# parameters\nnc: 80 # number of classes\ndepth_multiple: 0.67 # model depth multiple\nwidth_multiple: 0.75 # layer chan"
},
{
"path": "models/hub/yolov5s-transformer.yaml",
"chars": 1406,
"preview": "# parameters\nnc: 80 # number of classes\ndepth_multiple: 0.33 # model depth multiple\nwidth_multiple: 0.50 # layer chan"
},
{
"path": "models/hub/yolov5s6.yaml",
"chars": 1979,
"preview": "# parameters\nnc: 80 # number of classes\ndepth_multiple: 0.33 # model depth multiple\nwidth_multiple: 0.50 # layer chan"
},
{
"path": "models/hub/yolov5x6.yaml",
"chars": 1979,
"preview": "# parameters\nnc: 80 # number of classes\ndepth_multiple: 1.33 # model depth multiple\nwidth_multiple: 1.25 # layer chan"
},
{
"path": "models/yolo.py",
"chars": 13682,
"preview": "\"\"\"YOLOv5-specific modules\n\nUsage:\n $ python path/to/models/yolo.py --cfg yolov5s.yaml\n\"\"\"\n\nimport argparse\nimport lo"
},
{
"path": "models/yolov5l.yaml",
"chars": 1365,
"preview": "# parameters\nnc: 80 # number of classes\ndepth_multiple: 1.0 # model depth multiple\nwidth_multiple: 1.0 # layer channe"
},
{
"path": "models/yolov5m.yaml",
"chars": 1367,
"preview": "# parameters\nnc: 80 # number of classes\ndepth_multiple: 0.67 # model depth multiple\nwidth_multiple: 0.75 # layer chan"
},
{
"path": "models/yolov5s.yaml",
"chars": 1367,
"preview": "# parameters\nnc: 80 # number of classes\ndepth_multiple: 0.33 # model depth multiple\nwidth_multiple: 0.50 # layer chan"
},
{
"path": "models/yolov5x.yaml",
"chars": 1367,
"preview": "# parameters\nnc: 80 # number of classes\ndepth_multiple: 1.33 # model depth multiple\nwidth_multiple: 1.25 # layer chan"
},
{
"path": "networks/__init__.py",
"chars": 150,
"preview": "from .resnet_encoder import ResnetEncoder\nfrom .depth_decoder import DepthDecoder\nfrom .pose_decoder import PoseDecoder\n"
},
{
"path": "networks/depth_decoder.py",
"chars": 2218,
"preview": "# Copyright Niantic 2019. Patent Pending. All rights reserved.\n#\n# This software is licensed under the terms of the Mono"
},
{
"path": "networks/pose_cnn.py",
"chars": 1509,
"preview": "# Copyright Niantic 2019. Patent Pending. All rights reserved.\n#\n# This software is licensed under the terms of the Mono"
},
{
"path": "networks/pose_decoder.py",
"chars": 1875,
"preview": "# Copyright Niantic 2019. Patent Pending. All rights reserved.\n#\n# This software is licensed under the terms of the Mono"
},
{
"path": "networks/resnet_encoder.py",
"chars": 4046,
"preview": "# Copyright Niantic 2019. Patent Pending. All rights reserved.\n#\n# This software is licensed under the terms of the Mono"
},
{
"path": "nodes/rviz2/gaussian_rpg.rviz",
"chars": 5796,
"preview": "Panels:\n - Class: rviz_common/Displays\n Help Height: 0\n Name: Displays\n Property Tree Widget:\n Expanded:\n"
},
{
"path": "nodes/scripts/simulator_launch.sh",
"chars": 1085,
"preview": "#!/bin/bash\nCC=/usr/bin/gcc\nCXX=/usr/bin/g++\n\n# Setup the paths\nrelative_path=$0\nabsolute_path=$(readlink -f \"$relative_"
},
{
"path": "nodes/scripts/simulator_launch_hil.sh",
"chars": 1553,
"preview": "#!/bin/bash\nCC=/usr/bin/gcc\nCXX=/usr/bin/g++\nexport QT_QPA_PLATFORM_PLUGIN_PATH=/usr/lib/x86_64-linux-gnu/qt5/plugins\n\n#"
},
{
"path": "nodes/scripts/simulator_launch_separate.sh",
"chars": 1187,
"preview": "#!/bin/bash\nCC=/usr/bin/gcc\nCXX=/usr/bin/g++\n\n# Setup the paths\nrelative_path=$0\nabsolute_path=$(readlink -f \"$relative_"
},
{
"path": "nodes/src/dummy_controllers/LICENSE",
"chars": 11358,
"preview": "\n Apache License\n Version 2.0, January 2004\n "
},
{
"path": "nodes/src/dummy_controllers/dummy_controllers/AEB_controller.py",
"chars": 4314,
"preview": "# Copyright 2016 Open Source Robotics Foundation, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\""
},
{
"path": "nodes/src/dummy_controllers/dummy_controllers/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "nodes/src/dummy_controllers/dummy_controllers/object_detector.py",
"chars": 10086,
"preview": "# Copyright 2016 Open Source Robotics Foundation, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\""
},
{
"path": "nodes/src/dummy_controllers/package.xml",
"chars": 841,
"preview": "<?xml version=\"1.0\"?>\n<?xml-model href=\"http://download.ros.org/schema/package_format3.xsd\" schematypens=\"http://www.w3."
},
{
"path": "nodes/src/dummy_controllers/resource/dummy_controllers",
"chars": 0,
"preview": ""
},
{
"path": "nodes/src/dummy_controllers/setup.cfg",
"chars": 103,
"preview": "[develop]\nscript_dir=$base/lib/dummy_controllers\n[install]\ninstall_scripts=$base/lib/dummy_controllers\n"
},
{
"path": "nodes/src/dummy_controllers/setup.py",
"chars": 803,
"preview": "from setuptools import find_packages, setup\n\npackage_name = 'dummy_controllers'\n\nsetup(\n name=package_name,\n versi"
},
{
"path": "nodes/src/dummy_controllers/test/test_copyright.py",
"chars": 962,
"preview": "# Copyright 2015 Open Source Robotics Foundation, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\""
},
{
"path": "nodes/src/dummy_controllers/test/test_flake8.py",
"chars": 884,
"preview": "# Copyright 2017 Open Source Robotics Foundation, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\""
},
{
"path": "nodes/src/dummy_controllers/test/test_pep257.py",
"chars": 803,
"preview": "# Copyright 2015 Open Source Robotics Foundation, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\""
},
{
"path": "nodes/src/simulator/LICENSE",
"chars": 11358,
"preview": "\n Apache License\n Version 2.0, January 2004\n "
},
{
"path": "nodes/src/simulator/package.xml",
"chars": 817,
"preview": "<?xml version=\"1.0\"?>\n<?xml-model href=\"http://download.ros.org/schema/package_format3.xsd\" schematypens=\"http://www.w3."
},
{
"path": "nodes/src/simulator/resource/simulator",
"chars": 0,
"preview": ""
},
{
"path": "nodes/src/simulator/setup.cfg",
"chars": 87,
"preview": "[develop]\nscript_dir=$base/lib/simulator\n[install]\ninstall_scripts=$base/lib/simulator\n"
},
{
"path": "nodes/src/simulator/setup.py",
"chars": 860,
"preview": "from setuptools import find_packages, setup\n\npackage_name = 'simulator'\n\nsetup(\n name=package_name,\n version='0.0."
},
{
"path": "nodes/src/simulator/simulator/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "nodes/src/simulator/simulator/evaluation.py",
"chars": 2363,
"preview": "# Copyright 2016 Open Source Robotics Foundation, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\""
},
{
"path": "nodes/src/simulator/simulator/groundtruth.py",
"chars": 5446,
"preview": "# Copyright 2016 Open Source Robotics Foundation, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\""
},
{
"path": "nodes/src/simulator/simulator/simulator.py",
"chars": 19906,
"preview": "# Copyright 2016 Open Source Robotics Foundation, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\""
},
{
"path": "nodes/src/simulator/simulator/simulator_hil.py",
"chars": 11633,
"preview": "# Copyright 2016 Open Source Robotics Foundation, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\""
},
{
"path": "nodes/src/simulator/test/test_copyright.py",
"chars": 962,
"preview": "# Copyright 2015 Open Source Robotics Foundation, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\""
},
{
"path": "nodes/src/simulator/test/test_flake8.py",
"chars": 884,
"preview": "# Copyright 2017 Open Source Robotics Foundation, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\""
},
{
"path": "nodes/src/simulator/test/test_pep257.py",
"chars": 803,
"preview": "# Copyright 2015 Open Source Robotics Foundation, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\""
},
{
"path": "on_board/nodes/src/dummy_controllers/LICENSE",
"chars": 11358,
"preview": "\n Apache License\n Version 2.0, January 2004\n "
},
{
"path": "on_board/nodes/src/dummy_controllers/dummy_controllers/AEB_controller.py",
"chars": 4468,
"preview": "# Copyright 2016 Open Source Robotics Foundation, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\""
},
{
"path": "on_board/nodes/src/dummy_controllers/dummy_controllers/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "on_board/nodes/src/dummy_controllers/dummy_controllers/object_detector.py",
"chars": 14147,
"preview": "# Copyright 2016 Open Source Robotics Foundation, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\""
},
{
"path": "on_board/nodes/src/dummy_controllers/dummy_controllers/test_yolov5.py",
"chars": 6330,
"preview": "#!/usr/bin/env python3\n\nimport numpy as np\nimport cv2\nfrom hobot_dnn import pyeasy_dnn as dnn\nimport time\nimport ctypes\n"
},
{
"path": "on_board/nodes/src/dummy_controllers/package.xml",
"chars": 841,
"preview": "<?xml version=\"1.0\"?>\n<?xml-model href=\"http://download.ros.org/schema/package_format3.xsd\" schematypens=\"http://www.w3."
},
{
"path": "on_board/nodes/src/dummy_controllers/resource/dummy_controllers",
"chars": 0,
"preview": ""
},
{
"path": "on_board/nodes/src/dummy_controllers/setup.cfg",
"chars": 103,
"preview": "[develop]\nscript_dir=$base/lib/dummy_controllers\n[install]\ninstall_scripts=$base/lib/dummy_controllers\n"
},
{
"path": "on_board/nodes/src/dummy_controllers/setup.py",
"chars": 803,
"preview": "from setuptools import find_packages, setup\n\npackage_name = 'dummy_controllers'\n\nsetup(\n name=package_name,\n versi"
},
{
"path": "on_board/nodes/src/dummy_controllers/test/test_copyright.py",
"chars": 962,
"preview": "# Copyright 2015 Open Source Robotics Foundation, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\""
},
{
"path": "on_board/nodes/src/dummy_controllers/test/test_flake8.py",
"chars": 884,
"preview": "# Copyright 2017 Open Source Robotics Foundation, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\""
},
{
"path": "on_board/nodes/src/dummy_controllers/test/test_pep257.py",
"chars": 803,
"preview": "# Copyright 2015 Open Source Robotics Foundation, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\""
},
{
"path": "render.py",
"chars": 3626,
"preview": "import torch \nimport os\nimport json\nfrom tqdm import tqdm\nfrom lib.models.street_gaussian_model import StreetGaussianMod"
},
{
"path": "render_lite.py",
"chars": 10460,
"preview": "import torch \nimport os\nimport json\nfrom tqdm import tqdm\nimport numpy as np\nfrom lib.models.street_gaussian_model impor"
},
{
"path": "requirements.txt",
"chars": 263,
"preview": "pyyaml\ntqdm\nopencv-python\nimgaug\nlpips\nplyfile\ntensorboard\nsympy\nnumpy==1.23.5\npillow\nmatplotlib\nbidict\nipdb\nimageio\nima"
},
{
"path": "script/convert.py",
"chars": 5349,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "script/kitti/colmap_kitti.py",
"chars": 7343,
"preview": "import numpy as np\nimport os\nimport shutil\nimport sqlite3\nimport glob\nimport cv2\nimport sys\nsys.path.append(os.getcwd())"
},
{
"path": "script/kitti/generate_dynamic_mask.py",
"chars": 2460,
"preview": "import cv2\nimport os\nimport numpy as np\nimport argparse\nimport glob\n\nparsers = argparse.ArgumentParser(description=\"KITT"
},
{
"path": "script/kitti/generate_semantic_mask.py",
"chars": 2102,
"preview": "import imageio\nimport os\nimport numpy as np\nimport argparse\nimport glob\n\nparsers = argparse.ArgumentParser(description=\""
},
{
"path": "script/kitti/generate_sky_mask.py",
"chars": 2409,
"preview": "import cv2\nimport os\nimport numpy as np\nimport argparse\nimport glob\n\nparsers = argparse.ArgumentParser(description=\"KITT"
},
{
"path": "script/render_waymo_example.sh",
"chars": 155,
"preview": "#!/bin/bash\nscenes=(\"031\" \"002\")\nfor scene in \"${scenes[@]}\"; do\n python render.py --config configs/example/waymo_trai"
},
{
"path": "script/render_waymo_exp.sh",
"chars": 294,
"preview": "#!/bin/bash\nscenes=(\"006\" \"026\" \"090\" \"105\" \"108\" \"134\" \"150\" \"181\") \nfor scene in \"${scenes[@]}\"; do\n python render"
},
{
"path": "script/test_gaussian_rasterization.py",
"chars": 3197,
"preview": "import math\nimport torch\nimport time\nfrom diff_gaussian_rasterization import GaussianRasterizationSettings, GaussianRast"
},
{
"path": "script/train_waymo_example.sh",
"chars": 156,
"preview": "#!/bin/bash\n# scenes=(\"031\" \"002\")\nscenes=(\"031\")\nfor scene in \"${scenes[@]}\"; do\n python train.py --config configs/e"
},
{
"path": "script/train_waymo_exp.sh",
"chars": 185,
"preview": "#!/bin/bash\nscenes=(\"006\" \"026\" \"090\" \"105\" \"108\" \"134\" \"150\" \"181\") \nfor scene in \"${scenes[@]}\"; do\n python train."
},
{
"path": "script/waymo/colmap_waymo_full.py",
"chars": 11171,
"preview": "import sqlite3\nimport os\nimport numpy as np\nimport glob\nimport os\nimport cv2\nimport shutil\nimport sys\nsys.path.append(os"
},
{
"path": "script/waymo/generate_lidar_depth.py",
"chars": 4485,
"preview": "import sys\nimport os\nsys.path.append(os.getcwd())\nimport argparse\nimport numpy as np\nimport cv2\nfrom glob import glob\nfr"
},
{
"path": "script/waymo/generate_mono_depth.py",
"chars": 3019,
"preview": "import torch\nimport argparse\nimport os\nimport sys\nimport imageio\nimport numpy as np\nsys.path.append(os.getcwd())\nfrom gl"
},
{
"path": "script/waymo/generate_mono_normal.py",
"chars": 409,
"preview": "import os\nimport argparse\n\n#TODO: try other normal estimation models (GeoWizard etc.)\n\nif __name__ == \"__main__\":\n pa"
},
{
"path": "script/waymo/generate_sky_mask.py",
"chars": 7275,
"preview": "import os, sys\n\nsys.path.append(os.getcwd())\nimport argparse\nimport os\nimport copy\nimport imageio\nimport numpy as np\nimp"
},
{
"path": "script/waymo/waymo_converter.py",
"chars": 25600,
"preview": "import sys\nimport os\nsys.path.append(os.getcwd())\nimport torch\nimport numpy as np\nimport cv2\nimport math\nimport imageio\n"
},
{
"path": "script/waymo/waymo_splits/demo.txt",
"chars": 142,
"preview": "# scene_id, seg_name, start_timestep, end_timestep, scene_type\n31,seg105887,0,-1,dynamic\n2,seg100508,0,-1,high-speed\n36,"
},
{
"path": "script/waymo/waymo_splits/more_examples.txt",
"chars": 146,
"preview": "# scene_id, seg_name, start_timestep, end_timestep, scene_type\n124,seg128560,0,-1,dynamic\n147,seg132079,0,-1,dusk/dawn\n1"
},
{
"path": "script/waymo/waymo_splits/segment_list_train.txt",
"chars": 51801,
"preview": "segment-10017090168044687777_6380_000_6400_000_with_camera_labels\nsegment-10023947602400723454_1120_000_1140_000_with_ca"
},
{
"path": "script/waymo/waymo_splits/segment_list_val.txt",
"chars": 13117,
"preview": "segment-10203656353524179475_7625_000_7645_000_with_camera_labels\nsegment-1024360143612057520_3580_000_3600_000_with_cam"
},
{
"path": "script/waymo/waymo_splits/train_diverse.txt",
"chars": 1685,
"preview": "# scene_id, seg_name, start_timestep, end_timestep, scene_type\n1,seg100239,0,-1,ego-static\n23,seg104554,0,-1,ego-static\n"
},
{
"path": "script/waymo/waymo_splits/train_dynamic.txt",
"chars": 911,
"preview": "# scene_id, seg_name, start_timestep, end_timestep, scene_type\n16,seg102319,0,-1,dynamic\n21,seg103913,0,-1,dynamic\n22,se"
},
{
"path": "script/waymo/waymo_splits/train_static.txt",
"chars": 898,
"preview": "# scene_id, seg_name, start_timestep, end_timestep, scene_type\n3,seg100613,0,163,static\n19,seg102751,0,-1,static\n36,seg1"
},
{
"path": "script/waymo/waymo_splits/val_dynamic.txt",
"chars": 274,
"preview": "# scene_id, seg_name, start_timestep, end_timestep, scene_type\n6,seg104481,0,-1,dynamic\n26,seg123746,0,-1,dynamic\n90,seg"
},
{
"path": "submodules/diff-gaussian-rasterization/.gitignore",
"chars": 69,
"preview": "build/\ndiff_gaussian_rasterization.egg-info/\ndist/\n\n__pycache__\n\n*.so"
},
{
"path": "submodules/diff-gaussian-rasterization/.gitmodules",
"chars": 95,
"preview": "[submodule \"third_party/glm\"]\n\tpath = third_party/glm\n\turl = https://github.com/g-truc/glm.git\n"
},
{
"path": "submodules/diff-gaussian-rasterization/CMakeLists.txt",
"chars": 1043,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "submodules/diff-gaussian-rasterization/LICENSE.md",
"chars": 4275,
"preview": "Gaussian-Splatting License \n=========================== \n\n**Inria** and **the Max Planck Institut for Informatik (MPII"
},
{
"path": "submodules/diff-gaussian-rasterization/README.md",
"chars": 1346,
"preview": "# Differential Gaussian Rasterization\n\n**NOTE**: this is a modified version to support depth & alpha rendering (both for"
},
{
"path": "submodules/diff-gaussian-rasterization/cuda_rasterizer/auxiliary.h",
"chars": 5499,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization/cuda_rasterizer/backward.cu",
"chars": 27642,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization/cuda_rasterizer/backward.h",
"chars": 1716,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization/cuda_rasterizer/config.h",
"chars": 543,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization/cuda_rasterizer/forward.cu",
"chars": 17693,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization/cuda_rasterizer/forward.h",
"chars": 2100,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization/cuda_rasterizer/rasterizer.h",
"chars": 2886,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization/cuda_rasterizer/rasterizer_impl.cu",
"chars": 14119,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization/cuda_rasterizer/rasterizer_impl.h",
"chars": 1574,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization/diff_gaussian_rasterization/__init__.py",
"chars": 8844,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "submodules/diff-gaussian-rasterization/ext.cpp",
"chars": 641,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization/rasterize_points.cu",
"chars": 10140,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization/rasterize_points.h",
"chars": 2684,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization/setup.py",
"chars": 1199,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "submodules/diff-gaussian-rasterization/third_party/glm/.appveyor.yml",
"chars": 3257,
"preview": "shallow_clone: true\n\nplatform:\n - x86\n - x64\n\nconfiguration:\n - Debug\n - Release\n\nimage:\n - Visual Studio 2013\n - "
},
{
"path": "submodules/diff-gaussian-rasterization/third_party/glm/.gitignore",
"chars": 604,
"preview": "# Compiled Object files\n*.slo\n*.lo\n*.o\n*.obj\n\n# Precompiled Headers\n*.gch\n*.pch\n\n# Compiled Dynamic libraries\n*.so\n*.dyl"
},
{
"path": "submodules/diff-gaussian-rasterization/third_party/glm/.travis.yml",
"chars": 13878,
"preview": "language: cpp\n\nbranches:\n only:\n - master\n - stable\n\njobs:\n include:\n - name: \"Xcode 7.3 C++98 pure release\"\n"
},
{
"path": "submodules/diff-gaussian-rasterization/third_party/glm/CMakeLists.txt",
"chars": 1809,
"preview": "cmake_minimum_required(VERSION 3.2 FATAL_ERROR)\ncmake_policy(VERSION 3.2)\n\n\nfile(READ \"glm/detail/setup.hpp\" GLM_SETUP_F"
},
{
"path": "submodules/diff-gaussian-rasterization/third_party/glm/cmake/cmake_uninstall.cmake.in",
"chars": 852,
"preview": "if(NOT EXISTS \"@CMAKE_BINARY_DIR@/install_manifest.txt\")\n message(FATAL_ERROR \"Cannot find install manifest: @CMAKE_BIN"
},
{
"path": "submodules/diff-gaussian-rasterization/third_party/glm/copying.txt",
"chars": 2865,
"preview": "================================================================================\nOpenGL Mathematics (GLM)\n--------------"
},
{
"path": "submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00001_source.html",
"chars": 59169,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00002_source.html",
"chars": 7003,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00003_source.html",
"chars": 17423,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00004_source.html",
"chars": 158134,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00005_source.html",
"chars": 123923,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00006_source.html",
"chars": 31163,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00007.html",
"chars": 26643,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00007_source.html",
"chars": 30822,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00008.html",
"chars": 12465,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00008_source.html",
"chars": 14301,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00009.html",
"chars": 28311,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00009_source.html",
"chars": 27455,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00010.html",
"chars": 7102,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00010_source.html",
"chars": 9819,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
}
]
// ... and 1518 more files (download for full content)
About this extraction
This page contains the full source code of the GimpelZhang/GaussianRPG GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1718 files (31.7 MB), approximately 4.7M tokens, and a symbol index with 3840 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.