SYMBOL INDEX (367 symbols across 57 files)

FILE: extern/chamfer3D/chamfer_cuda.cpp
  function chamfer_forward (line 25) | int chamfer_forward(at::Tensor xyz1,
  function chamfer_backward (line 34) | int chamfer_backward(at::Tensor xyz1,
  function PYBIND11_MODULE (line 46) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: extern/chamfer3D/dist_chamfer_3D.py
  class chamfer_3DFunction (line 41) | class chamfer_3DFunction(Function):
    method forward (line 43) | def forward(ctx, xyz1, xyz2):
    method backward (line 73) | def backward(ctx, graddist1, graddist2, gradidx1, gradidx2):
  class chamfer_3DDist (line 90) | class chamfer_3DDist(nn.Module):
    method __init__ (line 91) | def __init__(self):
    method forward (line 94) | def forward(self, input1, input2):

FILE: extern/fscore.py
  function fscore (line 4) | def fscore(dist1, dist2, threshold=0.001):

FILE: lidarnerf/activation.py
  class _trunc_exp (line 6) | class _trunc_exp(Function):
    method forward (line 9) | def forward(ctx, x):
    method backward (line 15) | def backward(ctx, g):

FILE: lidarnerf/convert.py
  function lidar_to_pano_with_intensities_with_bbox_mask (line 4) | def lidar_to_pano_with_intensities_with_bbox_mask(
  function lidar_to_pano_with_intensities (line 99) | def lidar_to_pano_with_intensities(
  function lidar_to_pano (line 163) | def lidar_to_pano(
  function pano_to_lidar_with_intensities (line 194) | def pano_to_lidar_with_intensities(pano: np.ndarray, intensities, lidar_K):
  function pano_to_lidar (line 236) | def pano_to_lidar(pano, lidar_K):
  function lidar_to_pano_with_intensities_fpa (line 253) | def lidar_to_pano_with_intensities_fpa(
  function parse_z_buffer (line 331) | def parse_z_buffer(novel_pano, lidar_H, lidar_W, threshold=0.2):

FILE: lidarnerf/dataset/base_dataset.py
  function custom_meshgrid (line 8) | def custom_meshgrid(*args):
  function get_lidar_rays (line 16) | def get_lidar_rays(poses, intrinsics, H, W, N=-1, patch_size=1):
  function get_rays (line 109) | def get_rays(poses, intrinsics, H, W, N=-1, patch_size=1):
  function nerf_matrix_to_ngp (line 186) | def nerf_matrix_to_ngp(pose, scale=0.33, offset=[0, 0, 0]):
  function visualize_poses (line 200) | def visualize_poses(poses, size=0.1):
  class BaseDataset (line 240) | class BaseDataset:

FILE: lidarnerf/dataset/kitti360_dataset.py
  class KITTI360Dataset (line 14) | class KITTI360Dataset(BaseDataset):
    method __post_init__ (line 32) | def __post_init__(self):
    method collate (line 123) | def collate(self, index):
    method dataloader (line 161) | def dataloader(self):
    method __len__ (line 174) | def __len__(self):

FILE: lidarnerf/dataset/nerfmvl_dataset.py
  class NeRFMVLDataset (line 14) | class NeRFMVLDataset(BaseDataset):
    method __post_init__ (line 32) | def __post_init__(self):
    method collate (line 116) | def collate(self, index):
    method dataloader (line 174) | def dataloader(self):
    method __len__ (line 187) | def __len__(self):

FILE: lidarnerf/encoding.py
  class FreqEncoder (line 6) | class FreqEncoder(nn.Module):
    method __init__ (line 7) | def __init__(
    method forward (line 35) | def forward(self, input, **kwargs):
  function get_encoder (line 50) | def get_encoder(
  class PeriodicVolumeEncoding (line 123) | class PeriodicVolumeEncoding(nn.Module):
    method __init__ (line 136) | def __init__(
    method parameters (line 174) | def parameters(self):
    method get_out_dim (line 177) | def get_out_dim(self) -> int:
    method hash_fn (line 180) | def hash_fn(self, in_tensor):
    method pytorch_fwd (line 201) | def pytorch_fwd(self, in_tensor):
    method forward (line 275) | def forward(self, in_tensor):
    method get_total_variation_loss (line 278) | def get_total_variation_loss(self):

FILE: lidarnerf/ffmlp/backend.py
  function find_cl_path (line 27) | def find_cl_path():

FILE: lidarnerf/ffmlp/ffmlp.py
  class _ffmlp_forward (line 14) | class _ffmlp_forward(Function):
    method forward (line 17) | def forward(
    method backward (line 96) | def backward(ctx, grad):
  function convert_activation (line 170) | def convert_activation(act):
  class FFMLP (line 187) | class FFMLP(nn.Module):
    method __init__ (line 188) | def __init__(
    method cleanup (line 235) | def cleanup(self):
    method __repr__ (line 239) | def __repr__(self):
    method reset_parameters (line 242) | def reset_parameters(self):
    method forward (line 247) | def forward(self, inputs):

FILE: lidarnerf/ffmlp/setup.py
  function find_cl_path (line 28) | def find_cl_path():

FILE: lidarnerf/ffmlp/src/bindings.cpp
  function PYBIND11_MODULE (line 5) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: lidarnerf/ffmlp/src/cutlass_matmul.h
  type Params (line 169) | struct Params {
  function CUTLASS_HOST_DEVICE (line 183) | CUTLASS_HOST_DEVICE
  function CUTLASS_HOST_DEVICE (line 186) | CUTLASS_HOST_DEVICE
  function CUTLASS_HOST_DEVICE (line 203) | CUTLASS_HOST_DEVICE
  type Params (line 258) | struct Params {
  function CUTLASS_HOST_DEVICE (line 274) | CUTLASS_HOST_DEVICE
  function CUTLASS_HOST_DEVICE (line 277) | CUTLASS_HOST_DEVICE
  function CUTLASS_HOST_DEVICE (line 301) | CUTLASS_HOST_DEVICE
  function cutlass_free_workspace (line 424) | inline void cutlass_free_workspace(cudaStream_t stream) {
  function typename (line 520) | typename Gemm::Arguments arguments{{M, N, K},

FILE: lidarnerf/ffmlp/src/utils.h
  function Activation (line 38) | enum class Activation {
  function enlarge (line 232) | void enlarge(const size_t size) {
  function memset (line 262) | void memset(const int value) { memset(value, m_size); }
  function copy_from_host (line 269) | void copy_from_host(const T *host_data, const size_t num_elements) {
  function copy_from_host (line 281) | void copy_from_host(const std::vector<T> &data, const size_t num_element...
  function copy_from_host (line 293) | void copy_from_host(const T *data) { copy_from_host(data, m_size); }
  function enlarge_and_copy_from_host (line 297) | void enlarge_and_copy_from_host(const T *data, const size_t num_elements) {
  function enlarge_and_copy_from_host (line 304) | void enlarge_and_copy_from_host(const std::vector<T> &data,
  function enlarge_and_copy_from_host (line 311) | void enlarge_and_copy_from_host(const std::vector<T> &data) {
  function resize_and_copy_from_host (line 317) | void resize_and_copy_from_host(const T *data, const size_t num_elements) {
  function resize_and_copy_from_host (line 323) | void resize_and_copy_from_host(const std::vector<T> &data,
  function resize_and_copy_from_host (line 329) | void resize_and_copy_from_host(const std::vector<T> &data) {
  function copy_from_host (line 335) | void copy_from_host(const std::vector<T> &data) {
  function copy_to_host (line 347) | void copy_to_host(T *host_data, const size_t num_elements) const {
  function copy_to_host (line 366) | void copy_to_host(std::vector<T> &data, const size_t num_elements) const {
  function copy_to_host (line 378) | void copy_to_host(T *data) const { copy_to_host(data, m_size); }
  function copy_to_host (line 381) | void copy_to_host(std::vector<T> &data) const {
  function copy_from_device (line 393) | void copy_from_device(const GPUMemory<T> &other) {
  function copy_from_device (line 410) | void copy_from_device(const GPUMemory<T> &other, const size_t size) {
  function T (line 431) | T *data() const {
  function std (line 463) | inline std::string bytes_to_string(size_t bytes) {
  function warp_activation (line 480) | void warp_activation(Activation activation,
  function warp_activation_backward_in (line 542) | void warp_activation_backward_in(
  function warp_activation_backward (line 610) | void warp_activation_backward(

FILE: lidarnerf/freqencoder/backend.py
  function find_cl_path (line 21) | def find_cl_path():

FILE: lidarnerf/freqencoder/freq.py
  class _freq_encoder (line 12) | class _freq_encoder(Function):
    method forward (line 15) | def forward(ctx, inputs, degree, output_dim):
    method backward (line 37) | def backward(ctx, grad):
  class FreqEncoder (line 55) | class FreqEncoder(nn.Module):
    method __init__ (line 56) | def __init__(self, input_dim=3, degree=4):
    method __repr__ (line 63) | def __repr__(self):
    method forward (line 66) | def forward(self, inputs, **kwargs):

FILE: lidarnerf/freqencoder/setup.py
  function find_cl_path (line 22) | def find_cl_path():

FILE: lidarnerf/freqencoder/src/bindings.cpp
  function PYBIND11_MODULE (line 5) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: lidarnerf/gridencoder/backend.py
  function find_cl_path (line 20) | def find_cl_path():

FILE: lidarnerf/gridencoder/grid.py
  class _grid_encode (line 24) | class _grid_encode(Function):
    method forward (line 27) | def forward(
    method backward (line 98) | def backward(ctx, grad):
  class GridEncoder (line 141) | class GridEncoder(nn.Module):
    method __init__ (line 142) | def __init__(
    method reset_parameters (line 202) | def reset_parameters(self):
    method __repr__ (line 206) | def __repr__(self):
    method forward (line 209) | def forward(self, inputs, bound=1):
    method grad_total_variation (line 239) | def grad_total_variation(self, weight=1e-7, inputs=None, bound=1, B=10...

FILE: lidarnerf/gridencoder/setup.py
  function find_cl_path (line 21) | def find_cl_path():

FILE: lidarnerf/gridencoder/src/bindings.cpp
  function PYBIND11_MODULE (line 5) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: lidarnerf/loss.py
  function mape_loss (line 6) | def mape_loss(pred, target, reduction="mean"):
  function huber_loss (line 18) | def huber_loss(pred, target, delta=0.1, reduction="mean"):
  class EffDistLoss (line 30) | class EffDistLoss(torch.autograd.Function):
    method forward (line 32) | def forward(ctx, w, m, interval):
    method backward (line 64) | def backward(ctx, grad_back):

FILE: lidarnerf/nerf/network.py
  class NeRFNetwork (line 10) | class NeRFNetwork(NeRFRenderer):
    method __init__ (line 11) | def __init__(
    method forward (line 131) | def forward(self, x, d):
    method density (line 162) | def density(self, x):
    method background (line 181) | def background(self, x, d):
    method color (line 199) | def color(self, x, d, cal_lidar_color=False, mask=None, geo_feat=None,...
    method get_params (line 240) | def get_params(self, lr):

FILE: lidarnerf/nerf/network_tcnn.py
  class NeRFNetwork (line 10) | class NeRFNetwork(NeRFRenderer):
    method __init__ (line 11) | def __init__(
    method forward (line 134) | def forward(self, x, d):
    method density (line 137) | def density(self, x):
    method color (line 154) | def color(self, x, d, cal_lidar_color=False, mask=None, geo_feat=None,...
    method get_params (line 198) | def get_params(self, lr):

FILE: lidarnerf/nerf/renderer.py
  function sample_pdf (line 10) | def sample_pdf(bins, weights, n_samples, det=False):
  function plot_pointcloud (line 49) | def plot_pointcloud(pc, color=None):
  class NeRFRenderer (line 61) | class NeRFRenderer(nn.Module):
    method __init__ (line 62) | def __init__(
    method forward (line 89) | def forward(self, x, d):
    method density (line 93) | def density(self, x):
    method color (line 96) | def color(self, x, d, mask=None, **kwargs):
    method run (line 99) | def run(
    method render (line 300) | def render(

FILE: lidarnerf/nerf/utils.py
  function is_ali_cluster (line 31) | def is_ali_cluster():
  function linear_to_srgb (line 39) | def linear_to_srgb(x):
  function srgb_to_linear (line 44) | def srgb_to_linear(x):
  function filter_bbox_dataset (line 48) | def filter_bbox_dataset(pc, OBB_local):
  function filter_poly (line 60) | def filter_poly(pcs, OBB_2D):
  function sort_quadrilateral (line 68) | def sort_quadrilateral(points):
  function is_in_poly (line 80) | def is_in_poly(px, py, poly):
  function seed_everything (line 104) | def seed_everything(seed):
  function torch_vis_2d (line 114) | def torch_vis_2d(x, renormalize=False):
  function extract_fields (line 139) | def extract_fields(bound_min, bound_max, resolution, query_func, S=128):
  function extract_geometry (line 169) | def extract_geometry(bound_min, bound_max, resolution, threshold, query_...
  class PSNRMeter (line 187) | class PSNRMeter:
    method __init__ (line 188) | def __init__(self):
    method clear (line 192) | def clear(self):
    method prepare_inputs (line 196) | def prepare_inputs(self, *inputs):
    method update (line 205) | def update(self, preds, truths):
    method measure (line 216) | def measure(self):
    method write (line 219) | def write(self, writer, global_step, prefix=""):
    method report (line 222) | def report(self):
  class RMSEMeter (line 226) | class RMSEMeter:
    method __init__ (line 227) | def __init__(self):
    method clear (line 231) | def clear(self):
    method prepare_inputs (line 235) | def prepare_inputs(self, *inputs):
    method update (line 244) | def update(self, preds, truths):
    method measure (line 255) | def measure(self):
    method write (line 258) | def write(self, writer, global_step, prefix=""):
    method report (line 261) | def report(self):
  class MAEMeter (line 265) | class MAEMeter:
    method __init__ (line 266) | def __init__(self, intensity_inv_scale=1.0):
    method clear (line 271) | def clear(self):
    method prepare_inputs (line 275) | def prepare_inputs(self, *inputs):
    method update (line 284) | def update(self, preds, truths):
    method measure (line 297) | def measure(self):
    method write (line 300) | def write(self, writer, global_step, prefix=""):
    method report (line 303) | def report(self):
  class DepthMeter (line 307) | class DepthMeter:
    method __init__ (line 308) | def __init__(self, scale):
    method clear (line 314) | def clear(self):
    method prepare_inputs (line 318) | def prepare_inputs(self, *inputs):
    method update (line 327) | def update(self, preds, truths):
    method compute_depth_errors (line 341) | def compute_depth_errors(
    method measure (line 362) | def measure(self):
    method write (line 366) | def write(self, writer, global_step, prefix=""):
    method report (line 371) | def report(self):
  class PointsMeter (line 375) | class PointsMeter:
    method __init__ (line 376) | def __init__(self, scale, intrinsics):
    method clear (line 382) | def clear(self):
    method prepare_inputs (line 386) | def prepare_inputs(self, *inputs):
    method update (line 395) | def update(self, preds, truths):
    method measure (line 418) | def measure(self):
    method write (line 423) | def write(self, writer, global_step, prefix=""):
    method report (line 426) | def report(self):
  class SSIMMeter (line 430) | class SSIMMeter:
    method __init__ (line 431) | def __init__(self, device=None):
    method clear (line 441) | def clear(self):
    method prepare_inputs (line 453) | def prepare_inputs(self, *inputs):
    method update (line 462) | def update(self, preds, truths):
    method measure (line 476) | def measure(self):
    method write (line 479) | def write(self, writer, global_step, prefix=""):
    method report (line 482) | def report(self):
  class LPIPSMeter (line 486) | class LPIPSMeter:
    method __init__ (line 487) | def __init__(self, net="alex", device=None):
    method clear (line 499) | def clear(self):
    method prepare_inputs (line 503) | def prepare_inputs(self, *inputs):
    method update (line 511) | def update(self, preds, truths):
    method measure (line 521) | def measure(self):
    method write (line 524) | def write(self, writer, global_step, prefix=""):
    method report (line 529) | def report(self):
  class Trainer (line 533) | class Trainer(object):
    method __init__ (line 534) | def __init__(
    method __del__ (line 682) | def __del__(self):
    method log (line 686) | def log(self, *args, **kwargs):
    method train_step (line 697) | def train_step(self, data):
    method eval_step (line 886) | def eval_step(self, data):
    method test_step (line 980) | def test_step(self, data, bg_color=None, perturb=False):
    method save_mesh (line 1011) | def save_mesh(self, save_path=None, resolution=256, threshold=10):
    method train (line 1044) | def train(self, train_loader, valid_loader, max_epochs):
    method evaluate (line 1079) | def evaluate(self, loader, name=None):
    method test (line 1084) | def test(self, loader, save_path=None, name=None, write_video=True):
    method train_one_epoch (line 1179) | def train_one_epoch(self, loader):
    method evaluate_one_epoch (line 1282) | def evaluate_one_epoch(self, loader, name=None):
    method save_checkpoint (line 1449) | def save_checkpoint(self, name=None, full=False, best=False, remove_ol...
    method load_checkpoint (line 1512) | def load_checkpoint(self, checkpoint=None, model_only=False):

FILE: lidarnerf/raymarching/backend.py
  function find_cl_path (line 20) | def find_cl_path():

FILE: lidarnerf/raymarching/raymarching.py
  class _near_far_from_aabb (line 15) | class _near_far_from_aabb(Function):
    method forward (line 18) | def forward(ctx, rays_o, rays_d, aabb, min_near=0.2):
  class _sph_from_ray (line 51) | class _sph_from_ray(Function):
    method forward (line 54) | def forward(ctx, rays_o, rays_d, radius):
  class _morton3D (line 85) | class _morton3D(Function):
    method forward (line 87) | def forward(ctx, coords):
  class _morton3D_invert (line 111) | class _morton3D_invert(Function):
    method forward (line 113) | def forward(ctx, indices):
  class _packbits (line 136) | class _packbits(Function):
    method forward (line 139) | def forward(ctx, grid, thresh, bitfield=None):
  class _march_rays_train (line 171) | class _march_rays_train(Function):
    method forward (line 174) | def forward(
  class _composite_rays_train (line 292) | class _composite_rays_train(Function):
    method forward (line 295) | def forward(ctx, sigmas, rgbs, deltas, rays, T_thresh=1e-4):
    method backward (line 329) | def backward(ctx, grad_weights_sum, grad_depth, grad_image):
  class _march_rays (line 367) | class _march_rays(Function):
    method forward (line 370) | def forward(
  class _composite_rays (line 463) | class _composite_rays(Function):
    method forward (line 466) | def forward(

FILE: lidarnerf/raymarching/setup.py
  function find_cl_path (line 21) | def find_cl_path():

FILE: lidarnerf/raymarching/src/bindings.cpp
  function PYBIND11_MODULE (line 5) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: lidarnerf/shencoder/backend.py
  function find_cl_path (line 20) | def find_cl_path():

FILE: lidarnerf/shencoder/setup.py
  function find_cl_path (line 21) | def find_cl_path():

FILE: lidarnerf/shencoder/sphere_harmonics.py
  class _sh_encoder (line 12) | class _sh_encoder(Function):
    method forward (line 15) | def forward(ctx, inputs, degree, calc_grad_inputs=False):
    method backward (line 42) | def backward(ctx, grad):
  class SHEncoder (line 62) | class SHEncoder(nn.Module):
    method __init__ (line 63) | def __init__(self, input_dim=3, degree=4):
    method __repr__ (line 75) | def __repr__(self):
    method forward (line 78) | def forward(self, inputs, size=1):

FILE: lidarnerf/shencoder/src/bindings.cpp
  function PYBIND11_MODULE (line 5) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: lidarnvs/eval.py
  function eval_points_and_pano (line 9) | def eval_points_and_pano(

FILE: lidarnvs/lidarnvs_base.py
  class LidarNVSBase (line 6) | class LidarNVSBase(ABC):
    method fit (line 8) | def fit(self, dataset) -> None:
    method predict_frame (line 17) | def predict_frame(
    method predict_frame_with_raydrop (line 43) | def predict_frame_with_raydrop(

FILE: lidarnvs/lidarnvs_meshing.py
  class LidarNVSMeshing (line 20) | class LidarNVSMeshing(LidarNVSBase):
    method __init__ (line 28) | def __init__(self, ckpt_path=None):
    method fit (line 55) | def fit(self, dataset) -> None:
    method predict_frame (line 100) | def predict_frame(
    method predict_frame_with_raydrop (line 170) | def predict_frame_with_raydrop(
    method intersect_rays (line 293) | def intersect_rays(self, rays):
    method intersect_lidar (line 336) | def intersect_lidar(
  function generate_raydrop_data_meshing (line 356) | def generate_raydrop_data_meshing(dataset, nvs: LidarNVSMeshing) -> dict:

FILE: lidarnvs/lidarnvs_nksr.py
  class LidarNVSNksr (line 9) | class LidarNVSNksr(LidarNVSMeshing):
    method __init__ (line 10) | def __init__(self, ckpt_path=None):
    method _run_nksr (line 26) | def _run_nksr(

FILE: lidarnvs/lidarnvs_pcgen.py
  class LidarNVSPCGen (line 16) | class LidarNVSPCGen(LidarNVSBase):
    method __init__ (line 17) | def __init__(self, raycasting="cp", ckpt_path=None):
    method fit (line 36) | def fit(self, dataset) -> None:
    method predict_frame (line 60) | def predict_frame(
    method predict_frame_with_raydrop (line 132) | def predict_frame_with_raydrop(
  function generate_raydrop_data_pcgen (line 197) | def generate_raydrop_data_pcgen(dataset, nvs: LidarNVSPCGen, rm_pano_mas...
  function get_direction (line 236) | def get_direction(lidar_H, lidar_W, lidar_K):

FILE: lidarnvs/lidarnvs_poisson.py
  class LidarNVSPoisson (line 9) | class LidarNVSPoisson(LidarNVSMeshing):
    method _run_poisson (line 11) | def _run_poisson(
    method __init__ (line 31) | def __init__(

FILE: lidarnvs/loader.py
  function extract_dataset_frame (line 8) | def extract_dataset_frame(

FILE: lidarnvs/plot_possion_grid_search.py
  function main (line 9) | def main():

FILE: lidarnvs/raydrop_dataset_poisson.py
  class RaydropDataset (line 8) | class RaydropDataset(Dataset):
    method __init__ (line 9) | def __init__(self, data_dir, split):
    method __len__ (line 23) | def __len__(self):
    method __getitem__ (line 26) | def __getitem__(self, idx):
    method collate_fn (line 30) | def collate_fn(batch):

FILE: lidarnvs/raydrop_train_pcgen.py
  function setup_seed (line 24) | def setup_seed(seed):
  function cal_psnr (line 35) | def cal_psnr(im1, im2):
  class RayDrop (line 41) | class RayDrop(nn.Module):
    method __init__ (line 42) | def __init__(self, D=4, W=128, input_ch=3, output_ch=1):
    method forward (line 57) | def forward(self, x):
  function weights_init (line 66) | def weights_init(m):
  function config_parser (line 73) | def config_parser():
  function cosine_scheduler (line 205) | def cosine_scheduler(
  function get_embedder (line 222) | def get_embedder(multires, input_dims=3, i=0):
  class Embedder (line 241) | class Embedder:
    method __init__ (line 242) | def __init__(self, **kwargs):
    method create_embedding_fn (line 246) | def create_embedding_fn(self):
    method embed (line 271) | def embed(self, inputs):
  function run_network (line 275) | def run_network(inputs, model, embed_fn, embeddirs_fn):
  function load_pkl_data (line 286) | def load_pkl_data(data_dir, split):
  function train (line 299) | def train():

FILE: lidarnvs/raydrop_train_poisson.py
  function evaluate (line 18) | def evaluate(net, dataloader, device, amp):
  function train_model (line 75) | def train_model(
  function get_args (line 262) | def get_args():
  function main (line 307) | def main():

FILE: lidarnvs/run.py
  function main (line 18) | def main():

FILE: lidarnvs/unet.py
  class DoubleConv (line 7) | class DoubleConv(nn.Module):
    method __init__ (line 10) | def __init__(self, in_channels, out_channels, mid_channels=None):
    method forward (line 23) | def forward(self, x):
  class Down (line 27) | class Down(nn.Module):
    method __init__ (line 30) | def __init__(self, in_channels, out_channels):
    method forward (line 36) | def forward(self, x):
  class Up (line 40) | class Up(nn.Module):
    method __init__ (line 43) | def __init__(self, in_channels, out_channels, bilinear=True):
    method forward (line 56) | def forward(self, x1, x2):
  class OutConv (line 78) | class OutConv(nn.Module):
    method __init__ (line 79) | def __init__(self, in_channels, out_channels):
    method forward (line 83) | def forward(self, x):
  class UNet (line 87) | class UNet(nn.Module):
    method __init__ (line 88) | def __init__(self, n_channels, n_classes, bilinear=False):
    method forward (line 106) | def forward(self, x):
  function dice_coeff (line 120) | def dice_coeff(
  function multiclass_dice_coeff (line 143) | def multiclass_dice_coeff(
  function dice_loss (line 155) | def dice_loss(input: Tensor, target: Tensor, multiclass: bool = False):
  function main (line 161) | def main():

FILE: main_lidarnerf.py
  function get_arg_parser (line 16) | def get_arg_parser():
  function main (line 226) | def main():

FILE: preprocess/cal_centerpose_bound.py
  function cal_centerpose_bound_scale (line 10) | def cal_centerpose_bound_scale(
  function get_path_pose_from_json (line 67) | def get_path_pose_from_json(root_path, sequence_id):
  function main (line 83) | def main():

FILE: preprocess/generate_train_rangeview.py
  function all_points_to_world (line 14) | def all_points_to_world(pcd_path_list, lidar2world_list):
  function oriented_bounding_box (line 24) | def oriented_bounding_box(data):
  function get_dataset_bbox (line 47) | def get_dataset_bbox(all_class, dataset_root, out_dir):
  function LiDAR_2_Pano_NeRF_MVL (line 73) | def LiDAR_2_Pano_NeRF_MVL(
  function generate_nerf_mvl_train_data (line 95) | def generate_nerf_mvl_train_data(
  function create_nerf_mvl_rangeview (line 140) | def create_nerf_mvl_rangeview():
  function LiDAR_2_Pano_KITTI (line 180) | def LiDAR_2_Pano_KITTI(
  function generate_train_data (line 196) | def generate_train_data(
  function create_kitti_rangeview (line 225) | def create_kitti_rangeview():
  function main (line 261) | def main():

FILE: preprocess/kitti360_loader.py
  class KITTI360Loader (line 7) | class KITTI360Loader:
    method __init__ (line 8) | def __init__(self, kitti_360_root) -> None:
    method _read_variable (line 37) | def _read_variable(fid, name, M, N):
    method _load_perspective_intrinsics (line 68) | def _load_perspective_intrinsics(intrinsics_path):
    method load_images (line 99) | def load_images(self, camera_name, sequence_name, frame_ids):
    method get_image_paths (line 115) | def get_image_paths(self, camera_name, sequence_name, frame_ids):
    method _load_all_cameras (line 144) | def _load_all_cameras(self, sequence_name):
    method load_cameras (line 229) | def load_cameras(self, camera_name, sequence_name, frame_ids):
    method _load_all_lidars (line 260) | def _load_all_lidars(self, sequence_name):
    method load_lidars (line 305) | def load_lidars(self, sequence_name, frame_ids):
  function main (line 320) | def main():

FILE: preprocess/kitti360_to_nerf.py
  function normalize_Ts (line 9) | def normalize_Ts(Ts):
  function main (line 26) | def main():

FILE: preprocess/nerfmvl_loader.py
  class NeRFMVLLoader (line 5) | class NeRFMVLLoader:
    method __init__ (line 6) | def __init__(self, nerf_mvl_root, class_name) -> None:
    method _load_all_lidars (line 22) | def _load_all_lidars(
    method load_lidars (line 35) | def load_lidars(self, frame_ids):
  function main (line 49) | def main():

FILE: preprocess/nerfmvl_to_nerf.py
  function main (line 8) | def main():

FILE: setup.py
  function main (line 8) | def main():