SYMBOL INDEX (451 symbols across 54 files)

FILE: bip3d/converter/extract_occupancy_ann.py
  function extract_occupancy (line 8) | def extract_occupancy(dataset, src, dst):

FILE: bip3d/converter/generate_image_3rscan.py
  function process_scene (line 9) | def process_scene(path, scene_name):

FILE: bip3d/converter/generate_image_matterport3d.py
  function process_scene (line 9) | def process_scene(path, output_folder, scene_name):

FILE: bip3d/converter/generate_image_scannet.py
  class RGBDFrame (line 22) | class RGBDFrame:
    method load (line 25) | def load(self, file_handle):
    method decompress_depth (line 41) | def decompress_depth(self, compression_type):
    method decompress_color (line 46) | def decompress_color(self, compression_type):
  class SensorData (line 52) | class SensorData:
    method __init__ (line 58) | def __init__(self, filename, fast=False):
    method load (line 62) | def load(self, filename, fast):
    method export_depth_images (line 105) | def export_depth_images(self, output_path):
    method export_color_images (line 118) | def export_color_images(self, output_path):
    method index_to_str (line 130) | def index_to_str(index):
    method save_mat_to_file (line 135) | def save_mat_to_file(matrix, filename):
    method export_poses (line 141) | def export_poses(self, output_path):
    method export_intrinsics (line 151) | def export_intrinsics(self, output_path):
    method export_depth_intrinsics (line 158) | def export_depth_intrinsics(self, output_path):
  function process_scene (line 166) | def process_scene(path, fast, idx):
  function process_directory (line 186) | def process_directory(path, fast, nproc):

FILE: bip3d/datasets/embodiedscan_det_grounding_dataset.py
  class EmbodiedScanDetGroundingDataset (line 90) | class EmbodiedScanDetGroundingDataset(BaseDataset):
    method __init__ (line 91) | def __init__(
    method process_metainfo (line 147) | def process_metainfo(self):
    method parse_data_info (line 164) | def parse_data_info(self, info: dict):
    method parse_ann_info (line 220) | def parse_ann_info(self, info: dict):
    method _get_axis_align_matrix (line 285) | def _get_axis_align_matrix(info: dict):
    method _ids2masks (line 303) | def _ids2masks(self, ids, mask_length):
    method _remove_dontcare (line 312) | def _remove_dontcare(self, ann_info: dict):
    method load_data_list (line 343) | def load_data_list(self):
    method _get_axis_align_matrix (line 395) | def _get_axis_align_matrix(info: dict):
    method _is_view_dep (line 405) | def _is_view_dep(text):
    method convert_info_to_scan (line 414) | def convert_info_to_scan(self):
    method load_language_data (line 421) | def load_language_data(self):
    method convert_to_continuous (line 442) | def convert_to_continuous(self):
    method get_data_info_continuous (line 469) | def get_data_info_continuous(self, data_info):
    method merge_grounding_data (line 513) | def merge_grounding_data(self, data_infos):
    method get_data_info_grounding (line 550) | def get_data_info_grounding(self, data_info):
    method get_data_info (line 607) | def get_data_info(self, idx):
  function index (line 617) | def index(input, idx):

FILE: bip3d/datasets/transforms/augmentation.py
  class RandomFlip3D (line 12) | class RandomFlip3D(RandomFlip):
    method __init__ (line 59) | def __init__(self,
    method transform (line 88) | def transform(self, input_dict: dict) -> dict:
    method random_flip_data_3d (line 142) | def random_flip_data_3d(self,
    method random_flip_data_2d (line 174) | def random_flip_data_2d(self,
    method _flip_on_direction (line 204) | def _flip_on_direction(self, results: dict) -> None:
    method _transform_lidar2cam (line 231) | def _transform_lidar2cam(self, results: dict) -> None:
    method __repr__ (line 245) | def __repr__(self) -> str:
  class GlobalRotScaleTrans (line 254) | class GlobalRotScaleTrans(BaseTransform):
    method __init__ (line 290) | def __init__(self,
    method transform (line 323) | def transform(self, input_dict: dict) -> dict:
    method _trans_bbox_points (line 351) | def _trans_bbox_points(self, input_dict: dict) -> None:
    method _rot_bbox_points (line 370) | def _rot_bbox_points(self, input_dict: dict) -> None:
    method _scale_bbox_points (line 411) | def _scale_bbox_points(self, input_dict: dict) -> None:
    method _random_scale (line 437) | def _random_scale(self, input_dict: dict) -> None:
    method _transform_lidar2cam (line 451) | def _transform_lidar2cam(self, input_dict: dict) -> None:
    method __repr__ (line 472) | def __repr__(self) -> str:
  class ResizeCropFlipImage (line 483) | class ResizeCropFlipImage(object):
    method __init__ (line 484) | def __init__(self, data_aug_conf, test_mode=False):
    method get_augmentation (line 488) | def get_augmentation(self):
    method __call__ (line 535) | def __call__(self, results):
    method _transform (line 545) | def _transform(self, img, aug_configs):

FILE: bip3d/datasets/transforms/formatting.py
  function to_tensor (line 15) | def to_tensor(
  class Pack3DDetInputs (line 48) | class Pack3DDetInputs(BaseTransform):
    method __init__ (line 64) | def __init__(
    method _remove_prefix (line 84) | def _remove_prefix(self, key: str) -> str:
    method transform (line 89) | def transform(self, results: Union[dict,
    method pack_single_results (line 124) | def pack_single_results(self, results: dict) -> dict:
    method __repr__ (line 292) | def __repr__(self) -> str:

FILE: bip3d/datasets/transforms/loading.py
  class LoadDepthFromFile (line 13) | class LoadDepthFromFile(BaseTransform):
    method __init__ (line 41) | def __init__(self,
    method transform (line 53) | def transform(self, results: dict):
    method __repr__ (line 82) | def __repr__(self):
  class LoadAnnotations3D (line 97) | class LoadAnnotations3D(LoadAnnotations):
    method __init__ (line 180) | def __init__(self,
    method _load_bboxes_3d (line 222) | def _load_bboxes_3d(self, results: dict):
    method _load_bboxes_depth (line 236) | def _load_bboxes_depth(self, results: dict):
    method _load_labels_3d (line 250) | def _load_labels_3d(self, results: dict):
    method _load_attr_labels (line 263) | def _load_attr_labels(self, results: dict):
    method _load_depth_map (line 275) | def _load_depth_map(self, results: dict):
    method _load_masks_3d (line 301) | def _load_masks_3d(self, results: dict):
    method _load_semantic_seg_3d (line 327) | def _load_semantic_seg_3d(self, results: dict):
    method _load_panoptic_3d (line 361) | def _load_panoptic_3d(self, results: dict):
    method _load_visible_instance_masks (line 401) | def _load_visible_instance_masks(self, results: dict):
    method _load_occupancy (line 416) | def _load_occupancy(self, results: dict):
    method _load_visible_occupancy_masks (line 430) | def _load_visible_occupancy_masks(self, results: dict):
    method _load_bboxes (line 445) | def _load_bboxes(self, results: dict):
    method _load_labels (line 460) | def _load_labels(self, results: dict):
    method transform (line 471) | def transform(self, results: dict):
    method __repr__ (line 506) | def __repr__(self):

FILE: bip3d/datasets/transforms/multiview.py
  class MultiViewPipeline (line 14) | class MultiViewPipeline(BaseTransform):
    method __init__ (line 16) | def __init__(
    method transform (line 33) | def transform(self, results: dict):

FILE: bip3d/datasets/transforms/transform.py
  class CategoryGroundingDataPrepare (line 18) | class CategoryGroundingDataPrepare(BaseTransform):
    method __init__ (line 19) | def __init__(
    method transform (line 39) | def transform(self, results):
  class CamIntrisicStandardization (line 127) | class CamIntrisicStandardization(BaseTransform):
    method __init__ (line 128) | def __init__(self, dst_intrinsic, dst_wh):
    method transform (line 143) | def transform(self, results):
  class CustomResize (line 174) | class CustomResize(Resize):
    method _resize_img (line 175) | def _resize_img(self, results: dict, key="img"):
    method transform (line 205) | def transform(self, results: dict):
  class DepthProbLabelGenerator (line 222) | class DepthProbLabelGenerator(BaseTransform):
    method __init__ (line 223) | def __init__(
    method transform (line 237) | def transform(self, input_dict):

FILE: bip3d/datasets/utils.py
  function sample (line 5) | def sample(total_n, sample_n, fix_interval=True):
  function xyzrpy_to_matrix (line 22) | def xyzrpy_to_matrix(input):

FILE: bip3d/eval/indoor_eval.py
  function average_precision (line 10) | def average_precision(recalls, precisions, mode='area'):
  function eval_det_cls (line 58) | def eval_det_cls(pred, gt, iou_thr=None, area_range=None):
  function eval_map_recall (line 194) | def eval_map_recall(pred, gt, ovthresh=None, area_range=None):
  function save_pr_curve (line 233) | def save_pr_curve(recs, precs, metrics):
  function indoor_eval (line 248) | def indoor_eval(gt_annos,

FILE: bip3d/eval/metrics/det_metric.py
  class IndoorDetMetric (line 22) | class IndoorDetMetric(BaseMetric):
    method __init__ (line 37) | def __init__(self,
    method process (line 55) | def process(self, data_batch: dict, data_samples: Sequence[dict]):
    method compute_metrics (line 77) | def compute_metrics(self, results: list, part="Overall", split=True):
    method evaluate (line 112) | def evaluate(self, size: int):
  class Indoor2DMetric (line 237) | class Indoor2DMetric(BaseMetric):
    method __init__ (line 252) | def __init__(self,
    method process (line 260) | def process(self, data_batch: dict, data_samples: Sequence[dict]) -> N...
    method compute_metrics (line 289) | def compute_metrics(self, results: list) -> Dict[str, float]:

FILE: bip3d/eval/metrics/grounding_metric.py
  class GroundingMetric (line 16) | class GroundingMetric(BaseMetric):
    method __init__ (line 37) | def __init__(self,
    method process (line 53) | def process(self, data_batch: dict, data_samples: Sequence[dict]) -> N...
    method ground_eval (line 75) | def ground_eval(self, gt_annos, det_annos, logger=None, part="Overall"):
    method compute_metrics (line 163) | def compute_metrics(self, results: list) -> Dict[str, float]:

FILE: bip3d/grid_mask.py
  class Grid (line 7) | class Grid(object):
    method __init__ (line 8) | def __init__(
    method set_prob (line 20) | def set_prob(self, epoch, max_epoch):
    method __call__ (line 23) | def __call__(self, img, label):
  class GridMask (line 75) | class GridMask(object):
    method __init__ (line 76) | def __init__(
    method set_prob (line 89) | def set_prob(self, epoch, max_epoch):
    method __call__ (line 92) | def __call__(self, x, offset=None):

FILE: bip3d/models/base_target.py
  class BaseTargetWithDenoising (line 8) | class BaseTargetWithDenoising(ABC, nn.Module):
    method __init__ (line 9) | def __init__(self, num_dn=0, num_temp_dn_groups=0):
    method sample (line 16) | def sample(self, cls_pred, box_pred, cls_target, box_target):
    method get_dn_anchors (line 23) | def get_dn_anchors(self, cls_target, box_target, *args, **kwargs):
    method update_dn (line 30) | def update_dn(self, instance_feature, anchor, *args, **kwargs):
    method cache_dn (line 36) | def cache_dn(

FILE: bip3d/models/bbox3d_decoder.py
  function decode_box (line 43) | def decode_box(box, min_size=None, max_size=None):
  class BBox3DDecoder (line 56) | class BBox3DDecoder(BaseModel):
    method __init__ (line 57) | def __init__(
    method init_weights (line 146) | def init_weights(self):
    method forward (line 158) | def forward(
    method loss (line 422) | def loss(self, model_outs, data, text_dict=None):
    method prepare_for_dn_loss (line 554) | def prepare_for_dn_loss(self, model_outs, prefix=""):
    method post_process (line 580) | def post_process(
  class GroundingRefineClsHead (line 614) | class GroundingRefineClsHead(BaseModel):
    method __init__ (line 615) | def __init__(
    method forward (line 651) | def forward(
  class DoF9BoxLoss (line 685) | class DoF9BoxLoss(nn.Module):
    method __init__ (line 686) | def __init__(
    method forward (line 699) | def forward(
  class GroundingBox3DPostProcess (line 733) | class GroundingBox3DPostProcess:
    method __init__ (line 734) | def __init__(
    method __call__ (line 745) | def __call__(
  class DoF9BoxEncoder (line 861) | class DoF9BoxEncoder(nn.Module):
    method __init__ (line 862) | def __init__(
    method forward (line 889) | def forward(self, box_3d: torch.Tensor):
  class SparseBox3DKeyPointsGenerator (line 902) | class SparseBox3DKeyPointsGenerator(nn.Module):
    method __init__ (line 903) | def __init__(
    method forward (line 919) | def forward(
    method anchor_projection (line 977) | def anchor_projection(
    method distance (line 1025) | def distance(anchor):

FILE: bip3d/models/bert.py
  function generate_masks_with_special_tokens_and_transfer_map (line 19) | def generate_masks_with_special_tokens_and_transfer_map(
  class BertModel (line 86) | class BertModel(BaseModel):
    method __init__ (line 110) | def __init__(
    method forward (line 163) | def forward(self, captions: Sequence[str], **kwargs) -> dict:
  class BertEncoder (line 205) | class BertEncoder(nn.Module):
    method __init__ (line 218) | def __init__(
    method forward (line 240) | def forward(self, x) -> dict:

FILE: bip3d/models/data_preprocessors/custom_data_preprocessor.py
  class CustomDet3DDataPreprocessor (line 23) | class CustomDet3DDataPreprocessor(DetDataPreprocessor):
    method __init__ (line 89) | def __init__(
    method forward (line 134) | def forward(self, data: Union[dict, List[dict]], training: bool = False):
    method simple_process (line 160) | def simple_process(self, data: dict, training: bool = False):
    method process_camera_params (line 268) | def process_camera_params(self, data_samples):
    method preprocess_img (line 323) | def preprocess_img(self, _batch_img: Tensor):
    method collate_data (line 341) | def collate_data(self, data: dict):
    method _get_pad_shape (line 428) | def _get_pad_shape(self, data: dict):

FILE: bip3d/models/data_preprocessors/utils.py
  function multiview_img_stack_batch (line 9) | def multiview_img_stack_batch(

FILE: bip3d/models/deformable_aggregation.py
  class DeformableFeatureAggregation (line 29) | class DeformableFeatureAggregation(BaseModule):
    method __init__ (line 30) | def __init__(
    method init_weight (line 115) | def init_weight(self):
    method get_spatial_shape_3D (line 119) | def get_spatial_shape_3D(self, spatial_shape, depth_dim):
    method forward (line 124) | def forward(
    method _get_weights (line 203) | def _get_weights(
    method project_points (line 252) | def project_points(key_points, projection_mat, image_wh=None):
    method feature_sampling (line 273) | def feature_sampling(
    method multi_view_level_fusion (line 305) | def multi_view_level_fusion(

FILE: bip3d/models/feature_enhancer.py
  class TextImageDeformable2DEnhancer (line 23) | class TextImageDeformable2DEnhancer(BaseModel):
    method __init__ (line 24) | def __init__(
    method forward (line 60) | def forward(
    method get_2d_position_embed (line 143) | def get_2d_position_embed(self, feature_maps):

FILE: bip3d/models/instance_bank.py
  function topk (line 11) | def topk(confidence, k, *inputs):
  class InstanceBank (line 24) | class InstanceBank(nn.Module):
    method __init__ (line 25) | def __init__(
    method init_weight (line 73) | def init_weight(self):
    method reset (line 78) | def reset(self):
    method bbox_transform (line 88) | def bbox_transform(self, bbox, matrix):
    method get (line 109) | def get(self, batch_size, metas=None, dn_metas=None):
    method update (line 159) | def update(self, instance_feature, anchor, confidence, num_dn=None):
    method cache (line 192) | def cache(
    method get_instance_id (line 228) | def get_instance_id(self, confidence, anchor=None, threshold=None):
    method update_instance_id (line 248) | def update_instance_id(self, instance_id=None, confidence=None):

FILE: bip3d/models/spatial_enhancer.py
  class DepthFusionSpatialEnhancer (line 13) | class DepthFusionSpatialEnhancer(BaseModel):
    method __init__ (line 14) | def __init__(
    method forward (line 58) | def forward(
    method get_pts (line 104) | def get_pts(self, spatial_shapes, image_wh, projection_mat, device, dt...
    method depth_prob_loss (line 138) | def depth_prob_loss(self, depth_prob, batch_inputs):

FILE: bip3d/models/structure.py
  class BIP3D (line 12) | class BIP3D(BaseDetector):
    method __init__ (line 13) | def __init__(
    method init_weights (line 65) | def init_weights(self):
    method extract_feat (line 78) | def extract_feat(self, batch_inputs_dict, batch_data_samples):
    method extract_text_feature (line 113) | def extract_text_feature(self, batch_inputs_dict):
    method loss (line 121) | def loss(self, batch_inputs, batch_data_samples):
    method predict (line 130) | def predict(self, batch_inputs, batch_data_samples):
    method _forward (line 137) | def _forward(self, batch_inputs, batch_data_samples):

FILE: bip3d/models/target.py
  class Grounding3DTarget (line 24) | class Grounding3DTarget(BaseTargetWithDenoising):
    method __init__ (line 25) | def __init__(
    method encode_reg_target (line 66) | def encode_reg_target(self, box_target, device=None):
    method sample (line 83) | def sample(
    method _cls_cost (line 132) | def _cls_cost(self, cls_pred, token_positive_maps, text_token_mask):
    method _box_cost (line 158) | def _box_cost(self, box_pred, box_target):
    method get_dn_anchors (line 183) | def get_dn_anchors(self, char_positives, box_target, text_dict, label=...

FILE: bip3d/models/utils.py
  function deformable_format (line 6) | def deformable_format(
  function bbox_to_corners (line 54) | def bbox_to_corners(bbox, permutation=False):
  function wasserstein_distance (line 107) | def wasserstein_distance(source, target):
  function permutation_corner_distance (line 126) | def permutation_corner_distance(source, target):
  function center_distance (line 136) | def center_distance(source, target):
  function get_positive_map (line 140) | def get_positive_map(char_positive, text_dict):
  function get_entities (line 182) | def get_entities(text, char_positive, sep_token="[SEP]"):
  function linear_act_ln (line 198) | def linear_act_ln(

FILE: bip3d/ops/deformable_aggregation.py
  class DeformableAggregationFunction (line 9) | class DeformableAggregationFunction(Function):
    method forward (line 12) | def forward(
    method backward (line 45) | def backward(ctx, grad_output):
  class DeformableAggregationWithDepthFunction (line 82) | class DeformableAggregationWithDepthFunction(Function):
    method forward (line 85) | def forward(
    method backward (line 121) | def backward(ctx, grad_output):
  function deformable_aggregation_func (line 164) | def deformable_aggregation_func(
  function feature_maps_format (line 193) | def feature_maps_format(feature_maps, inverse=False):

FILE: bip3d/ops/setup.py
  function make_cuda_ext (line 12) | def make_cuda_ext(

FILE: bip3d/ops/src/deformable_aggregation.cpp
  function deformable_aggregation_forward (line 46) | at::Tensor deformable_aggregation_forward(
  function deformable_aggregation_backward (line 78) | void deformable_aggregation_backward(
  function PYBIND11_MODULE (line 118) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: bip3d/ops/src/deformable_aggregation_with_depth.cpp
  function deformable_aggregation_with_depth_forward (line 48) | at::Tensor deformable_aggregation_with_depth_forward(
  function deformable_aggregation_with_depth_backward (line 82) | void deformable_aggregation_with_depth_backward(
  function PYBIND11_MODULE (line 124) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: bip3d/structures/bbox_3d/base_box3d.py
  class BaseInstance3DBoxes (line 14) | class BaseInstance3DBoxes:
    method __init__ (line 42) | def __init__(
    method shape (line 82) | def shape(self) -> torch.Size:
    method volume (line 87) | def volume(self) -> Tensor:
    method dims (line 92) | def dims(self) -> Tensor:
    method yaw (line 97) | def yaw(self) -> Tensor:
    method height (line 102) | def height(self) -> Tensor:
    method top_height (line 107) | def top_height(self) -> Tensor:
    method bottom_height (line 112) | def bottom_height(self) -> Tensor:
    method center (line 117) | def center(self) -> Tensor:
    method bottom_center (line 136) | def bottom_center(self) -> Tensor:
    method gravity_center (line 141) | def gravity_center(self) -> Tensor:
    method corners (line 150) | def corners(self) -> Tensor:
    method bev (line 155) | def bev(self) -> Tensor:
    method nearest_bev (line 161) | def nearest_bev(self) -> Tensor:
    method in_range_bev (line 180) | def in_range_bev(
    method rotate (line 205) | def rotate(
    method flip (line 228) | def flip(
    method translate (line 248) | def translate(self, trans_vector: Union[Tensor, np.ndarray]) -> None:
    method in_range_3d (line 259) | def in_range_3d(
    method convert_to (line 286) | def convert_to(self,
    method scale (line 309) | def scale(self, scale_factor: float) -> None:
    method limit_yaw (line 318) | def limit_yaw(self, offset: float = 0.5, period: float = np.pi) -> None:
    method nonempty (line 327) | def nonempty(self, threshold: float = 0.0) -> Tensor:
    method __getitem__ (line 348) | def __getitem__(
    method __len__ (line 382) | def __len__(self) -> int:
    method __repr__ (line 386) | def __repr__(self) -> str:
    method cat (line 391) | def cat(cls, boxes_list: Sequence['BaseInstance3DBoxes']
    method numpy (line 413) | def numpy(self) -> np.ndarray:
    method to (line 417) | def to(self, device: Union[str, torch.device], *args,
    method cpu (line 433) | def cpu(self) -> 'BaseInstance3DBoxes':
    method cuda (line 444) | def cuda(self, *args, **kwargs) -> 'BaseInstance3DBoxes':
    method clone (line 455) | def clone(self) -> 'BaseInstance3DBoxes':
    method detach (line 467) | def detach(self) -> 'BaseInstance3DBoxes':
    method device (line 480) | def device(self) -> torch.device:
    method __iter__ (line 484) | def __iter__(self) -> Iterator[Tensor]:
    method height_overlaps (line 493) | def height_overlaps(cls, boxes1: 'BaseInstance3DBoxes',
    method new_box (line 525) | def new_box(

FILE: bip3d/structures/bbox_3d/box_3d_mode.py
  class Box3DMode (line 14) | class Box3DMode(IntEnum):
    method convert (line 67) | def convert(

FILE: bip3d/structures/bbox_3d/coord_3d_mode.py
  class Coord3DMode (line 17) | class Coord3DMode(IntEnum):
    method convert (line 68) | def convert(input: Union[Sequence[float], np.ndarray, Tensor,
    method convert_box (line 131) | def convert_box(
    method convert_point (line 171) | def convert_point(

FILE: bip3d/structures/bbox_3d/euler_box3d.py
  class EulerInstance3DBoxes (line 12) | class EulerInstance3DBoxes(BaseInstance3DBoxes):
    method __init__ (line 24) | def __init__(self, tensor, box_dim=9, origin=(0.5, 0.5, 0.5)):
    method get_corners (line 60) | def get_corners(self, tensor1):
    method overlaps (line 104) | def overlaps(cls, boxes1, boxes2, mode='iou', eps=1e-4):
    method gravity_center (line 138) | def gravity_center(self):
    method corners (line 143) | def corners(self):
    method transform (line 186) | def transform(self, matrix):
    method scale (line 208) | def scale(self, scale_factor: float) -> None:
    method rotate (line 216) | def rotate(self, angle, points=None):
    method flip (line 263) | def flip(self, direction='X'):

FILE: bip3d/structures/bbox_3d/euler_depth_box3d.py
  class EulerDepthInstance3DBoxes (line 10) | class EulerDepthInstance3DBoxes(EulerInstance3DBoxes):
    method __init__ (line 41) | def __init__(self,
    method flip (line 49) | def flip(self, bev_direction='horizontal', points=None):
    method convert_to (line 80) | def convert_to(self, dst, rt_mat=None):
    method points_in_boxes_part (line 100) | def points_in_boxes_part(self, points, boxes_override=None):
    method points_in_boxes_all (line 132) | def points_in_boxes_all(self, points, boxes_override=None):

FILE: bip3d/structures/bbox_3d/utils.py
  function limit_period (line 14) | def limit_period(val: Union[np.ndarray, Tensor],
  function rotation_3d_in_euler (line 33) | def rotation_3d_in_euler(points, angles, return_mat=False, clockwise=Fal...
  function rotation_3d_in_axis (line 93) | def rotation_3d_in_axis(
  function xywhr2xyxyr (line 189) | def xywhr2xyxyr(
  function get_box_type (line 211) | def get_box_type(box_type: str) -> Tuple[type, int]:
  function points_cam2img (line 247) | def points_cam2img(points_3d: Union[Tensor, np.ndarray],
  function batch_points_cam2img (line 293) | def batch_points_cam2img(points_3d, proj_mat, with_depth=False):
  function points_img2cam (line 339) | def points_img2cam(
  function mono_cam_box2vis (line 374) | def mono_cam_box2vis(cam_box):
  function get_proj_mat_by_coord_type (line 420) | def get_proj_mat_by_coord_type(img_meta: dict, coord_type: str) -> Tensor:
  function yaw2local (line 437) | def yaw2local(yaw: Tensor, loc: Tensor) -> Tensor:
  function get_lidar2img (line 459) | def get_lidar2img(cam2img: Tensor, lidar2cam: Tensor) -> Tensor:

FILE: bip3d/structures/ops/box_np_ops.py
  function camera_to_lidar (line 14) | def camera_to_lidar(points, r_rect, velo2cam):
  function box_camera_to_lidar (line 37) | def box_camera_to_lidar(data, r_rect, velo2cam):
  function corners_nd (line 63) | def corners_nd(dims, origin=0.5):
  function center_to_corner_box2d (line 96) | def center_to_corner_box2d(centers, dims, angles=None, origin=0.5):
  function depth_to_points (line 123) | def depth_to_points(depth, trunc_pixel):
  function depth_to_lidar_points (line 147) | def depth_to_lidar_points(depth, trunc_pixel, P2, r_rect, velo2cam):
  function center_to_corner_box3d (line 171) | def center_to_corner_box3d(centers,
  function box2d_to_corner_jit (line 204) | def box2d_to_corner_jit(boxes):
  function corner_to_standup_nd_jit (line 235) | def corner_to_standup_nd_jit(boxes_corner):
  function corner_to_surfaces_3d_jit (line 256) | def corner_to_surfaces_3d_jit(corners):
  function rotation_points_single_angle (line 279) | def rotation_points_single_angle(points, angle, axis=0):
  function box3d_to_bbox (line 311) | def box3d_to_bbox(box3d, P2):
  function corner_to_surfaces_3d (line 333) | def corner_to_surfaces_3d(corners):
  function points_in_rbbox (line 355) | def points_in_rbbox(points, rbbox, z_axis=2, origin=(0.5, 0.5, 0)):
  function minmax_to_corner_2d (line 384) | def minmax_to_corner_2d(minmax_box):
  function create_anchors_3d_range (line 399) | def create_anchors_3d_range(feature_size,
  function center_to_minmax_2d (line 458) | def center_to_minmax_2d(centers, dims, origin=0.5):
  function rbbox2d_to_near_bbox (line 477) | def rbbox2d_to_near_bbox(rbboxes):
  function iou_jit (line 497) | def iou_jit(boxes, query_boxes, mode='iou', eps=0.0):
  function projection_matrix_to_CRT_kitti (line 538) | def projection_matrix_to_CRT_kitti(proj):
  function remove_outside_points (line 565) | def remove_outside_points(points, rect, Trv2c, P2, image_shape):
  function get_frustum (line 596) | def get_frustum(bbox_image, C, near_clip=0.001, far_clip=100):
  function surface_equ_3d (line 629) | def surface_equ_3d(polygon_surfaces):
  function _points_in_convex_polygon_3d_jit (line 654) | def _points_in_convex_polygon_3d_jit(points, polygon_surfaces, normal_ve...
  function points_in_convex_polygon_3d_jit (line 690) | def points_in_convex_polygon_3d_jit(points,
  function points_in_convex_polygon_jit (line 720) | def points_in_convex_polygon_jit(points, polygon, clockwise=False):
  function boxes3d_to_corners3d_lidar (line 765) | def boxes3d_to_corners3d_lidar(boxes3d, bottom_center=True):

FILE: bip3d/structures/ops/iou3d_calculator.py
  class BboxOverlapsNearest3D (line 10) | class BboxOverlapsNearest3D(object):
    method __init__ (line 21) | def __init__(self, coordinate='lidar'):
    method __call__ (line 25) | def __call__(self, bboxes1, bboxes2, mode='iou', is_aligned=False):
    method __repr__ (line 50) | def __repr__(self):
  class BboxOverlaps3D (line 58) | class BboxOverlaps3D(object):
    method __init__ (line 66) | def __init__(self, coordinate):
    method __call__ (line 70) | def __call__(self, bboxes1, bboxes2, mode='iou'):
    method __repr__ (line 92) | def __repr__(self):
  function bbox_overlaps_nearest_3d (line 99) | def bbox_overlaps_nearest_3d(bboxes1,
  function bbox_overlaps_3d (line 150) | def bbox_overlaps_3d(bboxes1, bboxes2, mode='iou', coordinate='camera'):
  class AxisAlignedBboxOverlaps3D (line 182) | class AxisAlignedBboxOverlaps3D(object):
    method __call__ (line 185) | def __call__(self, bboxes1, bboxes2, mode='iou', is_aligned=False):
    method __repr__ (line 206) | def __repr__(self):
  function axis_aligned_bbox_overlaps_3d (line 212) | def axis_aligned_bbox_overlaps_3d(bboxes1,

FILE: bip3d/structures/ops/transforms.py
  function bbox3d_mapping_back (line 5) | def bbox3d_mapping_back(bboxes, scale_factor, flip_horizontal, flip_vert...
  function bbox3d2roi (line 27) | def bbox3d2roi(bbox_list):
  function bbox3d2result (line 51) | def bbox3d2result(bboxes, scores, labels, attrs=None):

FILE: bip3d/structures/points/__init__.py
  function get_points_type (line 10) | def get_points_type(points_type: str) -> type:

FILE: bip3d/structures/points/base_points.py
  class BasePoints (line 14) | class BasePoints:
    method __init__ (line 34) | def __init__(self,
    method coord (line 58) | def coord(self) -> Tensor:
    method coord (line 63) | def coord(self, tensor: Union[Tensor, np.ndarray]) -> None:
    method height (line 79) | def height(self) -> Union[Tensor, None]:
    method height (line 89) | def height(self, tensor: Union[Tensor, np.ndarray]) -> None:
    method color (line 115) | def color(self) -> Union[Tensor, None]:
    method color (line 125) | def color(self, tensor: Union[Tensor, np.ndarray]) -> None:
    method shape (line 154) | def shape(self) -> torch.Size:
    method shuffle (line 158) | def shuffle(self) -> Tensor:
    method rotate (line 168) | def rotate(self,
    method flip (line 206) | def flip(self, bev_direction: str = 'horizontal') -> None:
    method translate (line 215) | def translate(self, trans_vector: Union[Tensor, np.ndarray]) -> None:
    method in_range_3d (line 236) | def in_range_3d(
    method bev (line 263) | def bev(self) -> Tensor:
    method in_range_bev (line 267) | def in_range_bev(
    method convert_to (line 287) | def convert_to(self,
    method scale (line 308) | def scale(self, scale_factor: float) -> None:
    method __getitem__ (line 316) | def __getitem__(
    method __len__ (line 395) | def __len__(self) -> int:
    method __repr__ (line 399) | def __repr__(self) -> str:
    method cat (line 404) | def cat(cls, points_list: Sequence['BasePoints']) -> 'BasePoints':
    method numpy (line 425) | def numpy(self) -> np.ndarray:
    method to (line 429) | def to(self, device: Union[str, torch.device], *args,
    method cpu (line 444) | def cpu(self) -> 'BasePoints':
    method cuda (line 455) | def cuda(self, *args, **kwargs) -> 'BasePoints':
    method clone (line 466) | def clone(self) -> 'BasePoints':
    method detach (line 477) | def detach(self) -> 'BasePoints':
    method device (line 489) | def device(self) -> torch.device:
    method __iter__ (line 493) | def __iter__(self) -> Iterator[Tensor]:
    method new_point (line 501) | def new_point(

FILE: bip3d/structures/points/cam_points.py
  class CameraPoints (line 10) | class CameraPoints(BasePoints):
    method __init__ (line 30) | def __init__(self,
    method flip (line 39) | def flip(self, bev_direction: str = 'horizontal') -> None:
    method bev (line 53) | def bev(self) -> Tensor:
    method convert_to (line 57) | def convert_to(self,

FILE: bip3d/structures/points/depth_points.py
  class DepthPoints (line 10) | class DepthPoints(BasePoints):
    method __init__ (line 30) | def __init__(self,
    method flip (line 39) | def flip(self, bev_direction: str = 'horizontal') -> None:
    method convert_to (line 52) | def convert_to(self,

FILE: bip3d/structures/points/lidar_points.py
  class LiDARPoints (line 10) | class LiDARPoints(BasePoints):
    method __init__ (line 30) | def __init__(self,
    method flip (line 39) | def flip(self, bev_direction: str = 'horizontal') -> None:
    method convert_to (line 52) | def convert_to(self,

FILE: bip3d/utils/array_converter.py
  function array_converter (line 12) | def array_converter(to_torch: bool = True,
  class ArrayConverter (line 204) | class ArrayConverter:
    method __init__ (line 215) | def __init__(self,
    method set_template (line 220) | def set_template(self, array: TemplateArrayType) -> None:
    method convert (line 261) | def convert(
    method recover (line 326) | def recover(

FILE: bip3d/utils/dist_utils.py
  function reduce_mean (line 4) | def reduce_mean(tensor):

FILE: bip3d/utils/line_mesh.py
  function align_vector_to_another (line 24) | def align_vector_to_another(a=np.array([0, 0, 1]), b=np.array([1, 0, 0])):
  function normalized (line 35) | def normalized(a, axis=-1, order=2):
  class LineMesh (line 42) | class LineMesh(object):
    method __init__ (line 44) | def __init__(self, points, lines=None, colors=[0, 1, 0], radius=0.15):
    method lines_from_ordered_points (line 70) | def lines_from_ordered_points(points):
    method create_line_mesh (line 74) | def create_line_mesh(self):
    method add_line (line 110) | def add_line(self, vis):
    method remove_line (line 115) | def remove_line(self, vis):
  function main (line 123) | def main():

FILE: bip3d/utils/typing_config.py
  class Det3DDataElement (line 11) | class Det3DDataElement(BaseDataElement):
    method gt_instances_3d (line 14) | def gt_instances_3d(self) -> InstanceData:
    method gt_instances_3d (line 18) | def gt_instances_3d(self, value: InstanceData) -> None:
    method gt_instances_3d (line 22) | def gt_instances_3d(self) -> None:
    method pred_instances_3d (line 26) | def pred_instances_3d(self) -> InstanceData:
    method pred_instances_3d (line 30) | def pred_instances_3d(self, value: InstanceData) -> None:
    method pred_instances_3d (line 34) | def pred_instances_3d(self) -> None:
  class PointData (line 43) | class PointData(BaseDataElement):
    method __setattr__ (line 77) | def __setattr__(self, name: str, value: Sized) -> None:
    method __getitem__ (line 98) | def __getitem__(self, item: IndexType) -> 'PointData':
    method __len__ (line 185) | def __len__(self) -> int:

FILE: tools/anchor_bbox3d_kmeans.py
  function sample (line 10) | def sample(ids, n):
  function kmeans (line 25) | def kmeans(

FILE: tools/benchmark.py
  function parse_args (line 16) | def parse_args():
  function inference_benchmark (line 72) | def inference_benchmark(args, cfg, distributed, logger):
  function dataloader_benchmark (line 85) | def dataloader_benchmark(args, cfg, distributed, logger):
  function dataset_benchmark (line 97) | def dataset_benchmark(args, cfg, distributed, logger):
  function main (line 108) | def main():

FILE: tools/ckpt_rename.py
  function get_renamed_ckpt (line 4) | def get_renamed_ckpt(file, output="./"):

FILE: tools/test.py
  function wait_before_import_config (line 5) | def wait_before_import_config():
  function wait_after_import_config (line 9) | def wait_after_import_config():
  function parse_args (line 31) | def parse_args():
  function trigger_visualization_hook (line 93) | def trigger_visualization_hook(cfg, args):
  function main (line 122) | def main():

FILE: tools/train.py
  function wait_before_import_config (line 5) | def wait_before_import_config():
  function wait_after_import_config (line 9) | def wait_after_import_config():
  function parse_args (line 33) | def parse_args():
  function main (line 80) | def main():