Upload folder using huggingface_hub

.gitattributes

@@ -38,3 +38,4 @@ gf_s3dis_ss_0.05/baseline/wandb/run-20251102_201734-ccwbjmvu/run-ccwbjmvu.wandb
 gf_s3dis_ss_0.05/baseline/wandb/run-20251102_213550-2e8vphue/run-2e8vphue.wandb filter=lfs diff=lfs merge=lfs -text
 gf_s3dis_ss_0.05/early-fusion-r-0.5/wandb/run-20251102_213832-fwfae11r/run-fwfae11r.wandb filter=lfs diff=lfs merge=lfs -text
 gf_s3dis_ss_0.05/early-fusion-r-0.5/wandb/run-20251114_011300-hlpbmdin/run-hlpbmdin.wandb filter=lfs diff=lfs merge=lfs -text
+gf_s3dis_ss_0.05/latent-fusion-r-0.5/wandb/run-20251110_114502-texly8ki/run-texly8ki.wandb filter=lfs diff=lfs merge=lfs -text

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/__init__.py

@@ -0,0 +1,27 @@
+from .defaults import DefaultDataset, ConcatDataset
+from .builder import build_dataset
+from .utils import point_collate_fn, collate_fn
+
+# generic
+from .precomputed_features import PrecomputedFeaturesDataset
+
+# indoor scene
+from .s3dis import S3DISDataset
+from .scannet import ScanNetDataset, ScanNet200Dataset
+from .scannetpp import ScanNetPPDataset
+from .scannet_pair import ScanNetPairDataset
+from .hm3d import HM3DDataset
+from .structure3d import Structured3DDataset
+from .aeo import AEODataset
+
+# outdoor scene
+from .semantic_kitti import SemanticKITTIDataset
+from .nuscenes import NuScenesDataset
+from .waymo import WaymoDataset
+
+# object
+from .modelnet import ModelNetDataset
+from .shapenet_part import ShapeNetPartDataset
+
+# dataloader
+from .dataloader import MultiDatasetDataloader

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/aeo.py

@@ -0,0 +1,29 @@
+"""
+AEO Dataset
+
+Author: Xiaoyang Wu (xiaoyang.wu.cs@gmail.com)
+Please cite our work if the code is helpful to you.
+"""
+
+import os
+
+import numpy as np
+
+from .defaults import DefaultDataset
+from .builder import DATASETS
+
+
+@DATASETS.register_module()
+class AEODataset(DefaultDataset):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        label_mapping = np.ones(41, dtype=int) * -1
+        label_mapping[[0, 1, 3, 4, 13, 16, 19, 21, 22, 28, 29, 34, 36, 37, 38, 39]] = (
+            np.arange(16)
+        )
+        self.label_mapping = label_mapping
+
+    def get_data(self, idx):
+        data_dict = super().get_data(idx)
+        data_dict["segment"] = self.label_mapping[data_dict["segment"]]
+        return data_dict

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/builder.py

@@ -0,0 +1,15 @@
+"""
+Dataset Builder
+
+Author: Xiaoyang Wu (xiaoyang.wu.cs@gmail.com)
+Please cite our work if the code is helpful to you.
+"""
+
+from pointcept.utils.registry import Registry
+
+DATASETS = Registry("datasets")
+
+
+def build_dataset(cfg):
+    """Build datasets."""
+    return DATASETS.build(cfg)

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/dataloader.py

@@ -0,0 +1,112 @@
+from functools import partial
+import weakref
+import torch
+import torch.utils.data
+
+import pointcept.utils.comm as comm
+from pointcept.datasets.utils import point_collate_fn
+from pointcept.datasets import ConcatDataset
+from pointcept.utils.env import set_seed
+
+
+class MultiDatasetDummySampler:
+    def __init__(self):
+        self.dataloader = None
+
+    def set_epoch(self, epoch):
+        if comm.get_world_size() > 1:
+            for dataloader in self.dataloader.dataloaders:
+                dataloader.sampler.set_epoch(epoch)
+        return
+
+
+class MultiDatasetDataloader:
+    """
+    Multiple Datasets Dataloader, batch data from a same dataset and mix up ratio determined by loop of each sub dataset.
+    The overall length is determined by the main dataset (first) and loop of concat dataset.
+    """
+
+    def __init__(
+        self,
+        concat_dataset: ConcatDataset,
+        batch_size_per_gpu: int,
+        num_worker_per_gpu: int,
+        mix_prob=0,
+        seed=None,
+    ):
+        self.datasets = concat_dataset.datasets
+        self.ratios = [dataset.loop for dataset in self.datasets]
+        # reset data loop, original loop serve as ratios
+        for dataset in self.datasets:
+            dataset.loop = 1
+        # determine union training epoch by main dataset
+        self.datasets[0].loop = concat_dataset.loop
+        # build sub-dataloaders
+        num_workers = num_worker_per_gpu // len(self.datasets)
+        self.dataloaders = []
+        for dataset_id, dataset in enumerate(self.datasets):
+            if comm.get_world_size() > 1:
+                sampler = torch.utils.data.distributed.DistributedSampler(dataset)
+            else:
+                sampler = None
+
+            init_fn = (
+                partial(
+                    self._worker_init_fn,
+                    dataset_id=dataset_id,
+                    num_workers=num_workers,
+                    num_datasets=len(self.datasets),
+                    rank=comm.get_rank(),
+                    seed=seed,
+                )
+                if seed is not None
+                else None
+            )
+            self.dataloaders.append(
+                torch.utils.data.DataLoader(
+                    dataset,
+                    batch_size=batch_size_per_gpu,
+                    shuffle=(sampler is None),
+                    num_workers=num_worker_per_gpu,
+                    sampler=sampler,
+                    collate_fn=partial(point_collate_fn, mix_prob=mix_prob),
+                    pin_memory=True,
+                    worker_init_fn=init_fn,
+                    drop_last=True,
+                    persistent_workers=True,
+                )
+            )
+        self.sampler = MultiDatasetDummySampler()
+        self.sampler.dataloader = weakref.proxy(self)
+
+    def __iter__(self):
+        iterator = [iter(dataloader) for dataloader in self.dataloaders]
+        while True:
+            for i in range(len(self.ratios)):
+                for _ in range(self.ratios[i]):
+                    try:
+                        batch = next(iterator[i])
+                    except StopIteration:
+                        if i == 0:
+                            return
+                        else:
+                            iterator[i] = iter(self.dataloaders[i])
+                            batch = next(iterator[i])
+                    yield batch
+
+    def __len__(self):
+        main_data_loader_length = len(self.dataloaders[0])
+        return (
+            main_data_loader_length // self.ratios[0] * sum(self.ratios)
+            + main_data_loader_length % self.ratios[0]
+        )
+
+    @staticmethod
+    def _worker_init_fn(worker_id, num_workers, dataset_id, num_datasets, rank, seed):
+        worker_seed = (
+            num_workers * num_datasets * rank
+            + num_workers * dataset_id
+            + worker_id
+            + seed
+        )
+        set_seed(worker_seed)

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/defaults.py

@@ -0,0 +1,236 @@
+"""
+Default Datasets
+
+Author: Xiaoyang Wu (xiaoyang.wu.cs@gmail.com)
+Please cite our work if the code is helpful to you.
+"""
+
+import os
+import glob
+import json
+from re import split
+
+import numpy as np
+from copy import deepcopy
+from torch.utils.data import Dataset
+from collections.abc import Sequence
+
+from pointcept.utils.logger import get_root_logger
+from pointcept.utils.cache import shared_dict
+
+from .builder import DATASETS, build_dataset
+from .transform import Compose, TRANSFORMS
+
+
+@DATASETS.register_module()
+class DefaultDataset(Dataset):
+    VALID_ASSETS = [
+        "coord",
+        "color",
+        "normal",
+        "strength",
+        "segment",
+        "instance",
+        "pose",
+    ]
+
+    def __init__(
+        self,
+        split="train",
+        data_root="data/dataset",
+        transform=None,
+        test_mode=False,
+        test_cfg=None,
+        cache=False,
+        ignore_index=-1,
+        loop=1,
+    ):
+        super(DefaultDataset, self).__init__()
+        self.data_root = data_root
+        self.split = split
+        self.transform = Compose(transform)
+        self.cache = cache
+        self.ignore_index = ignore_index
+        self.loop = (
+            loop if not test_mode else 1
+        )  # force make loop = 1 while in test mode
+        self.test_mode = test_mode
+        self.test_cfg = test_cfg if test_mode else None
+
+        if test_mode:
+            self.test_voxelize = (
+                TRANSFORMS.build(self.test_cfg.voxelize)
+                if self.test_cfg.voxelize
+                else None
+            )
+            self.test_crop = (
+                TRANSFORMS.build(self.test_cfg.crop) if self.test_cfg.crop else None
+            )
+            self.post_transform = Compose(self.test_cfg.post_transform)
+            self.aug_transform = [Compose(aug) for aug in self.test_cfg.aug_transform]
+
+        self.data_list = self.get_data_list()
+        logger = get_root_logger()
+        logger.info(
+            "Totally {} x {} samples in {} {} set.".format(
+                len(self.data_list), self.loop, os.path.basename(self.data_root), split
+            )
+        )
+
+    def get_data_list(self):
+        if isinstance(self.split, str):
+            split_list = [self.split]
+        elif isinstance(self.split, Sequence):
+            split_list = self.split
+        else:
+            raise NotImplementedError
+
+        data_list = []
+        for split in split_list:
+            if os.path.isfile(os.path.join(self.data_root, split)):
+                with open(os.path.join(self.data_root, split)) as f:
+                    data_list += [
+                        os.path.join(self.data_root, data) for data in json.load(f)
+                    ]
+            else:
+                data_list += glob.glob(os.path.join(self.data_root, split, "*"))
+        return data_list
+
+    def get_data(self, idx):
+        data_path = self.data_list[idx % len(self.data_list)]
+        name = self.get_data_name(idx)
+        split = self.get_split_name(idx)
+        if self.cache:
+            cache_name = f"pointcept-{name}"
+            return shared_dict(cache_name)
+
+        data_dict = {}
+        assets = os.listdir(data_path)
+        for asset in assets:
+            if not asset.endswith(".npy"):
+                continue
+            if asset[:-4] not in self.VALID_ASSETS:
+                continue
+            data_dict[asset[:-4]] = np.load(os.path.join(data_path, asset))
+        data_dict["name"] = name
+        data_dict["split"] = split
+
+        if "coord" in data_dict.keys():
+            data_dict["coord"] = data_dict["coord"].astype(np.float32)
+
+        if "color" in data_dict.keys():
+            data_dict["color"] = data_dict["color"].astype(np.float32)
+
+        if "normal" in data_dict.keys():
+            data_dict["normal"] = data_dict["normal"].astype(np.float32)
+
+        if "segment" in data_dict.keys():
+            data_dict["segment"] = data_dict["segment"].reshape([-1]).astype(np.int32)
+        else:
+            data_dict["segment"] = (
+                np.ones(data_dict["coord"].shape[0], dtype=np.int32) * -1
+            )
+
+        if "instance" in data_dict.keys():
+            data_dict["instance"] = data_dict["instance"].reshape([-1]).astype(np.int32)
+        else:
+            data_dict["instance"] = (
+                np.ones(data_dict["coord"].shape[0], dtype=np.int32) * -1
+            )
+        return data_dict
+
+    def get_data_name(self, idx):
+        return os.path.basename(self.data_list[idx % len(self.data_list)])
+
+    def get_split_name(self, idx):
+        return os.path.basename(
+            os.path.dirname(self.data_list[idx % len(self.data_list)])
+        )
+
+    def prepare_train_data(self, idx):
+        # load data
+        data_dict = self.get_data(idx)
+        data_dict = self.transform(data_dict)
+        return data_dict
+
+    def prepare_test_data(self, idx):
+        # load data
+        data_dict = self.get_data(idx)
+        data_dict = self.transform(data_dict)
+        result_dict = dict(segment=data_dict.pop("segment"), name=data_dict.pop("name"))
+        if "origin_segment" in data_dict:
+            assert "inverse" in data_dict
+            result_dict["origin_segment"] = data_dict.pop("origin_segment")
+            result_dict["inverse"] = data_dict.pop("inverse")
+
+        data_dict_list = []
+        for aug in self.aug_transform:
+            data_dict_list.append(aug(deepcopy(data_dict)))
+
+        fragment_list = []
+        for data in data_dict_list:
+            if self.test_voxelize is not None:
+                data_part_list = self.test_voxelize(data)
+            else:
+                data["index"] = np.arange(data["coord"].shape[0])
+                data_part_list = [data]
+            for data_part in data_part_list:
+                if self.test_crop is not None:
+                    data_part = self.test_crop(data_part)
+                else:
+                    data_part = [data_part]
+                fragment_list += data_part
+
+        for i in range(len(fragment_list)):
+            fragment_list[i] = self.post_transform(fragment_list[i])
+        result_dict["fragment_list"] = fragment_list
+        return result_dict
+
+    def __getitem__(self, idx):
+        if self.test_mode:
+            return self.prepare_test_data(idx)
+        else:
+            return self.prepare_train_data(idx)
+
+    def __len__(self):
+        return len(self.data_list) * self.loop
+
+
+@DATASETS.register_module()
+class ConcatDataset(Dataset):
+    def __init__(self, datasets, loop=1):
+        super(ConcatDataset, self).__init__()
+        self.datasets = [build_dataset(dataset) for dataset in datasets]
+        self.loop = loop
+        self.data_list = self.get_data_list()
+        logger = get_root_logger()
+        logger.info(
+            "Totally {} x {} samples in the concat set.".format(
+                len(self.data_list), self.loop
+            )
+        )
+
+    def get_data_list(self):
+        data_list = []
+        for i in range(len(self.datasets)):
+            data_list.extend(
+                zip(
+                    np.ones(len(self.datasets[i]), dtype=int) * i,
+                    np.arange(len(self.datasets[i])),
+                )
+            )
+        return data_list
+
+    def get_data(self, idx):
+        dataset_idx, data_idx = self.data_list[idx % len(self.data_list)]
+        return self.datasets[dataset_idx][data_idx]
+
+    def get_data_name(self, idx):
+        dataset_idx, data_idx = self.data_list[idx % len(self.data_list)]
+        return self.datasets[dataset_idx].get_data_name(data_idx)
+
+    def __getitem__(self, idx):
+        return self.get_data(idx)
+
+    def __len__(self):
+        return len(self.data_list) * self.loop

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/hm3d.py

@@ -0,0 +1,45 @@
+"""
+Habitat-Matterport 3D Dataset
+
+Author: Xiaoyang Wu (xiaoyang.wu.cs@gmail.com)
+Please cite our work if the code is helpful to you.
+"""
+
+import glob
+import os
+from collections.abc import Sequence
+from .builder import DATASETS
+from .defaults import DefaultDataset
+
+
+@DATASETS.register_module()
+class HM3DDataset(DefaultDataset):
+    def __init__(
+        self,
+        force_label=True,
+        **kwargs,
+    ):
+        # if force_label, only load data with label
+        self.force_label = force_label
+        super().__init__(**kwargs)
+
+    def get_single_data_list(self, split):
+        if self.force_label:
+            data_list = glob.glob(
+                os.path.join(self.data_root, split, "*", "segment.npy")
+            )
+            data_list = [os.path.dirname(data) for data in data_list]
+        else:
+            data_list = glob.glob(os.path.join(self.data_root, split, "*"))
+        return data_list
+
+    def get_data_list(self):
+        if isinstance(self.split, str):
+            data_list = self.get_single_data_list(self.split)
+        elif isinstance(self.split, Sequence):
+            data_list = []
+            for split in self.split:
+                data_list += self.get_single_data_list(split)
+        else:
+            raise NotImplementedError
+        return data_list

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/modelnet.py

@@ -0,0 +1,156 @@
+"""
+ModelNet40 Dataset
+
+get sampled point clouds of ModelNet40 (XYZ and normal from mesh, 10k points per shape)
+at "https://shapenet.cs.stanford.edu/media/modelnet40_normal_resampled.zip"
+
+Author: Xiaoyang Wu (xiaoyang.wu.cs@gmail.com)
+Please cite our work if the code is helpful to you.
+"""
+
+import os
+import numpy as np
+import copy
+import torch
+from torch.utils.data import Dataset
+from copy import deepcopy
+
+
+from pointcept.utils.logger import get_root_logger
+from .builder import DATASETS
+from .transform import Compose
+
+try:
+    import pointops
+except ImportError:
+    pointops = None
+    print("Warning: pointops could not be imported. Some features may be unavailable.")
+
+
+@DATASETS.register_module()
+class ModelNetDataset(Dataset):
+    def __init__(
+        self,
+        split="train",
+        data_root="data/modelnet40",
+        class_names=None,
+        transform=None,
+        num_points=8192,
+        uniform_sampling=True,
+        save_record=True,
+        test_mode=False,
+        test_cfg=None,
+        loop=1,
+    ):
+        super().__init__()
+        self.data_root = data_root
+        self.class_names = dict(zip(class_names, range(len(class_names))))
+        self.split = split
+        self.num_point = num_points
+        self.uniform_sampling = uniform_sampling
+        self.transform = Compose(transform)
+        self.loop = (
+            loop if not test_mode else 1
+        )  # force make loop = 1 while in test mode
+        self.test_mode = test_mode
+        self.test_cfg = test_cfg if test_mode else None
+        if test_mode:
+            self.post_transform = Compose(self.test_cfg.post_transform)
+            self.aug_transform = [Compose(aug) for aug in self.test_cfg.aug_transform]
+
+        self.data_list = self.get_data_list()
+        logger = get_root_logger()
+        logger.info(
+            "Totally {} x {} samples in {} set.".format(
+                len(self.data_list), self.loop, split
+            )
+        )
+
+        # check, prepare record
+        record_name = f"modelnet40_{self.split}"
+        if num_points is not None:
+            record_name += f"_{num_points}points"
+            if uniform_sampling:
+                record_name += "_uniform"
+        record_path = os.path.join(self.data_root, f"{record_name}.pth")
+        if os.path.isfile(record_path):
+            logger.info(f"Loading record: {record_name} ...")
+            self.data = torch.load(record_path, weights_only=False)
+        else:
+            logger.info(f"Preparing record: {record_name} ...")
+            self.data = {}
+            for idx in range(len(self.data_list)):
+                data_name = self.data_list[idx]
+                logger.info(f"Parsing data [{idx}/{len(self.data_list)}]: {data_name}")
+                self.data[data_name] = self.get_data(idx)
+            if save_record:
+                torch.save(self.data, record_path)
+
+    def get_data(self, idx):
+        data_idx = idx % len(self.data_list)
+        data_name = self.data_list[data_idx]
+        if data_name in self.data.keys():
+            return copy.deepcopy(self.data[data_name])
+        else:
+            data_shape = "_".join(data_name.split("_")[0:-1])
+            data_path = os.path.join(
+                self.data_root, data_shape, self.data_list[data_idx] + ".txt"
+            )
+            data = np.loadtxt(data_path, delimiter=",").astype(np.float32)
+            if self.num_point is not None:
+                if self.uniform_sampling:
+                    with torch.no_grad():
+                        mask = pointops.farthest_point_sampling(
+                            torch.tensor(data).float().cuda(),
+                            torch.tensor([len(data)]).long().cuda(),
+                            torch.tensor([self.num_point]).long().cuda(),
+                        )
+                    data = data[mask.cpu()]
+                else:
+                    data = data[: self.num_point]
+            coord, normal = data[:, 0:3], data[:, 3:6]
+            category = np.array([self.class_names[data_shape]])
+            return dict(coord=coord, normal=normal, category=category)
+
+    def get_data_list(self):
+        assert isinstance(self.split, str)
+        split_path = os.path.join(
+            self.data_root, "modelnet40_{}.txt".format(self.split)
+        )
+        data_list = np.loadtxt(split_path, dtype="str")
+        return data_list
+
+    def get_data_name(self, idx):
+        data_idx = idx % len(self.data_list)
+        return self.data_list[data_idx]
+
+    def __getitem__(self, idx):
+        if self.test_mode:
+            return self.prepare_test_data(idx)
+        else:
+            return self.prepare_train_data(idx)
+
+    def __len__(self):
+        return len(self.data_list) * self.loop
+
+    def prepare_train_data(self, idx):
+        data_dict = self.get_data(idx)
+        data_dict = self.transform(data_dict)
+        return data_dict
+
+    def prepare_test_data(self, idx):
+        assert idx < len(self.data_list)
+        data_dict = self.get_data(idx)
+        category = data_dict.pop("category")
+        data_dict = self.transform(data_dict)
+        data_dict_list = []
+        for aug in self.aug_transform:
+            data_dict_list.append(aug(deepcopy(data_dict)))
+        for i in range(len(data_dict_list)):
+            data_dict_list[i] = self.post_transform(data_dict_list[i])
+        data_dict = dict(
+            voting_list=data_dict_list,
+            category=category,
+            name=self.get_data_name(idx),
+        )
+        return data_dict

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/nuscenes.py

@@ -0,0 +1,125 @@
+"""
+nuScenes Dataset
+
+Author: Xiaoyang Wu (xiaoyang.wu.cs@gmail.com), Zheng Zhang
+Please cite our work if the code is helpful to you.
+"""
+
+import os
+import numpy as np
+from collections.abc import Sequence
+import pickle
+
+from .builder import DATASETS
+from .defaults import DefaultDataset
+
+
+@DATASETS.register_module()
+class NuScenesDataset(DefaultDataset):
+    def __init__(self, sweeps=10, ignore_index=-1, **kwargs):
+        self.sweeps = sweeps
+        self.ignore_index = ignore_index
+        self.learning_map = self.get_learning_map(ignore_index)
+        super().__init__(ignore_index=ignore_index, **kwargs)
+
+    def get_info_path(self, split):
+        assert split in ["train", "val", "test"]
+        if split == "train":
+            return os.path.join(
+                self.data_root, "info", f"nuscenes_infos_{self.sweeps}sweeps_train.pkl"
+            )
+        elif split == "val":
+            return os.path.join(
+                self.data_root, "info", f"nuscenes_infos_{self.sweeps}sweeps_val.pkl"
+            )
+        elif split == "test":
+            return os.path.join(
+                self.data_root, "info", f"nuscenes_infos_{self.sweeps}sweeps_test.pkl"
+            )
+        else:
+            raise NotImplementedError
+
+    def get_data_list(self):
+        if isinstance(self.split, str):
+            info_paths = [self.get_info_path(self.split)]
+        elif isinstance(self.split, Sequence):
+            info_paths = [self.get_info_path(s) for s in self.split]
+        else:
+            raise NotImplementedError
+        data_list = []
+        for info_path in info_paths:
+            with open(info_path, "rb") as f:
+                info = pickle.load(f)
+                data_list.extend(info)
+        return data_list
+
+    def get_data(self, idx):
+        data = self.data_list[idx % len(self.data_list)]
+        lidar_path = os.path.join(self.data_root, "raw", data["lidar_path"])
+        points = np.fromfile(str(lidar_path), dtype=np.float32, count=-1).reshape(
+            [-1, 5]
+        )
+        coord = points[:, :3]
+        strength = points[:, 3].reshape([-1, 1]) / 255  # scale strength to [0, 1]
+
+        if "gt_segment_path" in data.keys():
+            gt_segment_path = os.path.join(
+                self.data_root, "raw", data["gt_segment_path"]
+            )
+            segment = np.fromfile(
+                str(gt_segment_path), dtype=np.uint8, count=-1
+            ).reshape([-1])
+            segment = np.vectorize(self.learning_map.__getitem__)(segment).astype(
+                np.int64
+            )
+        else:
+            segment = np.ones((points.shape[0],), dtype=np.int64) * self.ignore_index
+        data_dict = dict(
+            coord=coord,
+            strength=strength,
+            segment=segment,
+            name=self.get_data_name(idx),
+        )
+        return data_dict
+
+    def get_data_name(self, idx):
+        # return data name for lidar seg, optimize the code when need to support detection
+        return self.data_list[idx % len(self.data_list)]["lidar_token"]
+
+    @staticmethod
+    def get_learning_map(ignore_index):
+        learning_map = {
+            0: ignore_index,
+            1: ignore_index,
+            2: 6,
+            3: 6,
+            4: 6,
+            5: ignore_index,
+            6: 6,
+            7: ignore_index,
+            8: ignore_index,
+            9: 0,
+            10: ignore_index,
+            11: ignore_index,
+            12: 7,
+            13: ignore_index,
+            14: 1,
+            15: 2,
+            16: 2,
+            17: 3,
+            18: 4,
+            19: ignore_index,
+            20: ignore_index,
+            21: 5,
+            22: 8,
+            23: 9,
+            24: 10,
+            25: 11,
+            26: 12,
+            27: 13,
+            28: 14,
+            29: ignore_index,
+            30: 15,
+            31: ignore_index,
+        }
+        return learning_map

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/precomputed_features.py

@@ -0,0 +1,80 @@
+import os
+import numpy as np
+from torch.utils.data import Dataset
+from collections.abc import Sequence
+from pointcept.utils.logger import get_root_logger
+from .builder import DATASETS
+from .defaults import DefaultDataset
+import json
+import glob
+
+
+@DATASETS.register_module()
+class PrecomputedFeaturesDataset(DefaultDataset):
+    """
+    Flexible dataset for loading precomputed features from user-specified assets in each sample directory.
+    The user provides a mapping from data_dict keys to asset filenames (without .npy extension).
+    Example config:
+        mapping = {
+            'coord': 'my_coord', (or a list of file names ['X', 'Y', 'Z'])
+            'segment': 'my_label',
+            'feature1': 'my_feature',
+            # ...
+        }
+    """
+
+    def __init__(
+        self,
+        mapping,
+        **kwargs,
+    ):
+        assert "coord" in mapping, "'coord' key must be present in mapping."
+        assert "segment" in mapping, "'segment' key must be present in mapping."
+        self.mapping = mapping
+        super().__init__(**kwargs)
+
+    def get_data(self, idx):
+        data_path = self.data_list[idx % len(self.data_list)]
+        name = self.get_data_name(idx)
+        split = self.get_split_name(idx)
+        if self.cache:
+            cache_name = f"pointcept-{name}"
+            return shared_dict(cache_name)
+
+        data_dict = {}
+        for key, asset in self.mapping.items():
+            if isinstance(asset, str):
+                asset_file = os.path.join(data_path, asset + ".npy")
+                if os.path.exists(asset_file):
+                    asset = np.load(asset_file)
+                    if asset.ndim == 1:
+                        asset = np.expand_dims(asset, axis=1)
+                    data_dict[key] = asset
+                else:
+                    raise FileNotFoundError(
+                        f"Asset file {asset_file} not found for key {key}."
+                    )
+            elif isinstance(asset, (list, tuple)):
+                arrays = []
+                for a in asset:
+                    asset_file = os.path.join(data_path, a + ".npy")
+                    if os.path.exists(asset_file):
+                        asset = np.load(asset_file)
+                        if asset.ndim == 1:
+                            asset = np.expand_dims(asset, axis=1)
+                        arrays.append(asset)
+                    else:
+                        raise FileNotFoundError(
+                            f"Asset file {asset_file} not found for key {key}."
+                        )
+                data_dict[key] = np.concatenate(arrays, axis=1)
+            else:
+                raise ValueError(
+                    f"Mapping for key {key} must be a string or list/tuple of strings."
+                )
+
+        data_dict["name"] = name
+        data_dict["split"] = split
+        data_dict["segment"] = data_dict["segment"].astype(np.int32).squeeze()
+
+        return data_dict

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/preprocessing/arkitscenes/preprocess_arkitscenes_mesh.py

@@ -0,0 +1,93 @@
+"""
+Preprocessing ArkitScenes
+"""
+
+import os
+import argparse
+import glob
+import plyfile
+import numpy as np
+import pandas as pd
+import multiprocessing as mp
+from concurrent.futures import ProcessPoolExecutor
+from itertools import repeat
+from pathlib import Path
+
+
+def read_plymesh(filepath):
+    """Read ply file and return it as numpy array. Returns None if emtpy."""
+    with open(filepath, "rb") as f:
+        plydata = plyfile.PlyData.read(f)
+    if plydata.elements:
+        vertices = pd.DataFrame(plydata["vertex"].data).values
+        faces = np.stack(plydata["face"].data["vertex_indices"], axis=0)
+        return vertices, faces
+
+
+def face_normal(vertex, face):
+    v01 = vertex[face[:, 1]] - vertex[face[:, 0]]
+    v02 = vertex[face[:, 2]] - vertex[face[:, 0]]
+    vec = np.cross(v01, v02)
+    length = np.sqrt(np.sum(vec**2, axis=1, keepdims=True)) + 1.0e-8
+    nf = vec / length
+    area = length * 0.5
+    return nf, area
+
+
+def vertex_normal(vertex, face):
+    nf, area = face_normal(vertex, face)
+    nf = nf * area
+
+    nv = np.zeros_like(vertex)
+    for i in range(face.shape[0]):
+        nv[face[i]] += nf[i]
+
+    length = np.sqrt(np.sum(nv**2, axis=1, keepdims=True)) + 1.0e-8
+    nv = nv / length
+    return nv
+
+
+def parse_scene(scene_path, output_dir):
+    print(f"Parsing scene {scene_path}")
+    split = os.path.basename(os.path.dirname(os.path.dirname(scene_path)))
+    scene_id = os.path.basename(os.path.dirname(scene_path))
+    vertices, faces = read_plymesh(scene_path)
+    coords = vertices[:, :3]
+    colors = vertices[:, 3:6]
+    normals = vertex_normal(coords, faces)
+    data_dict = dict(coord=coords, color=colors, normal=normals)
+    os.makedirs(output_dir / split / scene_id, exist_ok=True)
+    for key in data_dict.keys():
+        np.save(output_dir / split / scene_id / f"{key}.npy", data_dict[key])
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--dataset_root",
+        required=True,
+        help="Path to the ArkitScenes dataset containing 3dod folder",
+    )
+    parser.add_argument(
+        "--output_root",
+        required=True,
+        help="Output path where train/val folders will be located",
+    )
+    parser.add_argument(
+        "--num_workers",
+        default=mp.cpu_count(),
+        type=int,
+        help="Num workers for preprocessing.",
+    )
+    opt = parser.parse_args()
+    # Create output directories
+    train_output_dir = os.path.join(opt.output_root, "Training")
+    os.makedirs(train_output_dir, exist_ok=True)
+    val_output_dir = os.path.join(opt.output_root, "Validation")
+    os.makedirs(val_output_dir, exist_ok=True)
+    # Load scene paths
+    scene_paths = sorted(glob.glob(opt.dataset_root + "/3dod/*/*/*_mesh.ply"))
+    # Preprocess data.
+    pool = ProcessPoolExecutor(max_workers=opt.num_workers)
+    print("Processing scenes...")
+    _ = list(pool.map(parse_scene, scene_paths, repeat(Path(opt.output_root))))

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/preprocessing/hm3d/filter_hm3d.py

@@ -0,0 +1,92 @@
+"""
+Filtering Script for Habitat-Matterport 3D Dataset
+
+filter out and only keep top 10,000 size of processed HM3D
+
+Author: Xiaoyang Wu (xiaoyang.wu.cs@gmail.com)
+Please cite our work if the code is helpful to you.
+"""
+
+import os
+import glob
+import argparse
+import numpy as np
+import shutil
+import tqdm
+from pathlib import Path
+import multiprocessing as mp
+from concurrent.futures import ProcessPoolExecutor
+from itertools import repeat
+
+
+def count_scene(data_path, info_list, lock):
+    data_path = Path(data_path)
+    data_name = data_path.name
+    data_split = data_path.parent.name
+    print(f"Counting {data_name} in {data_split}..")
+    data_size = np.load(data_path / "color.npy").shape[0]
+    with lock:
+        info_list.append(dict(name=data_name, split=data_split, size=data_size))
+
+
+def main_process():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--dataset_root",
+        required=True,
+        help="Path to the Habitat-Matterport 3D dataset containing scene folders",
+    )
+
+    parser.add_argument(
+        "--num_keep",
+        default=10000,
+        type=int,
+        help="Number of scenes that kept for the dataset.",
+    )
+    parser.add_argument(
+        "--num_workers",
+        default=mp.cpu_count(),
+        type=int,
+        help="Num workers for preprocessing.",
+    )
+    args = parser.parse_args()
+
+    scene_list = glob.glob(os.path.join(args.dataset_root, "*", "*"))
+    if len(scene_list) <= args.num_keep:
+        return
+    manager = mp.Manager()
+    lock = manager.Lock()
+    info_list = manager.list()
+
+    # Preprocess data.
+    print("Processing scenes...")
+    pool = ProcessPoolExecutor(max_workers=args.num_workers)
+    _ = list(
+        pool.map(
+            count_scene,
+            scene_list,
+            repeat(info_list),
+            repeat(lock),
+        )
+    )
+    name_list = np.array([scene["name"] for scene in info_list])
+    split_list = np.array([scene["split"] for scene in info_list])
+    size_list = np.array([scene["size"] for scene in info_list])
+    remove_index = np.argsort(size_list)[: len(scene_list) - args.num_keep]
+
+    for split in np.unique(split_list):
+        os.makedirs(os.path.join(args.dataset_root, f"{split}_rm"), exist_ok=True)
+
+    source = [
+        os.path.join(args.dataset_root, split_list[i], name_list[i])
+        for i in remove_index
+    ]
+    target = [
+        os.path.join(args.dataset_root, f"{split_list[i]}_rm") for i in remove_index
+    ]
+    for s, t in zip(source, target):
+        shutil.move(s, t)
+
+
+if __name__ == "__main__":
+    main_process()

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/preprocessing/hm3d/hm3d_constants.py

@@ -0,0 +1,45 @@
+from pathlib import Path
+
+
+CLASS_LABELS_40 = (
+    "wall",  # 0
+    "floor",  # 1
+    "chair",  # 2
+    "door",  # 3
+    "table",  # 4
+    "picture",  # 5
+    "cabinet",  # 6
+    "cushion",  # 7
+    "window",  # 8
+    "sofa",  # 9
+    "bed",  # 10
+    "curtain",  # 11
+    "chest_of_drawers",  # 12
+    "plant",  # 13
+    "sink",  # 14
+    "stairs",  # 15
+    "ceiling",  # 16
+    "toilet",  # 17
+    "stool",  # 18
+    "towel",  # 19
+    "mirror",  # 20
+    "tv_monitor",  # 21
+    "shower",  # 22
+    "column",  # 23
+    "bathtub",  # 24
+    "counter",  # 25
+    "fireplace",  # 26
+    "lighting",  # 27
+    "beam",  # 28
+    "railing",  # 29
+    "shelving",  # 30
+    "blinds",  # 31
+    "gym_equipment",  # 32
+    "seating",  # 33
+    "board_panel",  # 34
+    "furniture",  # 35
+    "appliances",  # 36
+    "clothes",  # 37
+    "objects",  # 38
+    "misc",  # 39
+)

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/preprocessing/hm3d/hm3dsem_category_mappings.tsv

@@ -0,0 +1,2368 @@
+raw_category	category	mpcat40
+,1	unknown	unlabeled
+,4	unknown	unlabeled
+,5	unknown	unlabeled
+,6	unknown	unlabeled
+/unknown/ probably decoration	unknown	unlabeled
+acoustic panel	acoustic panel	misc
+advertisement	advertisement	misc
+aemchair	armchair	chair
+affice chair	office chair	chair
+air conditioner	air conditioner	objects
+air conditioning	air conditioning	objects
+air duct	air duct	misc
+air freshener	air freshener	objects
+air heater	air heater	misc
+air hockey	air hockey	objects
+air purifier	air purifier	objects
+air refresher	air refresher	objects
+air vent	air vent	misc
+air vent fan	air vent fan	objects
+air vent installation	air vent installation	misc
+aisle frame	aisle frame	misc
+alarm	alarm	objects
+alarm clock	alarm clock	objects
+alarm control	alarm control	misc
+alarm controller	alarm controller	misc
+album	album	objects
+albums	albums	objects
+alcohol bottles	alcohol bottles	objects
+american flag	american flag	misc
+amp	amplifier	objects
+amplifier	amplifier	objects
+antique clock	antique clock	objects
+antique telehone	antique telephone	objects
+antique telephone	antique telephone	objects
+antlers	antlers	misc
+apple	apple	objects
+appliance	appliance	misc
+apron	apron	misc
+aquarium	aquarium	misc
+arcade	arcade	misc
+arcade game	arcade game	misc
+arch	arch	misc
+archway	archway	door
+arm chair	armchair	chair
+armchair	armchair	chair
+armchir	armchair	chair
+art	picture	picture
+art frame	art frame	misc
+art piece	art piece	misc
+art work	artwork	picture
+art/clutter	art/clutter	misc
+art/muscle shell	art/muscle shell	misc
+art/statue	art/statue	misc
+artframe	art frame	misc
+artwork	artwork	picture
+artwork frame	artwork frame	misc
+ashtray	ashtray	objects
+attic door	attic door	misc
+attic entrance	attic entrance	misc
+attic hatch	attic hatch	misc
+audio cable	audio cable	misc
+audio cables	audio cables	misc
+audio player	audio player	objects
+axe	axe	objects
+baby chair	baby chair	misc
+baby changing station	baby changing station	misc
+baby changing table	baby changing table	misc
+baby seat	baby seat	misc
+backpack	backpack	objects
+backrest	backrest	objects
+backsplash	backsplash	misc
+bad	unknown	unlabeled
+badside cabinet	bedside cabinet	chest_of_drawers
+bag	bag	objects
+bag with sheets	bag with sheets	objects
+bag with something	bag with something	objects
+bags	bags	objects
+balcony	balcony	misc
+balcony railing	balcony railing	misc
+balcony reiling	balcony railing	misc
+balk	ball	misc
+ball	ball	misc
+ball chair	ball chair	chair
+ball pool	ball pool	objects
+ball pouffe	ball pouffe	seating
+balustrade	balustrade	railing
+banister	banister	railing
+banner	banner	misc
+bar	bar	objects
+bar cabinet	bar cabinet	cabinet
+bar chair	bar chair	chair
+bar soap	bar soap	misc
+barbecue	barbecue	misc
+barbell	barbell	gym_equipment
+barrel	barrel	misc
+bascet	basket	objects
+base	base	misc
+baseball bat	baseball bat	objects
+baseball cap	baseball cap	objects
+baseboard	baseboard	wall
+basin	basin	sink
+basin faucet	basin faucet	objects
+basket	basket	objects
+basket /w books	basket with books	objects
+basket of fruits	basket of fruits	objects
+basket of something	basket of something	misc
+basket of towels	basket of towels	misc
+basket with clothes	basket with clothes	objects
+basket wqith clothes	basket with clothes	objects
+basketball hoop	basketball hoop	gym_equipment
+basketballs	basketballs	objects
+baskets	baskets	objects
+bat tube	bath tub	bathtub
+bath	bath	bathtub
+bath bar	bath bar	misc
+bath cabinet	bath cabinet	cabinet
+bath carpet	bath carpet	floor
+bath cosmetics	bath cosmetics	objects
+bath curtain	bath curtain	curtain
+bath curtain bar	bath curtain bar	misc
+bath dial	bath dial	misc
+bath door	bath door	door
+bath door frame	bath door frame	door
+bath faucet	bath faucet	objects
+bath floor	bath floor	floor
+bath grab bar	bath grab bar	misc
+bath hanger	bath hanger	objects
+bath mat	bath mat	floor
+bath shelf	bath shelf	shelving
+bath shower	bath shower	shower
+bath side table	bath side table	table
+bath sink	bath sink	misc
+bath tap	bath tap	objects
+bath towel	bath towel	towel
+bath towels	bath towels	towel
+bath tub	bath tub	bathtub
+bath tube	bath tub	bathtub
+bath utensil	bath utensil	misc
+bath wall	bath wall	misc
+bathmat	bathmat	floor
+bathrobe	bathrobe	clothes
+bathroom  mat	bathroom mat	floor
+bathroom accessory	bathroom accessory	clothes
+bathroom art	bathroom art	objects
+bathroom cabinet	bathroom cabinet	cabinet
+bathroom cabinet door	bathroom cabinet door	misc
+bathroom cabinet drawer	bathroom cabinet drawer	chest_of_drawers
+bathroom cabint	bathroom cabinet	cabinet
+bathroom counter	bathroom counter	counter
+bathroom floor	bathroom floor	floor
+bathroom glass	bathroom glass	objects
+bathroom mat	bathroom mat	floor
+bathroom mirror	mirror	mirror
+bathroom rug	bathroom rug	floor
+bathroom shelf	bathroom shelf	shelving
+bathroom stuff	bathroom stuff	objects
+bathroom towel	bathroom towel	towel
+bathroom utencills	bathroom utensils	objects
+bathroom utencils	bathroom utensil	objects
+bathroom utensil	bathroom utensil	objects
+bathroom wall	bathroom wall	wall
+bathroom window	bathroom window	window
+bathtub	bathtub	bathtub
+bathtub knob	bathtub knob	misc
+bathtub platform	bathtub platform	misc
+bathtub tap	bathtub tap	objects
+bathtub utensil	bathtub utensil	misc
+bathtube	bathtub	bathtub
+batroom art	bathroom art	objects
+beam	beam	beam
+bean bag chair	bean bag chair	chair
+beanbag	beanbag	chair
+beanbag chair	beanbag chair	chair
+bed	bed	bed
+bed base	bed base	bed
+bed cabinet	bed cabinet	chest_of_drawers
+bed cabinet lamp	bed cabinet lamp	lighting
+bed comforter	bed comforter	misc
+bed curtain	bed curtain	misc
+bed for pet	bed for pet	misc
+bed frame	bedframe	bed
+bed ladder	bed ladder	stairs
+bed lamp	bedside lamp	lighting
+bed light	bed light	misc
+bed sheet	bed sheet	bed
+bed small	bed small	misc
+bed stand	bed stand	misc
+bed table	bed table	table
+bedding	bedding	objects
+bedframe	bedframe	bed
+bedpost	bedpost	bed
+bedroom ceiling	bedroom ceiling	misc
+bedroom table	bedroom table	chest_of_drawers
+bedside cabinet	bedside cabinet	chest_of_drawers
+bedside cabinet door	bedside cabinet door	misc
+bedside cabinet drawer	bedside cabinet drawer	chest_of_drawers
+bedside lamp	bedside lamp	lighting
+bedside table	bedside table	chest_of_drawers
+beer crate	beer crate	misc
+bell	bell	misc
+belt	belt	misc
+bench	bench	seating
+beside table	bedside table	chest_of_drawers
+bicycle	bicycle	objects
+bicycle helmet	bicycle helmet	objects
+bicycle helmets	bicycle helmets	objects
+bidet	bidet	toilet
+big bag	big bag	objects
+bike	bicycle	objects
+billiard balls	billiard balls	objects
+billiard cue	billiard cue	objects
+billiard cues	billiard cues	objects
+bin	bin	objects
+binder	binder	misc
+binders	binders	misc
+birdhouse	birdhouse	misc
+brackboard	blackboard	objects
+blackboard	blackboard	objects
+blanket	blanket	objects
+blanket basket	blanket basket	objects
+blankets	blankets	objects
+blind	blinds	blinds
+blinder	blinds	blinds
+blinds	blinds	blinds
+blouse	blouse	clothes
+board	board	board_panel
+board game	board game	misc
+board games	board games	misc
+board with keys	board with keys	objects
+boards	boards	board_panel
+boat model	boat model	misc
+boiler	boiler	misc
+bojler	boiler	misc
+bonsai tree	bonsai tree	misc
+book	book	objects
+book cabinet	book cabinet	cabinet
+book display	book display	misc
+book rack	book rack	misc
+book shape	bookshelf	shelving
+book shelf	bookshelf	shelving
+bookcase	bookshelf	shelving
+books	book	objects
+bookshelf	bookshelf	shelving
+bookstand	bookstand	shelving
+bootles	bottles	objects
+boots	boots	objects
+bottle	bottle	objects
+bottle dispenser	bottle dispenser	objects
+bottle of  soap	bottle of soap	misc
+bottle of detergent	bottle of detergent	misc
+bottle of soap	bottle of soap	misc
+bottle of water	bottle of water	objects
+bottle of wine	bottle of wine	objects
+bottle opener	bottle opener	misc
+bottlels	bottles	objects
+bottles	bottles	objects
+bottles of water	bottles of water	objects
+bottles of wine	bottles of wine	misc
+bottom of stairs	bottom of stairs	misc
+bouquet	bouquet	objects
+bowl	bowl	objects
+bowl of fruit	bowl of fruit	objects
+bowl of fruits	bowl of fruits	objects
+bowl of sweets	bowl of sweets	objects
+bowl with sweets	bowl with sweets	objects
+bowls	bowls	objects
+box	box	objects
+box with books	box with books	misc
+box /w books	box with books	misc
+box /w shoes	box with shoes	misc
+box /w toys	box with toys	misc
+box of  tissues	box of tissues	misc
+box of food	box of food	misc
+box of fruit	box of fruit	misc
+box of paper	box of paper	misc
+box of something	box of something	misc
+box of tissue	box of tissue	misc
+box of tissues	box of tissues	misc
+box pen	box pen	misc
+box tissues	box of tissues	misc
+box with jewellery	box with jewelry	misc
+box with photos	box with photos	misc
+box with tea	box with tea	misc
+boxes	boxes	objects
+boxes /w books	boxes with books	misc
+boxing ring	boxing ring	objects
+bread	bread	misc
+bread bin	bread bin	misc
+bread box	bread box	misc
+breadbox	breadbox	misc
+breifcase	briefcase	objects
+bricks	bricks	misc
+bridge	bridge	misc
+briefcase	briefcase	objects
+brochure	brochure	objects
+brochures	brochures	objects
+broom	broom	objects
+broom stick	broomstick	misc
+broomstick	broomstick	misc
+brtochure	brochure	objects
+brush	brush	objects
+brushes	brushes	objects
+bucket	bucket	objects
+buckets	buckets	objects
+buffet	buffet	counter
+bulletin board	bulletin board	tv_monitor
+bunk bed	bunk bed	bed
+bureau	bureau	chest_of_drawers
+bust	bust	objects
+button	button	misc
+cabidet	cabinet	cabinet
+cabient	cabinet	cabinet
+cabiinet	cabinet	cabinet
+cabinet	cabinet	cabinet
+cabinet  door	cabinet door	misc
+cabinet /otherroom	cabinet /otherroom	cabinet
+cabinet /w clutter	cabinet /w clutter	cabinet
+cabinet /w cluttered art	cabinet /w cluttered art	misc
+cabinet clutter	cabinet clutter	misc
+cabinet counter	cabinet counter	misc
+cabinet door	cabinet door	misc
+cabinet drawer	cabinet drawer	cabinet
+cabinet kitchen	cabinet kitchen	cabinet
+cabinet mirror	cabinet mirror	cabinet
+cabinet parts	cabinet parts	cabinet
+cabinet table	cabinet table	table
+cable	cable	misc
+cables	cables	misc
+cage	cage	objects
+cailing lamp	ceiling lamp	lighting
+cair	chair	chair
+cake	cake	misc
+calander	calendar	misc
+calculator	calculator	appliances
+calendar	calendar	misc
+camera	camera	objects
+camping chair	camping chair	chair
+can	can	objects
+can of paint	can of paint	misc
+canal	canal	misc
+candel	candle	objects
+candelabra	candelabra	objects
+candle	candle	objects
+candle holder	candle holder	objects
+candle stand	candle stand	objects
+candles	candle	objects
+candlestick	candlestick	objects
+canister	canister	misc
+canoe	canoe	objects
+canopy	canopy	misc
+cans	cans	objects
+cans of paint	cans of paint	objects
+canvas	canvas	misc
+cap	cap	clothes
+car	car	objects
+car model	car model	objects
+carboard box	cardboard box	misc
+card	card	misc
+cardboard	cardboard	misc
+cardboard box	cardboard box	misc
+cardboardbox	cardboard box	misc
+carpet	carpet	floor
+carpet roll	carpet roll	misc
+cart	cart	objects
+cartboard	cardboard	misc
+case	case	misc
+cases	cases	misc
+cash register	cash register	objects
+casket	casket	misc
+cat	cat	misc
+cat bed	cat bed	bed
+cat food	cat food	misc
+cat food bag	cat food bag	misc
+cat litter box	cat litter box	toilet
+cat tree	cat tree	objects
+cats toilet	cat toilet	toilet
+cd	cd	objects
+cd player	cd player	appliances
+cd's	cds	objects
+cds	cds	objects
+cebinet	cabinet	cabinet
+ceiiling	ceiling	ceiling
+ceiling balk	unknown	unlabeled
+ceiilng	ceiling	ceiling
+ceiliing	ceiling	ceiling
+ceiliing lamp	ceiling lamp	lighting
+ceiling	ceiling	ceiling
+ceiling  lamp	ceiling lamp	lighting
+ceiling  light	ceiling light	lighting
+ceiling  vent	ceiling vent	misc
+ceiling /otheroom	ceiling	ceiling
+ceiling /otherroom	ceiling	ceiling
+ceiling air vent	ceiling vent	misc
+ceiling arch	ceiling arch	ceiling
+ceiling bedroom	ceiling bedroom	misc
+ceiling boarder	ceiling boarder	misc
+ceiling border	ceiling border	ceiling
+ceiling chasis	ceiling chassis	ceiling
+ceiling corridor	ceiling corridor	misc
+ceiling decorative lamp	ceiling decorative lamp	lighting
+ceiling dome	ceiling dome	misc
+ceiling door	ceiling door	misc
+ceiling duck	ceiling duct	ceiling
+ceiling duct	ceiling duct	ceiling
+ceiling fan	ceiling fan	objects
+ceiling fan lamp	ceiling fan lamp	lighting
+ceiling fan vent	ceiling fan vent	misc
+ceiling fire detector	ceiling fire detector	objects
+ceiling fixture	ceiling fixture	misc
+ceiling floor	ceiling floor	floor
+ceiling hanger	ceiling hanger	objects
+ceiling ladder	ceiling ladder	objects
+ceiling lamp	ceiling lamp	lighting
+ceiling lamp hanger	ceiling lamp hanger	lighting
+ceiling lamp rail	ceiling lamp rail	lighting
+ceiling lan	ceiling fan	objects
+ceiling light	ceiling light	lighting
+ceiling light fixture connection	ceiling light fixture connection	misc
+ceiling llower	ceiling lower	misc
+ceiling lower	ceiling lower	misc
+ceiling molding	ceiling molding	misc
+ceiling panel	ceiling panel	ceiling
+ceiling pipe	ceiling pipe	ceiling
+ceiling pipes	ceiling pipe	ceiling
+ceiling support	ceiling support	ceiling
+ceiling under staircase	ceiling under staircase	misc
+ceiling under stairs	ceiling under stairs	misc
+ceiling vent	ceiling vent	misc
+ceiling wall	ceiling wall	misc
+ceiling window	ceiling window	misc
+ceiling/ wall west	ceiling/west wall	misc
+ceiling/ west wall	ceiling/west wall	misc
+ceiling/west wall	ceiling/west wall	misc
+ceilling	ceiling	ceiling
+ceilling lamp	ceiling lamp	lighting
+celing	ceiling	ceiling
+celing lamp	ceiling lamp	lighting
+celing lower	ceiling lower	misc
+central heating furnace	central heating furnace	appliances
+ceramics	ceramics	objects
+cerpet	carpet	floor
+certain	curtain	curtain
+chain	chain	objects
+chair	chair	chair
+chair /otherroom	chair	chair
+chair /w clutter	chair /w clutter	chair
+chair stand	chair stand	misc
+chaise	chaise	chair
+chaise longue	chaise longue	sofa
+chamber pot	chamber pot	toilet
+chandelier	chandelier	lighting
+changing table	changing table	table
+charger	charger	objects
+chasis	chassis	objects
+chess	chess	misc
+chest	chest	misc
+chest bench	chest bench	misc
+chest drawer	chest drawer	misc
+chest drawers	chest of drawers	chest_of_drawers
+chest of drawer	chest of drawer	chest_of_drawers
+chest of drawers	chest of drawers	chest_of_drawers
+chest of drawres	chest of drawers	chest_of_drawers
+chest of dreawers	chest of drawers	chest_of_drawers
+chiar	chair	chair
+child car seat	child car seat	objects
+chimney	chimney	misc
+christmas tree	christmas tree	misc
+cieling	ceiling	ceiling
+circular sofa	circular sofa	sofa
+clarinet	clarinet	objects
+cleaner	cleaner	objects
+cleaner bottle	cleaner bottle	objects
+cleaner brush	cleaner brush	objects
+cleaning clutter	cleaning clutter	misc
+cleaning fluid	cleaning fluid	objects
+cleaning liquid	cleaning liquid	objects
+cleaning paper	cleaning paper	objects
+cleaning paste	cleaning paste	objects
+cleaning powders/ liquids	cleaning powders/ liquids	objects
+cleaning sponge	cleaning sponge	objects
+cleaning spray	cleaning spray	objects
+clock	clock	objects
+closet	closet	cabinet
+closet area for hanging clothes	closet area for hanging clothes	misc
+closet door	closet door	door
+closet floor	closet floor	misc
+closet mirror wall	closet mirror wall	misc
+closet rod	closet rod	objects
+closet shelf	closet shelf	shelving
+closet shelving	closet shelving	misc
+closet storage area	closet storage area	misc
+clotes dryer	clothes dryer	appliances
+cloth	cloth	objects
+cloth dryer	cloth dryer	appliances
+cloth hanger	cloth hanger	objects
+cloth hangers	cloth hangers	objects
+cloth holder	cloth holder	objects
+clothes	clothes	clothes
+clothes  rack	clothes rack	misc
+clothes bag	clothes bag	misc
+clothes container	clothes container	misc
+clothes dryer	clothes dryer	appliances
+clothes hamper	clothes hamper	objects
+clothes hanger	clothes hanger	objects
+clothes hanger rod	clothes hanger rod	objects
+clothes on shelf	clothes on shelf	clothes
+clothes rack	clothes rack	misc
+clothing stand	clothing stand	misc
+clutter	clutter	misc
+coach	coach	misc
+coaster	coaster	objects
+coat	coat	clothes
+coat hanger	coat hanger	objects
+coat rack	coat rack	misc
+cofee table	coffee machine	appliances
+coffe machine	coffee machine	appliances
+coffe table	coffee table	table
+coffee machine	coffee machine	appliances
+coffee maker	coffee maker	appliances
+coffee mug	coffee mug	objects
+coffee table	coffee table	table
+coffie machine	coffee machine	appliances
+coffiee machine	coffee machine	appliances
+coffiee table	coffee table	table
+coffy table	coffee table	table
+column	column	misc
+compound wall	compound wall	misc
+compressor	compressor	appliances
+computer	computer	objects
+computer chair	computer chair	chair
+computer desk	computer desk	table
+computer equipment	computer equipment	misc
+computer mouse	computer mouse	objects
+computer tower	computer tower	objects
+condensation furnace	condensation furnace	objects
+condiment	condiment	misc
+cone	cone	misc
+conference phone	conference phone	appliances
+console	console	objects
+console pad	console pad	objects
+console pad charger	console pad charger	misc
+construction stuff	construction stuff	misc
+container	container	objects
+containers	containers	objects
+control	control	objects
+control panel	control panel	objects
+controller	controller	objects
+coocker	cooker	objects
+cooffe machine	coffee machine	appliances
+cookbook	cook book	objects
+cooker	cooker	objects
+cooker hood	cooker hood	appliances
+cookies	cookies	misc
+copier	copier	objects
+copier machine	copier machine	misc
+cork board	cork board	objects
+cornice	cornice	misc
+cosmetic	cosmetic	objects
+cosmetics	cosmetics	objects
+couch	couch	sofa
+counter	counter	counter
+counter desk	counter desk	table
+counter door	counter door	misc
+countertop	countertop	counter
+countertop /otherroom	countertop /otherroom	counter
+countertop item	countertop item	misc
+courtain	curtain	curtain
+cover	cover	misc
+cradle	cradle	bed
+crate	crate	objects
+crayon	crayon	objects
+crib	crib	misc
+cross	cross	objects
+cross-trainer	cross-trainer	gym_equipment
+crutches	crutches	objects
+cuddly toy	cuddly toy	misc
+cup	cup	objects
+cupboard	cabinet	cabinet
+cups	cups	objects
+curatin	curtain	curtain
+curb	curb	objects
+curtain	curtain	curtain
+curtain  rod	curtain rod	curtain
+curtain /otheroom	curtain	curtain
+curtain bar	curtain bar	curtain
+curtain box	curtain box	curtain
+curtain hanger	curtain hanger	curtain
+curtain rail	curtain rail	misc
+curtain rod	curtain rod	curtain
+curtain rod cover	curtain rod cover	curtain
+curtain valence	curtain valence	curtain
+curtains	curtain	curtain
+cushiom	cushion	cushion
+cushion	cushion	cushion
+cutlery	cutlery	objects
+cutting board	cutting board	objects
+cutting boards	cutting board	objects
+cyp	cyp	misc
+dacorative plant	decorative plant	plant
+dartboard	dartboard	objects
+deccoration	decoration	objects
+deck chair	deck chair	chair
+decoartive plate	decorative plate	misc
+decoder	decoder	misc
+decooration	decoration	objects
+decor	decor	objects
+decor plate	decorative plate	misc
+decoratinon	decoration	objects
+decoratiom	decoration	objects
+decoration	decoration	objects
+decoration bowl	decorative bowl	objects
+decoration plan	decorative plant	misc
+decoration plant	decorative plant	misc
+decoration window	decorative window	misc
+decorations	decoration	objects
+decorative bottle	decorative bottle	objects
+decorative bowl	decorative bowl	objects
+decorative ceramic	decorative ceramic	objects
+decorative cloth	decorative cloth	objects
+decorative dinnerware	decorative dinnerware	objects
+decorative frame	decorative frame	objects
+decorative lamp	decorative lamp	objects
+decorative lantern	decorative lantern	objects
+decorative mask	decorative mask	objects
+decorative pl;ant	decorative plant	misc
+decorative plant	decorative plant	misc
+decorative plants	decorative plant	misc
+decorative plate	decorative plate	misc
+decorative quilt	decorative quilt	misc
+decorative tray	decorative tray	objects
+decorative vase	decorative vase	objects
+decorative vessel	decorative vessel	objects
+decoratrion	decoration	objects
+decoratrive plant	decorative plant	misc
+decorayion	decoration	objects
+decotarion	decoration	objects
+decration	decoration	objects
+dehumidifier	dehumidifier	objects
+den	den	misc
+desk	desk	table
+desk cabinet	desk cabinet	cabinet
+desk chair	desk chair	chair
+desk clutter	desk clutter	misc
+desk door	desk door	cabinet
+desk lamp	desk lamp	lighting
+desk organizer	desk organizer	objects
+detergent bottle	detergent bottle	objects
+detergent bottles	detergent bottle	objects
+detergents	detergent	misc
+device	device	misc
+device/ probably paper shredder	device	misc
+dining chair	dining chair	chair
+dining table	dining table	table
+dinner chair	dinner chair	chair
+dinner table	dinner table	table
+dinnerware	dinnerware	objects
+dinnerware decoration	decorative dinnerware	objects
+diplom	diploma	misc
+diploma	diploma	misc
+dirt ground	dirt ground	misc
+dish	dish	objects
+dish cabinet	dish cabinet	cabinet
+dish dryer	dish dryer	appliances
+dish rack	dish rack	objects
+dish washer	dishwasher	appliances
+dish with food	dish	objects
+dishawasher	dishwasher	appliances
+dishes	dishes	objects
+dishes dryer	dish dryer	appliances
+dishrag	dishrag	objects
+dishwasher	dishwasher	appliances
+dishwasher machine	dishwasher	appliances
+disk	dish	objects
+dispenser	dispenser	objects
+display	display	tv_monitor
+display cabinet	display cabinet	cabinet
+display case	display case	objects
+display of pictures	display of pictures	picture
+display table	display table	table
+document	document	misc
+document holder	document holder	objects
+documents	document	misc
+dog bed	dog bed	bed
+dog leash	dog leash	misc
+dog toy	dog toy	objects
+doile	doily	misc
+doily	doily	misc
+doll	doll	objects
+dool	doll	objects
+door	door	door
+door  frame	door frame	door
+door  hinge	door hinge	misc
+door /otherroom	door /otherroom	door
+door cabinet	door cabinet	cabinet
+door drame	door frame	door
+door f	door frame	door
+door fame	door frame	door
+door fframe	door frame	door
+door frame	door frame	door
+door framr	door frame	door
+door handle	door handle	misc
+door hanger	door handle	misc
+door hine	door hinge	misc
+door hinge	door hinge	misc
+door kinge	door hinge	misc
+door knob	door knob	misc
+door mat	doormat	floor
+door rame	door frame	door
+door slide	sliding door	door
+door stoper	door stopper	misc
+door stopper	door stopper	misc
+door stoppper	door stopper	misc
+door window	door window	misc
+door/window	door/window	misc
+door/window frame	door/window frame	misc
+doorbell	doorbell	misc
+doorf rame	door frame	door
+doorframe	door frame	door
+doormat	doormat	floor
+doorpost	doorpost	objects
+doors	door	door
+doorstep	doorstep	objects
+doorway	doorway	door
+dorr	door	door
+double armchair	double armchair	chair
+drain	drain	objects
+drainage	drainage	misc
+drainpipe	drainpipe	objects
+draw	draw	objects
+drawer	drawer	chest_of_drawers
+drawer cabinet	drawer cabinet	cabinet
+drawer cart	drawer cart	objects
+drawer desk	drawer desk	misc
+drawer sink table	drawer sink table	misc
+drawers	drawers	chest_of_drawers
+drawers for clothes	drawers for clothes	misc
+drawing	drawing	misc
+dreser	dresser	chest_of_drawers
+dress	dress	clothes
+dresser	dresser	chest_of_drawers
+dressing table	dressing table	table
+dried flowers	dried flowers	objects
+drill	drill	misc
+drum	drum	objects
+drums	drum	objects
+dryer	clothes dryer	appliances
+drywall board	drywall board	misc
+drywall boards	drywall board	misc
+duct	duct	misc
+dumb bell	dumbbell	gym_equipment
+dumb-bells	dumbbell	gym_equipment
+dumbbel	dumbbell	gym_equipment
+dumbbell	dumbbell	gym_equipment
+dumbbell handles	dumbbell	gym_equipment
+dumbbells	dumbbell	gym_equipment
+dust bin	dustbin	objects
+dustbin	dustbin	objects
+dustpan	dustpan	objects
+duvet	duvet	misc
+dvd	dvd	objects
+dvd movies	dvd	objects
+dvd player	dvd player	objects
+dvds	dvd	objects
+easel	easel	shelving
+easels	easel	shelving
+easy chair	easy chair	chair
+electric box	electric box	misc
+electric cable	electric cable	misc
+electric cord	electric cord	misc
+electric device	electric device	misc
+electric drums	electric drum	objects
+electric freshener	electric freshener	appliances
+electric guitar	electric guitar	objects
+electric guitar pack	electric guitar	objects
+electric heater	electric heater	appliances
+electric hub	electric hub	objects
+electric installation	electric installation	misc
+electric kettle	electric kettle	appliances
+electric outlet	electric outlet	objects
+electric percussion	electric percussion	appliances
+electric plug	electric plug	objects
+electric toothbrush	electric toothbrush	appliances
+electric wire	electric wire	misc
+electric wire casing	electric wire casing	misc
+electrical box	electrical box	objects
+electrical controller	electrical controller	misc
+electrical device	electrical device	misc
+electrical installation	electrical installation	misc
+electrical switchboard	electrical switchboard	misc
+electricity box	electricity box	misc
+electronics	electronics	misc
+elephant sculpture	elephant sculpture	misc
+elevator	elevator	misc
+elevator door	elevator door	door
+emergency sign	emergency sign	misc
+end table	end table	table
+entertainment set	entertainment set	misc
+entrance arch	entrance arch	misc
+entry phone	entry phone	objects
+excercise mat	exercise mat	gym_equipment
+excersie ball	exercise ball	gym_equipment
+excersie equipment	exercise equipment	gym_equipment
+exercise ball	exercise ball	gym_equipment
+exercise bike	exercise bike	gym_equipment
+exercise equipment	exercise equipment	gym_equipment
+exercise ladder	exercise ladder	gym_equipment
+exercise machine	exercise machine	misc
+exercise mat	exercise mat	gym_equipment
+exercise mat roll	exercise mat roll	misc
+exercising blocks	exercising blocks	gym_equipment
+exhaust pipe	exhaust pipe	misc
+exhibition panel	exhibition panel	misc
+exhibition picture	exhibition picture	picture
+exhibition table	exhibition table	table
+exhibition window	exhibition window	window
+exhibition window frame	exhibition window frame	window
+exit sign	exit sign	misc
+extension cord	extension cord	misc
+extension lead	extension lead	misc
+extinguisher	fire extinguisher	objects
+extractor	extractor	misc
+extractor hood	extractor hood	misc
+eyeglasses	eyeglasses	objects
+fan	fan	objects
+fan-coil	fan coil	objects
+fan air vent	fan air vent	misc
+fans	fan	objects
+faucet	faucet	objects
+fence	fence	misc
+fframe	frame	misc
+figure	figure	misc
+figurine	figurine	misc
+file	file	misc
+file binder	file binder	misc
+file cabinet	file cabinet	cabinet
+files	file	misc
+fire alarm	fire alarm	objects
+fire detector	fire detector	objects
+fire etenguisher	fire extinguisher	objects
+fire extinguisher	fire extinguisher	objects
+fire pit	fire pit	objects
+fire screen	fire screen	objects
+fire sprinkler	fire sprinkler	misc
+firebox	firebox	objects
+fireplace	fireplace	fireplace
+fireplace brush	fireplace brush	misc
+fireplace floor	fireplace floor	misc
+fireplace mirror	fireplace mirror	misc
+fireplace sconce	fireplace sconce	misc
+fireplace shelf	fireplace shelf	misc
+fireplace tool set	fireplace tool set	misc
+fireplace utensil	fireplace utensil	misc
+fireplace wall	fireplace wall	misc
+firewood	firewood	misc
+firewood bag	firewood bag	misc
+firewood chest	firewood chest	misc
+firewood holder	firewood holder	misc
+fish tank	fish tank	misc
+fishing pole	fishing pole	misc
+fishing rod	fishing rod	misc
+fitness ball	fitness ball	gym_equipment
+flag	flag	misc
+flashlight	flashlight	objects
+floer	floor	floor
+floor	floor	floor
+floor  lamp	floor lamp	lighting
+floor  mat	floor mat	floor
+floor  vent	floor vent	misc
+floor /otherroom	floor /otherroom	floor
+floor /outside	floor /outside	floor
+floor lamp	floor lamp	lighting
+floor mat	floor mat	floor
+floor stand	floor stand	misc
+floor vent	floor vent	misc
+floormat	floor mat	floor
+florr	floor	floor
+flower	flower	plant
+flower  vase	flower vase	objects
+flower pot	flowerpot	objects
+flower stand	flower stand	misc
+flower vase	flower vase	objects
+flowerbed	flowerbed	objects
+flowerpot	flowerpot	objects
+flowers	flowers	plant
+flowers in vase	flower vase	objects
+fluorescent light	fluorescent light	misc
+flush	flush	misc
+flush button	flush button	misc
+flush buttons	flush button	misc
+flush push	flush push	misc
+folded chair	folded chair	chair
+folded chairs	folded chair	chair
+folded table	folded table	table
+folder	folder	objects
+folders	folder	objects
+folding chair	folding chair	chair
+folding stand	folding stand	misc
+food	food	misc
+food processor	food processor	appliances
+food stand	food stand	misc
+food tray	food tray	objects
+foor frame	floor frame	floor
+foor lamp	floor lamp	lighting
+foosball game table	foosball game table	table
+foosball table	foosball table	table
+foot rest	footrest	stool
+foot spa	foot spa	misc
+foot stand	foot stand	misc
+football	football	objects
+footrest	footrest	stool
+footstool	footstool	stool
+fork	fork	objects
+frame	frame	misc
+frame door	frame	misc
+frame part	frame	misc
+framed document	document	misc
+framed mirror	mirror	mirror
+framed photo	photo	picture
+framed photos	photos	picture
+framed picture	picture	picture
+framed pictures	pictures	picture
+framed text	framed text	misc
+freezer	freezer	appliances
+fridge	refrigerator	appliances
+fruit	fruit	objects
+fruit bowl	fruit bowl	objects
+fruits	fruit	objects
+frying pan	frying pan	objects
+fume cupboard	fume cupboard	misc
+fur	fur	misc
+fur carpet	fur carpet	floor
+furnace	furnace	misc
+furniture	furniture	furniture
+furniture parts	furniture	furniture
+fuse box	fuse box	misc
+fuse panel	fuse panel	misc
+game board	game board	objects
+game console	game console	objects
+gap	gap	objects
+garage door	garage door	door
+garage door frame	garage door frame	misc
+garage door motor	garage door motor	misc
+garage door opener	garage door opener	misc
+garage door opener bar	garage door opener bar	misc
+garage door opener motor	garage door opener motor	misc
+garage door opener railing	garage door opener railing	misc
+garage door railing	garage door railing	misc
+garage light	garage light	misc
+garden bench	garden bench	seating
+garden chair	garden chair	chair
+garden deck	garden deck	misc
+garden hose	hose	misc
+garden swing	swing	objects
+gas box	gas box	objects
+gas container	gas container	objects
+gas furnace	gas furnace	appliances
+gas meter	gas meter	misc
+gate	gate	misc
+gauge	gauge	misc
+gift	gift	misc
+glass	glass	objects
+glass bottle	bottle	objects
+glass container	glass container	objects
+glass door	glass door	door
+glass pane	glass pane	misc
+glasses	glasses	objects
+globe	globe	misc
+globe stand	globe stand	misc
+glove	gloves	objects
+gloves	gloves	objects
+glue	glue	objects
+goal	goalpost	objects
+golf sticks	golf sticks	objects
+grab bar	grab bar	misc
+gramophone	gramophone	objects
+grandfather clock	grandfather clock	objects
+grass	grass	plant
+grate	grate	misc
+gravel	gravel	floor
+grill	grill	misc
+groceries	groceries	objects
+guitar	guitar	objects
+guitar amp	amplifier	objects
+guitar amplifier	amplifier	objects
+guitar box	amplifier	objects
+guitar case	guitar case	objects
+guitar case suit	guitar case cover	objects
+guitar cases	guitar cases	objects
+guitar frame	guitar frame	objects
+guitar pedals	guitar pedals	objects
+guitar stand	guitar stand	objects
+guitar straps	guitar straps	objects
+gun	gun	objects
+gutter	gutter	misc
+gym equipment	gym equipment	gym_equipment
+gym mat	gym mat	floor
+gym rope	gym rope	objects
+gym stepper	gym stepper	objects
+gym-equipment	gym equipment	gym_equipment
+hair dryer	hair dryer	objects
+hairbrush	hair brush	objects
+hairdryer	hair dryer	objects
+hammer	hammer	objects
+hammock	hammock	bed
+hand cart	handcart	objects
+hand cloth	hand cloth	misc
+hand drier	hand dryer	objects
+hand soap	hand soap	objects
+hand towel	hand towel	objects
+handbag	handbag	objects
+handkerchiefs	handkerchiefs	objects
+handle	handle	objects
+handrail	handrail	railing
+handhold	handrail	railing
+handshower	showerhead	shower
+hanger	hanger	objects
+hangers	hanger	objects
+hanging clothes	hanging clothes	clothes
+hat	hat	clothes
+hatch	hatch	misc
+hats	hats	objects
+headboard	headboard	bed
+headphones	headphones	objects
+headset	headset	objects
+hearth	hearth	misc
+heat vent	vent	misc
+heater	heater	objects
+heater  piping	heater piping	misc
+heater piping	heater piping	misc
+heating furnace part	furnace	misc
+heating vent	vent	misc
+herb basket	basket	objects
+hi hat	hi-hat	objects
+hi hat stand	hi-hat stand	objects
+high chair	highchair	chair
+high shelf	high shelf	misc
+highchair	highchair	chair
+highchairs	highchair	chair
+holder	holder	objects
+holy cross	holy cross	misc
+hood	range hood	objects
+hook	hook	misc
+hose	hose	misc
+hot drinks machine	beverage dispenser	objects
+hot water/cold water knob	hot water/cold water knob	misc
+hourglass	hourglass	objects
+hoverboard	hoverboard	objects
+hunting trophy	hunting trophy	misc
+hutch	hutch	misc
+ice maker	ice maker	objects
+icebox	icebox	appliances
+identifier	identifier	misc
+image	picture	picture
+indow curtain	window curtain	curtain
+induction hob	stovetop	misc
+information	information	misc
+insect door	door screen	door
+door screen	door screen	door
+installation	installation	objects
+instrument	instrument	objects
+iron	iron	objects
+iron board	iron board	misc
+ironing board	ironing board	objects
+island	island	counter
+jacket	jacket	clothes
+jacuzzi	jacuzzi	misc
+jar	jar	objects
+jars	jars	objects
+jewellery	jewelry	objects
+jewellery ehibition	jewelry	objects
+jewellery exhibition	jewelry	objects
+jewellery exposition	jewelry	objects
+jewelry	jewelry	objects
+jewelry box	jewelry box	misc
+jewlery box	jewelry box	misc
+joga mat	yoga mat	misc
+jug	jug	objects
+junk	junk	objects
+keg	keg	objects
+kegerator	keg	objects
+kettle	kettle	objects
+keyboard	keyboard	objects
+keyboard box	keyboard box	objects
+keyboard case suit	keyboard cover	objects
+keyboard piano	keyboard piano	objects
+keyboard stand	keyboard stand	objects
+keys	keys	objects
+kitchen appliance	kitchen appliance	appliances
+kitchen board	cutting board	objects
+kitchen cabinet	kitchen cabinet	cabinet
+kitchen cabinet door	kitchen cabinet door	cabinet
+kitchen cabinet drawer	kitchen cabinet drawer	cabinet
+kitchen cabinet lower	kitchen cabinet lower	cabinet
+kitchen ceiling	kitchen ceiling	ceiling
+kitchen chair	kitchen chair	chair
+kitchen coocking cabinet	kitchen cabinet	cabinet
+kitchen counter	kitchen counter	counter
+kitchen counter support	kitchen counter support	misc
+kitchen countertop	kitchen counter	counter
+kitchen countertop item	kitchen countertop item	misc
+kitchen countertop items	kitchen countertop items	misc
+kitchen coutertop item	kitchen counter item	objects
+kitchen decoration	kitchen decoration	objects
+kitchen extractor	kitchen extractor	misc
+kitchen glowes	kitchen gloves	objects
+kitchen handle	kitchen handle	objects
+kitchen hood	range hood	objects
+kitchen island	kitchen island	counter
+kitchen knife set	kitchen knife set	objects
+kitchen lower cabinet	kitchen lower cabinet	cabinet
+kitchen lower shelf	kitchen lower shelf	shelving
+kitchen shelf	kitchen shelf	shelving
+kitchen sink	kitchen sink	sink
+kitchen sink cabinet	kitchen sink cabinet	cabinet
+kitchen sitting	kitchen seating	seating
+kitchen stuff	clutter	misc
+kitchen table	kitchen table	table
+kitchen tools	kitchen utensils	objects
+kitchen top	kitchen top	counter
+kitchen towel	kitchen towel	objects
+kitchen untensils	kitchen utensils	objects
+kitchen upper cabinet	kitchen cabinet	cabinet
+kitchen utensil	kitchen utensil	objects
+kitchen utensils	kitchen utensils	objects
+kitchen wall	kitchen wall	wall
+kitchen walll	kitchen wall	wall
+kitchenware	kitchenware	objects
+kitchhen cabinet door	kitchen cabinet door	cabinet
+kitcyhen cabinet	kitchen cabinet	cabinet
+knife	knife	objects
+knife holder	knife holder	misc
+knife set	knife set	objects
+knife stand	knife stand	objects
+knob	knob	misc
+knofe set	knife set	objects
+l-shaped sofa	l-shaped sofa	sofa
+lace doily	lace doily	objects
+lacy doily	lace doily	objects
+ladder	ladder	stairs
+lamp	lamp	lighting
+lamp ceiling	ceiling lamp	lighting
+lamp desk	desk lamp	lighting
+lamp shade	lamp shade	lighting
+lamp stand	lamp stand	misc
+lamp table	lamp table	table
+lamps	lamp	lighting
+lampshade	lampshade	lighting
+landing	landing	floor
+lantern	lantern	lighting
+laptop	laptop	objects
+laundry	laundry	clothes
+laundry bag	laundry bag	misc
+laundry basket	laundry basket	objects
+laundry machine	laundry machine	misc
+launger	lounger	seating
+lawn	lawn	floor
+lawn mower	lawn mower	objects
+lawnmower	lawn mower	objects
+leaflet	leaflets	objects
+leaflets	leaflets	objects
+led  tv	led tv	misc
+led tv	led tv	misc
+ledge	ledge	objects
+ledtv	led tv	misc
+leg rest	leg rest	misc
+letter	document	misc
+level	level	objects
+lid	lid	misc
+lids	lid	misc
+light	light	lighting
+light fixture	light fixture	lighting
+light switch	light switch	objects
+lighter	lighter	objects
+lighting fixture	lighting fixture	objects
+lighting grid	lighting fixture	objects
+lights	light	lighting
+liquid	liquid	misc
+liquid container	liquid container	objects
+liquid cleaner	liquid cleaner	objects
+liquid soap	liquid soap	misc
+lmap	lamp	lighting
+locker	locker	misc
+loft hatch	hatch	misc
+logs	firewood	misc
+lounge chair	lounge chair	chair
+lounger	lounger	seating
+lower cabinet	lower cabinet	cabinet
+luggage	luggage	objects
+lundry basket	laundry basket	objects
+machine	machine	objects
+magazine	magazine	objects
+magazine rack	magazine rack	misc
+magazines	magazines	objects
+magazines, albums	magazines	objects
+magazines, albums, bookshelf	magazines	objects
+magazines, books and albums	magazines	objects
+magic marker	magic marker	objects
+magic marker box	magic marker box	objects
+mail	mail	objects
+mailbox	mailbox	objects
+make up accesories	makeup accessories	objects
+mannequin	mannequin	objects
+mantel	mantel	fireplace
+mantle	mantle	fireplace
+map	map	objects
+mascot	mascot	objects
+mascots	mascots	objects
+mask decoration	decoration	objects
+massage bed	massage bed	bed
+mat	mat	floor
+mat floor	mat	floor
+material	material	misc
+mattress	bed	bed
+measuring tape	measuring tape	objects
+medal	medal	objects
+medal collection	medal collection	objects
+media console	media console	misc
+medical lamp	medical lamp	lighting
+medical object	medical object	objects
+menu	menu	objects
+menu board	menu board	objects
+meshwork	meshwork	misc
+meter	meter	misc
+microphone	microphone	objects
+microphone accesory	microphone accessory	objects
+microvawe	microwave	appliances
+microwave	microwave	appliances
+microweave	microwave	appliances
+midi keyboard	keyboard piano	objects
+mini fridge	mini fridge	appliances
+miocrowave	microwave	appliances
+mircowave	microwave	appliances
+miror	mirror	mirror
+mirror	mirror	mirror
+mirror /otherroom	mirror /otherroom	mirror
+mirror door	mirror door	misc
+mirror frame	mirror frame	mirror
+mirror stand	mirror	mirror
+mixer	mixer	misc
+mobile	mobile	objects
+model	model	objects
+modem	modem	objects
+molding	molding	wall
+monitor	monitor	tv_monitor
+moose head/sculpture/hunting trophy	moose head/sculpture/hunting trophy	misc
+mop	mop	objects
+mortar	mortar	misc
+motion detector	motion detector	misc
+motion sensor	motion detector	misc
+motorcycle	motorcycle	objects
+mouse	mouse	objects
+mousepad	mousepad	objects
+mug	mug	objects
+multi-gym	gym equipment	gym_equipment
+music album shelf	music album shelf	shelving
+music player	music player	objects
+music stand	music equipment stand	objects
+musical equipment	music equipment	objects
+napkin	napkin	objects
+napkins	napkins	objects
+newspaper	newspaper	misc
+newspaper basket	newspaper basket	objects
+niche	niche	wall
+nighstand	nightstand	chest_of_drawers
+night lamp	night lamp	lighting
+night stand	nightstand	chest_of_drawers
+night table	nightstand	chest_of_drawers
+nightsand	nightstand	chest_of_drawers
+nightstand	nightstand	chest_of_drawers
+nigtstand	nightstand	chest_of_drawers
+note	note	objects
+notebook	notebook	objects
+notebooks	notebooks	objects
+notes	notes	objects
+noticeboard	note board	objects
+oar	oar	objects
+object	object	objects
+objects	objects	objects
+office chair	office chair	chair
+office wall	office wall	wall
+office drawer	drawers	chest_of_drawers
+office phone	phone	objects
+office stuff	stationery	objects
+office table	office table	table
+office utensils	utensil	objects
+oil lamp	oil lamp	lighting
+organizer drawers	drawers	chest_of_drawers
+ornament	ornament	objects
+ornament flower	flower	plant
+ornament plant	plant	plant
+ornamental plant	plant	plant
+ornamental plate	plate	objects
+ornaments	ornament	objects
+ottoman	ottoman	stool
+outflow	unknown	unlabeled
+outlet	outlet	objects
+outside	unknown	unlabeled
+oven	oven	appliances
+oven and stove	oven and stove	misc
+oven hood	range hood	objects
+oven vent	oven vent	misc
+overhang	overhang	misc
+overlay	unknown	unlabeled
+package	package	objects
+pad	pad	misc
+painiting	painting	objects
+paint	unknown	unlabeled
+painting	painting	objects
+painting  frame	painting frame	misc
+painting /otherroom	painting /otherroom	objects
+painting frame	painting frame	misc
+painting roll	painting roll	objects
+painting rolls	painting rolls	objects
+painting stuff	painting stuff	objects
+painting tray	painting tray	objects
+paintng	painting	objects
+paintning	painting	objects
+pair of shoes	shoes	objects
+paiting	painting	objects
+pan	pan	objects
+panel	panel	board_panel
+panel screen	panel screen	misc
+panel wall	wall panel	wall
+paneling	paneling	wall
+pantry	pantry	misc
+paper	paper	objects
+paper holder	paper holder	objects
+paper shelf	shelf	shelving
+paper storage	paper storage	misc
+paper towel	paper towel	towel
+paper towel dispenser	paper towel dispenser	misc
+paper towel holder	paper towel holder	objects
+paper towels	paper towels	towel
+papers	papers	objects
+parapet	parapet	misc
+partial	partial	misc
+partition	partition	misc
+patio	patio	misc
+patio chair	patio chair	chair
+patio floor	patio floor	misc
+pavement	pavement	floor
+paving	pavement	floor
+payment terminal	payment terminal	objects
+pc mouse	mouse	objects
+pc tower	pc tower	misc
+pedestal	pedestal	misc
+peinting	painting	objects
+pen	pen	objects
+pen cup	pen cup	objects
+pencil	pencil	objects
+pencil case	pencil case	objects
+pencil holder	pencil holder	objects
+pendant	pendant	objects
+pendrive	pen drive	objects
+perfume	perfume	objects
+pet bed	pet bed	objects
+pet bowl	pet bowl	objects
+phillar	pillar	column
+phone	phone	objects
+photo	photo	picture
+photo mount	photo mount	misc
+photo mounts	photo mounts	misc
+photo stand	photo stand	objects
+photography	photo	picture
+photos	photos	picture
+piano	piano	objects
+piano bench	piano bench	seating
+piano lower part	piano	objects
+piano stool	piano stool	stool
+pictrure	picture	picture
+picture	picture	picture
+picture  frame	picture frame	picture
+picture frame	picture frame	picture
+pictured frame	picture frame	picture
+pictures	pictures	picture
+picure	picture	picture
+piillow	pillow	cushion
+pile of boxes	boxes	objects
+pile of cups	cups	objects
+pile of clothes	clothes	clothes
+pile of magazines	pile of magazines	misc
+pile of papers	papers	objects
+pile of stuff	unknown	unlabeled
+pillar	pillar	column
+pilllow	pillow	cushion
+pillow	pillow	cushion
+pillow seat	pillow seat	seating
+pillows	pillow	cushion
+ping pong table	ping pong table	table
+pipe	pipe	misc
+pipe part	pipe	misc
+pipes	pipe	misc
+piping	pipe	misc
+pitcher	pitcher	objects
+pitchfork	pitchfork	objects
+place mat	place mat	objects
+plane	plane	misc
+plank	plank	misc
+planner	planner	misc
+plant	plant	plant
+plant ornament	plant ornament	misc
+planter	pot	objects
+plants	plant	plant
+plasma tv	tv	tv_monitor
+plastic bag	plastic bag	objects
+plate	plate	objects
+plate of food	plate of food	misc
+plates	plates	objects
+platform	platform	misc
+platter	platter	misc
+player	music player	objects
+playpen	playpen	misc
+plenum box	plenum box	misc
+pliers	pliers	objects
+plstes	plates	objects
+plug	plug	misc
+plunger	plunger	objects
+plush toy	plush toy	objects
+podest	podium	objects
+podium	podium	objects
+pole	pole	objects
+poles	poles	objects
+pomp	pump	objects
+pool	pool	misc
+pool stick	pool stick	objects
+pool table	pool table	table
+porcelain	porcelain	objects
+portrait	portrait	picture
+post	post	column
+poster	poster	picture
+poster figure	poster	picture
+pot	pot	objects
+pot lid	pot lid	objects
+poto mount	photo mount	misc
+pots	pot	objects
+potty	potty	objects
+pouches	pouches	objects
+poufe	pouffe	seating
+pouffe	pouffe	seating
+powder soap	powder soap	objects
+power breaker box	power breaker box	misc
+power cord	power cord	objects
+power outlet	outlet	objects
+power strip	power strip	objects
+prduct box	product box	objects
+press	press	objects
+pressure washer	pressure washer	objects
+price tag	price tag	objects
+printer	printer	objects
+product	product	objects
+product box	product box	objects
+product boxes	product boxes	objects
+products	products	objects
+projector	projector	objects
+projector screen	projector screen	misc
+prop	prop	misc
+psinting	painting	objects
+public tap	drinking fountain	misc
+pump	pump	objects
+punchbag	punchbag	objects
+puncher	hole puncher	objects
+puppet	puppet	objects
+puppet cat	puppet	objects
+purse	purse	objects
+purses	purse	objects
+rack	rack	shelving
+rack of weights	rack of weights	misc
+rack with shoes	rack with shoes	shelving
+radfiator	radiator	objects
+radiator	radiator	objects
+radio	radio	misc
+rafter	rafter	beam
+rag	rag	objects
+ragdoll	ragdoll	objects
+ragdoll cat	ragdoll cat	objects
+rail	rail	railing
+railing	railing	railing
+rain shower	showerhead	shower
+rake	rake	objects
+range hood	range hood	objects
+receipt printer	receipt printer	objects
+receipt spike	receipt spike	objects
+recessed cubby	recessed cubby	misc
+recessed shelving	recessed shelving	shelving
+recessed wall	recessed wall	misc
+recliner	recliner	chair
+record player	record player	objects
+records	records	objects
+recuperator	recuperator	objects
+recycle bin	recycle bin	misc
+refridgerator	refrigerator	appliances
+refrigearator	refrigerator	appliances
+refrigerator	refrigerator	appliances
+refrigerator cabinet	refrigerator cabinet	cabinet
+relief	relief	wall
+remote	remote control	objects
+remote control	remote control	objects
+remote controller	remote control	objects
+rice cooker	rice cooker	objects
+riser	riser	misc
+robe	robe	clothes
+rock	rock	objects
+rocking chair	rocking chair	chair
+rocking horse	rocking horse	objects
+rocks	rock	objects
+rod	rod	objects
+rods	rods	objects
+roll	roll	objects
+rolled carpet	rolled carpet	objects
+roller blind	blinds	blinds
+rolling pin	rolling pin	objects
+rolls of toilet paper	toilet paper	objects
+roof	roof	ceiling
+roomba	roomba	misc
+rope	rope	objects
+round chair	round chair	chair
+round cushion	round cushion	misc
+router	router	objects
+row of theater chairs	row of theater chairs	misc
+rug	rug	floor
+ruler	ruler	objects
+safe	safe	objects
+salt and pepper	salt and pepper	objects
+salt and pepper grinder	salt and pepper grinder	objects
+salt pepper	salt and pepper	objects
+salver	salver	objects
+sandals	sandals	objects
+saturator	saturator	appliances
+sauna	sauna	appliances
+sauna bowl	sauna bowl	objects
+sauna ceiling	ceiling	ceiling
+sauna floor	floor	floor
+sauna heat rocks	sauna heat rocks	misc
+sauna heater	sauna heater	misc
+sauna oven	sauna oven	appliances
+sauna seat	sauna seat	seating
+sauna support	sauna support	misc
+sauna wall	wall	wall
+saw	saw	objects
+saxophone	saxophone	objects
+scale	scale	objects
+scales	scale	objects
+scanner	scanner	objects
+scarf	scarf	clothes
+schedule	schedule	misc
+schoe	shoe	objects
+sconce	sconce	lighting
+scoop	scoop	objects
+screen	screen	curtain
+screen frame	screen frame	misc
+screw box	screw box	objects
+screwdriver	screwdriver	objects
+sculpture	sculpture	objects
+seat	seat	seating
+secretary	secretary	misc
+security camera	security camera	objects
+self-closing mechanism	self-closing mechanism	misc
+sensor	sensor	objects
+separator	separator	objects
+set of armchairs	set of armchairs	misc
+set of boxes	set of boxes	misc
+set of cosmetics	set of cosmetics	objects
+set of hangers	set of hangers	objects
+set of knives	set of knives	misc
+set of pictures	set of pictures	picture
+set of towels	set of towels	towel
+set of valves	set of valves	appliances
+sewing box	sewing box	appliances
+sewing machine	sewing machine	appliances
+sewing set	sewing set	appliances
+sewing tools	sewing tools	appliances
+shade	shade	objects
+shade rail	shade rail	misc
+shades	shades	blinds
+shalf	shelf	shelving
+shampoo	shampoo	objects
+shedule	schedule	misc
+sheet	sheet	misc
+sheet music	sheet music	objects
+sheet music stand	sheet music stand	objects
+sheets	sheets	misc
+sheets/ clothes	sheets / clothes	clothes
+shelf	shelf	shelving
+shelf /w art	shelf with art	shelving
+shelf /w clutter	shelf with clutter	shelving
+shelf clutter	shelf clutter	shelving
+shelf cubby	shelf cubby	misc
+shelf with cosmetics	shelf with cosmetics	shelving
+shelf with shoes	shelf with shoes	shelving
+shelf/cabinet	shelf / cabinet	misc
+shelve	shelf	shelving
+shelves	shelving	shelving
+shelving	shelving	shelving
+ship model	ship model	objects
+ship toy	ship toy	objects
+shirt	shirt	clothes
+shisha	shisha	appliances
+shlef	shelf	shelving
+shoe	shoe	objects
+shoe cabinet	shoe cabinet	cabinet
+shoe case	shoe case	cabinet
+shoe rack	shoe rack	shelving
+shoe shelf	shoe shelf	shelving
+shoehorn	shoehorn	objects
+shoes	shoes	objects
+shoes on shelf	shoes on shelf	shelving
+shoes rack	shoes rack	shelving
+shop shelf	shop shelf	shelving
+shoulder bag	shoulder bag	objects
+shovel	shovel	misc
+shower	shower	shower
+shower  floor	shower floor	shower
+shower  knob	shower knob	misc
+shower  wall	shower wall	shower
+shower bar	shower bar	misc
+shower base	shower base	shower
+shower battery	shower battery	misc
+shower bench	shower bench	seating
+shower cabin	shower cabin	misc
+shower cabinet	shower cabinet	cabinet
+shower caddy	shower caddy	misc
+shower case	shower case	misc
+shower ceiling	shower ceiling	shower
+shower ceiling lamp	shower ceiling lamp	lighting
+shower cockpit	shower cockpit	shower
+shower cosmetics	shower cosmetics	objects
+shower curtain	shower curtain	curtain
+shower curtain bar	shower curtain bar	misc
+shower curtain rod	shower curtain rod	curtain
+shower dial	shower dial	misc
+shower door	shower door	shower
+shower door frame	shower door frame	shower
+shower door knob	shower door knob	misc
+shower floor	shower floor	shower
+shower frame	shower frame	shower
+shower glass	shower glass	misc
+shower grab bar	shower grab bar	misc
+shower handle	shower handle	misc
+shower handrail	shower handrail	railing
+shower hanger	shower hanger	misc
+shower head	showerhead	shower
+shower hose	shower hose	misc
+shower hose/head	shower hose/head	misc
+shower knob	shower knob	misc
+shower mat	shower mat	floor
+shower mirror	shower mirror	mirror
+shower pipe	shower pipe	misc
+shower rail	shower rail	misc
+shower rod	shower rod	curtain
+shower seat	shower seat	misc
+shower shelf	shower shelf	shelving
+shower soap shelf	shower soap shelf	misc
+shower stall	shower stall	misc
+shower step	shower step	shower
+shower tap	shower tap	misc
+shower tray	shower tray	shower
+shower tub	shower tub	bathtub
+shower utensill	shower utensil	objects
+shower valve	shower valve	misc
+shower wall	shower wall	shower
+shower wall cubby	shower wall cubby	shower
+shower window frame	shower window frame	window
+shower-bath cabinet	shower-bath cabinet	cabinet
+showerhead	showerhead	shower
+shredder	shredder	appliances
+shutter	shutter	blinds
+shutters	shutters	blinds
+side table	side table	table
+sideboard	sideboard	misc
+sign	sign	misc
+silicone gun	silicone gun	objects
+silicone tube	silicone tube	objects
+sink	sink	sink
+sink cabinet	sink cabinet	cabinet
+sink pipe	sink pipe	misc
+sink table	sink table	table
+sink tap	sink tap	misc
+sink/basin	sink/basin	misc
+sitting bench	sitting bench	seating
+skateboard	skateboard	objects
+skates	skates	objects
+ski	ski	objects
+skirting board	skirting board	wall
+sky	sky	misc
+skylight	skylight	window
+slab	slab	objects
+sled	sled	objects
+sledge	sledge	objects
+sleeping bag	sleeping bag	objects
+sliding door	sliding door	door
+sliding glass door	sliding glass door	misc
+slippers	slippers	objects
+small table	table	table
+small table/stand	small table/stand	misc
+smoke alarm	smoke alarm	objects
+smoke detector	smoke detector	misc
+snack	snack	objects
+soap	soap	objects
+soap bottle	soap bottle	objects
+soap dish	soap dish	objects
+soap dish cubby	soap dish cubby	misc
+soap dispenser	soap dispenser	objects
+soap dispenser shelf in shower	soap dispenser shelf in shower	misc
+soap tray	soap tray	objects
+soapbox	soapbox	misc
+socket	socket	objects
+socks	socks	clothes
+sofa	sofa	sofa
+sofa chair	sofa chair	chair
+sofa seat	sofa seat	misc
+sofa set	sofa set	sofa
+soft chair	soft chair	chair
+solarium	solarium	misc
+solarium door	solarium door	door
+sombrero	sombrero	objects
+sopp bottle	soap bottle	objects
+sound bar	soundbar	appliances
+soundbar	soundbar	appliances
+spa armchair	spa armchair	chair
+spa bathtub	spa bathtub	bathtub
+spa bench	spa bench	seating
+spatula	spatula	objects
+speaker	speaker	objects
+speaker stand	speaker stand	cabinet
+spice boxes	spice boxes	objects
+spice rack	spice rack	shelving
+spices	spices	objects
+spirit level	spirit level	objects
+sponge	sponge	objects
+spoon	spoon	objects
+spray	spray	objects
+spray can	spray can	objects
+sprinkler	sprinkler	objects
+square	square	objects
+stack	stack	misc
+stack of albums	stack of albums	objects
+stack of bags	stack of bags	objects
+stack of binders	stack of binders	objects
+stack of blankets	stack of blankets	objects
+stack of book	stack of books	objects
+stack of books	stack of books	objects
+stack of books/ papers	stack of books / papers	objects
+stack of boxes	stack of boxes	objects
+stack of cd's	stack of cds	objects
+stack of cds	stack of cds	objects
+stack of chairs	stack of chairs	chair
+stack of clothes	stack of clothes	clothes
+stack of files	stack of files	objects
+stack of jackets	stack of jackets	clothes
+stack of magazines	stack of magazines	objects
+stack of music stands	stack of music stands	misc
+stack of paper	stack of papers	misc
+stack of papers	stack of papers	misc
+stack of pillows	stack of pillows	cushion
+stack of plates	stack of plates	objects
+stack of pots	stack of pots	objects
+stack of product boxes	stack of product boxes	objects
+stack of shoes	stack of shoes	objects
+stack of stuff	stack of stuff	misc
+stack of t shirts	stack of t-shirts	clothes
+stack of towels	stack of towels	towel
+stack of trays	stack of trays	objects
+stack of yarns	stack of yarns	clothes
+stacked chair	stacked chair	chair
+stacked chairs	stacked chair	chair
+stage	stage	misc
+stained glass	stained glass	window
+stair	stair	stairs
+stair frame	stair frame	misc
+stair handle	stair handle	railing
+stair railing	banister	railing
+stair step	stair step	misc
+stair wall	stair wall	misc
+staircaise handrail	staircase handrail	misc
+staircase	staircase	stairs
+staircase handrail	staircase handrail	misc
+staircase handrair	staircase handrail	misc
+staircase trim	staircase trim	misc
+staircase wall	staircase wall	wall
+stairs	stairs	stairs
+stairs railing	stairs railing	misc
+stairs skirt	stairs skirt	misc
+stairs trim	stairs trim	stairs
+stairs wall	stairs wall	wall
+stairwell	stairwell	stairs
+stampler	stapler	objects
+stand	stand	table
+stand/small table	stand/small table	table
+stapler	stapler	objects
+star	star	objects
+stationary	stationery	objects
+stationery	stationery	objects
+statue	statue	objects
+statue/art	statue/art	misc
+steel plate	steel plate	objects
+step	step	stairs
+step stool	step stool	stool
+stereo	stereo	appliances
+stereo set	stereo set	appliances
+stick	stick	misc
+sticker book	sticker book	objects
+sticky notes	sticky notes	objects
+stoll	stole	clothes
+stone	stone	objects
+stone bench	stone bench	seating
+stone support structure	stone support structure	misc
+stones	stones	misc
+stonework	stonework	misc
+stoo	stool	stool
+stool	stool	stool
+stools	stools	stool
+storage	storage	objects
+storage bin	storage bin	misc
+storage box	storage box	misc
+storage cabinet	storage cabinet	cabinet
+storage shelving	storage shelving	shelving
+storage space	storage space	misc
+storage unit	storage unit	furniture
+stove	stove	appliances
+stove and oven	oven	appliances
+stove door	door	door
+stove utensil	utensil	objects
+stove utensils	utensil	objects
+stovetop	stovetop	misc
+strands	strings	misc
+stricker book	book	objects
+strings	strings	misc
+stripes	decoration	objects
+stroke	stroke	misc
+strongbox	strongbox	objects
+stuffed animal	stuffed animal	objects
+stuffed duck	stuffed animal	objects
+subwoofer	subwoofer	objects
+suitcase	luggage	objects
+sunbed	sunbed	furniture
+support	support	misc
+support beam	support beam	beam
+support stand	stand	table
+supporting beam	support beam	beam
+supporting structure	support	misc
+surface	surface	counter
+surfboard	surfboard	objects
+sweets bowl	bowl	objects
+swing	swing	objects
+switch	switch	objects
+switches	switch	objects
+swivel chair	swivel chair	chair
+t shirt	t-shirt	clothes
+table	table	table
+table /w books	table	table
+table chair	chair	chair
+table cloth	table cloth	table
+table clutter	clutter	misc
+table lamp	table lamp	lighting
+table on wheels	table	table
+table pad	table pad	table
+table plant	plant	plant
+table shelf	shelf	shelving
+table stand	table stand	misc
+table tennis table	table tennis table	table
+table top	table	table
+table tray	tray	objects
+table vase	vase	objects
+table border	unknown	unlabeled
+tablecloth	table cloth	table
+tablet	tablet	table
+tabletop	table	table
+tabletop box	box	objects
+tabletop games	game	objects
+tabletop trinket	trinket	objects
+tableware	flatware	objects
+tailet	toilet	toilet
+tambourine	tambourine	objects
+tank	tank	misc
+tap	tap	objects
+tap dial	knob	misc
+tap/ water source	tap	objects
+tapestry	tapestry	objects
+tea box	box	objects
+tea boxes	boxes	objects
+teapot	teapot	objects
+teaset	tea set	objects
+teddy bear	stuffed animal	objects
+teepee	toilet paper	objects
+telephone	telephone	objects
+telephpne	telephone	objects
+telescope	telescope	objects
+temperature control	thermostat	objects
+tennis racket	tennis racket	objects
+tent	tent	objects
+terrace	terrace	misc
+terrace door	door	door
+therapeutic chair	chair	chair
+thermal mug	mug	objects
+thermometer	thermometer	objects
+thermostat	thermostat	objects
+threadmill	treadmill	gym_equipment
+three	three	misc
+throw blanket	throw blanket	misc
+tile	tile	objects
+tiled floor	floor	floor
+tiled wall	wall	wall
+tiles	tiles	misc
+tiling	tiles	misc
+tin	box	objects
+tire	tire	objects
+tisse box	tissue box	objects
+tissue	tissue	misc
+tissue box	tissue box	objects
+tissues	tissue	misc
+title	title	misc
+toaster	toaster	appliances
+toaster oven	toaster oven	appliances
+toester	toaster	appliances
+toiled	toilet	toilet
+toiled paper	toilet paper	objects
+toilet	toilet	toilet
+toilet bin	trash can	objects
+toilet bowl brush holder	toilet brush holder	misc
+toilet brush	toilet brush	misc
+toilet brush holder	toilet brush holder	misc
+toilet cabinet	cabinet	cabinet
+toilet cleaner	toilet cleaner	misc
+toilet counter	counter	counter
+toilet flush	handle	objects
+toilet handle	handle	objects
+toilet holder	toilet brush holder	misc
+toilet paper	toilet paper	objects
+toilet paper dispenser	toilet paper dispenser	misc
+toilet paper holder	toilet paper dispenser	misc
+toilet paper stand	toilet paper dispenser	misc
+toilet plunger	plunger	objects
+toilet seat	toilet seat	toilet
+toilet sink	sink	sink
+toilet sliding door	door	door
+toilet utensil	utensil	objects
+toilete	toilet	toilet
+toilete brush	toilet brush	misc
+toilete paper holder	toilet paper dispenser	misc
+toiletry	toiletry	objects
+toiletry bag	toiletry bag	objects
+toliet	toilet	toilet
+tolilet	toilet	toilet
+tool	tool	objects
+tool board	tool rack	wall
+tool box	tool box	objects
+tool rack	tool rack	wall
+toolbox	tool box	objects
+tools	tool	objects
+toothbrush	toothbrush	objects
+toothbrush cup	cup	objects
+toothbrush holder	cup	objects
+toothpaste	toothpaste	objects
+torch	torch	objects
+toster	toaster	appliances
+towel	towel	towel
+towel bar	towel bar	objects
+towel bar shelf	shelf	shelving
+towel basket	basket	objects
+towel box	box	objects
+towel hang	towel bar	objects
+towel hanger	towel bar	objects
+towel holder	towel bar	objects
+towel paper dispenser	toilet paper dispenser	misc
+towel paper holder	toilet paper dispenser	misc
+towel rack	towel bar	objects
+towel rail	towel bar	objects
+towel ring	towel ring	objects
+towel rod	towel bar	objects
+towel shelf	shelf	shelving
+towell	towel	towel
+towels	towel	towel
+towels in a basket	basket	objects
+toy	toy	objects
+toy /otherroom	toy	objects
+toy mickey mouse	toy	objects
+toy airplane	toy	objects
+toy car	toy	objects
+toy cars	toy	objects
+toy duck	toy	objects
+toy trailer	toy	objects
+toy train	toy	objects
+toys	toy	objects
+track	toy	objects
+traffic cone	traffic cone	objects
+training bench	weight bench	gym_equipment
+training mat	training mat	gym_equipment
+trampoline	trampoline	gym_equipment
+trascan	trash can	objects
+trash	trash can	objects
+trash  bin	trash can	objects
+trash bag	trash bag	misc
+trash bin	trash can	objects
+trash can	trash can	objects
+trashcan	trash can	objects
+tray	tray	objects
+treadmill	treadmill	gym_equipment
+tree	tree	plant
+tree branch	tree branch	objects
+trimmer	trimmer	objects
+trinket	trinket	objects
+tripod	tripod	shelving
+trofeum	trophy	misc
+troley	trolley	objects
+trolley	trolley	objects
+trombone	trombone	objects
+trophies	trophy	misc
+trophy	trophy	misc
+trough	trough	misc
+trumpet	trumpet	objects
+trumpet stand	stand	table
+tub	bathtub	bathtub
+tube	tv	tv_monitor
+tv	tv	tv_monitor
+tv cabinet	tv stand	furniture
+tv decoder	tv remote	objects
+tv led	tv	tv_monitor
+tv remote	tv remote	objects
+tv remote control	tv remote	objects
+tv stand	tv stand	furniture
+tv stand door	door	door
+tv table	tv stand	furniture
+twigs in vase	plant	plant
+typewriter	typewriter	objects
+ubnknown/ probably clothes	clothes	clothes
+uknknown	unknown	unlabeled
+uknown	unknown	unlabeled
+uknown device	unknown	unlabeled
+ukulele	ukulele	objects
+umbrella	umbrella	objects
+umbrella stand	umbrella stand	furniture
+umbrellas	umbrella	objects
+umknown	unknown	unlabeled
+unkknown	unknown	unlabeled
+unknaown	unknown	unlabeled
+unknnown	unknown	unlabeled
+unknon	unknown	unlabeled
+unknow	unknown	unlabeled
+unknowm	unknown	unlabeled
+unknown	unknown	unlabeled
+unknown /otherroom	unknown	unlabeled
+unknown /outside	unknown	unlabeled
+unknown /probably cup	cup	objects
+unknown cluter	clutter	misc
+unknown clutter	clutter	misc
+unknown countertop item	unknown	unlabeled
+unknown device	unknown	unlabeled
+unknown facility	unknown	unlabeled
+unknown kitchen appliance	kitchen appliance	appliances
+unknown kitchen stuff	unknown	unlabeled
+unknown machines	appliance	misc
+unknown office stuff	unknown	unlabeled
+unknown picture/window	picture	picture
+unknown stuff	unknown	unlabeled
+unknown wall	wall	wall
+unknown/	unknown	unlabeled
+unknown/ a pie?	food	misc
+unknown/ bin?	bin	objects
+unknown/ pile of something	clutter	misc
+unknown/ proably cup	cup	objects
+unknown/ probably a book	book	objects
+unknown/ probably advertisement	magazine	objects
+unknown/ probably air refresher	air freshener	objects
+unknown/ probably air vent	vent	misc
+unknown/ probably air vent fan	fan	objects
+unknown/ probably albums	album	objects
+unknown/ probably attic entrance	door	door
+unknown/ probably bag	bag	objects
+unknown/ probably basket	basket	objects
+unknown/ probably bin	bin	objects
+unknown/ probably board	board	board_panel
+unknown/ probably board games	game	objects
+unknown/ probably boiler	boiler	misc
+unknown/ probably book	book	objects
+unknown/ probably books	book	objects
+unknown/ probably books or albums	book	objects
+unknown/ probably bottle	bottle	objects
+unknown/ probably bowl	bowl	objects
+unknown/ probably box	box	objects
+unknown/probably cabinet	cabinet	cabinet
+unknown/ probably cabinet	cabinet	cabinet
+unknown/ probably calculator	calculator	appliances
+unknown/ probably candle	candle	objects
+unknown/ probably candle stand	candle	objects
+unknown/ probably candles	candle	objects
+unknown/ probably canopy	canopy	misc
+unknown/ probably casket	casket	misc
+unknown/ probably charger	charger	objects
+unknown/ probably clock	clock	objects
+unknown/ probably clothes	clothes	clothes
+unknown/ probably coffee machine	coffee machine	appliances
+unknown/ probably computer	computer	objects
+unknown/ probably coocking books	book	objects
+unknown/ probably cookies	food	misc
+unknown/ probably cosmetic	cosmetics	objects
+unknown/ probably cosmetics	cosmetics	objects
+unknown/ probably cups	cups	objects
+unknown/ probably decoration	decoration	objects
+unknown/ probably decorative plant	decorative plant	plant
+unknown/ probably desk or box	box	objects
+unknown/ probably dinnerware	flatware	objects
+unknown/ probably dishwasher	dishwasher	appliances
+unknown/ probably drum	drum	objects
+unknown/ probably drums	drum	objects
+unknown/ probably fan vent	fan	objects
+unknown/ probably fire alarm	fire alarm	objects
+unknown/ probably fire detector	smoke detector	misc
+unknown/ probably fire sprinkler	sprinkler	objects
+unknown/ probably foam	foam	misc
+unknown/ probably folded table	table	table
+unknown/ probably frame	frame	misc
+unknown/ probably framed picture	picture	picture
+unknown/ probably fridge	refrigerator	appliances
+unknown/ probably glasses	glasses	objects
+unknown/ probably hand grab	unknown	unlabeled
+unknown/ probably hat	hat	clothes
+unknown/ probably heater	heater	objects
+unknown/ probably home theater player	tv	tv_monitor
+unknown/ probably jar	jar	objects
+unknown/ probably lamp	lamp	lighting
+unknown/ probably letters	papers	objects
+unknown/ probably liquid soap	soap	objects
+unknown/ probably magazine	magazine	objects
+unknown/ probably monitor	monitor	tv_monitor
+unknown/ probably napkins	napkins	objects
+unknown/ probably notebook	notebook	objects
+unknown/ probably paper towel dispenser	paper towels	towel
+unknown/ probably paper towel holder	paper towels	towel
+unknown/ probably pipe	pipe	misc
+unknown/ probably plate	plate	objects
+unknown/ probably pot	pot	objects
+unknown/ probably printer	printer	objects
+unknown/ probably radio	radio	misc
+unknown/ probably rug	rug	floor
+unknown/ probably scarf	scarf	clothes
+unknown/ probably security detector	security detector	misc
+unknown/ probably shampoo	shampoo	objects
+unknown/ probably sheet	sheet	misc
+unknown/ probably sheets	sheet	misc
+unknown/ probably shelf	shelf	shelving
+unknown/ probably shower cabine	shower	shower
+unknown/ probably shower gel	shampoo	objects
+unknown/ probably sitting pillow	pillow	cushion
+unknown/ probably soap	soap	objects
+unknown/ probably sofa	sofa	sofa
+unknown/ probably solarium chair	chair	chair
+unknown/ probably stand	stand	table
+unknown/ probably table lamp	table lamp	lighting
+unknown/ probably tank	tank	misc
+unknown/ probably telephone	telephone	objects
+unknown/ probably tissue dispenser	tissue	misc
+unknown/ probably wall lamp	wall lamp	lighting
+unknown/ probably washing powder	washing powder	misc
+unknown/ probably washing soap	soap	objects
+unknown/ probaby albums	albums	objects
+unknown// probably fire sprinkler	fire sprinkler	misc
+unknown/probably decoration	decoration	objects
+unknown/remove	unknown/remove	misc
+unknwn	unknown	unlabeled
+unknwom	unknown	unlabeled
+unknwon	unknown	unlabeled
+unkown	unknown	unlabeled
+unkown clutter	clutter	misc
+unknown"	unknown	unlabeled
+	unknown	unlabeled
+ups	unknown	unlabeled
+urinal	urinal	objects
+utensil	utensil	objects
+vaccum cleaner	vacuum cleaner	appliances
+vacuum cleaner	vacuum cleaner	appliances
+valve	plumbing	objects
+vanity	vanity	table
+vanity table	vanity	table
+vase	vase	objects
+vase with flower	flower	plant
+vegetables	vegetables	objects
+vegetation	plant	plant
+vent	vent	misc
+vent pipe	pipe	misc
+ventialtion	ventilation	objects
+ventilation	ventilation	objects
+ventilation hood	ventilation hood	misc
+ventilation pipe	pipe	misc
+ventilator	ventilation	objects
+vese	vessel	objects
+vessel	vessel	objects
+vessel sink	vessel sink	misc
+vice	unknown	unlabeled
+video cassette	cassette	objects
+vinyl records	vinyl records	objects
+violin	violin	objects
+violin case	violin case	objects
+wadrobe	wardrobe	furniture
+waffle iron	waffle iron	appliances
+wal	wall	wall
+wal hanging decoration	decoration	objects
+wall	wall	wall
+wall outside	wall outside	wall
+wall  clock	wall clock	objects
+wall  lamp	wall lamp	lighting
+wall /otheroom	wall	wall
+wall /outside	wall /outside	wall
+wall balk	wall	wall
+wall balks	wall	wall
+wall beam	wall beam	misc
+wall board	wall board	misc
+wall cabinet	wall cabinet	cabinet
+wall clock	wall clock	objects
+wall control	wall control	misc
+wall controll	wall control	misc
+wall controller	wall control	misc
+wall coping	wall	wall
+wall corridor	wall	wall
+wall cubby	wall cubby	misc
+wall decoration	picture	picture
+wall detail	wall detail	misc
+wall device	wall electronics	misc
+wall electronic	wall electronics	misc
+wall electronics	wall electronics	misc
+wall frame	picture	picture
+wall hanger	wall hanger	objects
+wall hanging decoration	wall hanging decoration	misc
+wall hanging organizer	wall hanger	objects
+wall indent	wall indent	misc
+wall lamp	wall lamp	lighting
+wall light	wall lamp	lighting
+wall lmap	wall lamp	lighting
+wall niche	wall hanging decoration	misc
+wall of green	wall	wall
+wall painting	painting	objects
+wall panel	wall panel	wall
+wall panel frame	wall panel frame	wall
+wall post	wall post	misc
+wall shelf	wall shelf	shelving
+wall sign	wall sign	misc
+wall sing	wall sign	misc
+wall soap shelf	wall soap shelf	misc
+wall statue	wall statue	misc
+wall sticker	decoration	objects
+wall toilet paper	wall toilet paper	misc
+wall top	wall top	misc
+wall tv	wall tv	misc
+wall vent	vent	misc
+wallkitchen island	wall	wall
+walll	wall	wall
+wardeobe	wardrobe	furniture
+wardeobe door	wardrobe	furniture
+warderobe	wardrobe	furniture
+wardobe	wardrobe	furniture
+wardrobe	wardrobe	furniture
+wardrobe accesories	wardrobe	furniture
+wardrobe door	wardrobe	furniture
+wardrobe door frame	wardrobe	furniture
+wardrobe drawer	drawer	chest_of_drawers
+wardrobe mirror	mirror	mirror
+wardrobe shelf	shelf	shelving
+wardrobe sliding door	sliding door	door
+wash basin	washbasin	sink
+wash basin cabinet	wash cabinet	cabinet
+wash cabinet	wash cabinet	cabinet
+washbasin	washbasin	sink
+washbasin cabinet	wash cabinet	cabinet
+washbasin counter	washbasin counter	counter
+washbasin countertop	washbasin counter	counter
+washbasin table	washbasin counter	counter
+washcloth	washcloth	objects
+washdisher machine	dishwasher	appliances
+washer dryer	washer-dryer	misc
+washer-dryer	washer-dryer	misc
+washing container	container	objects
+washing liquid	detergent	misc
+washing machine	washing machine	appliances
+washing machine and dryer	washing machine and dryer	appliances
+washing powder	washing powder	misc
+washing stuff	washing stuff	misc
+watch	watch	objects
+water basin	water basin	misc
+water bottle	bottle	objects
+water dispenser	water dispenser	objects
+water fountain	water fountain	misc
+water heater	water heater	objects
+water meter	water meter	objects
+water outlet	water outlet	objects
+water pump	water pump	objects
+water tank	water tank	objects
+watering can	watering can	objects
+weight	weight	gym_equipment
+weight bench	weight bench	gym_equipment
+weights	weights	gym_equipment
+wheel	wheel	objects
+wheelbarrow	wheelbarrow	objects
+whine shelf	whine shelf	misc
+whiteboard	whiteboard	tv_monitor
+widnow frame	window frame	window
+wifi repeater	wifi router	objects
+wifi router	wifi router	objects
+wifi transmitter	wifi router	objects
+wind chime	decoration	objects
+windo	window	window
+windoe frame	window frame	window
+windoow shade	window shade	blinds
+windor	window	window
+window	window	window
+window  curtain	window curtain	curtain
+window  frame	window frame	window
+window  glass	window glass	objects
+window  shade	window shade	blinds
+window /otherroom	window /otherroom	window
+window /outside	window /outside	window
+window /wall	window	window
+window bars	window	window
+window behind shutters	window	window
+window blinds	blinds	blinds
+window curtain	window curtain	curtain
+window curtain bar	window curtain	curtain
+window fame	window frame	window
+window fram	window frame	window
+window frame	window frame	window
+window frame /otherroom	window frame /otherroom	window
+window glass	window glass	objects
+window glass /outside	window	window
+window pane	window	window
+window panel	window	window
+window panes	window	window
+window place	window	window
+window rame	window	window
+window seat	window seat	seating
+window shade	window shade	blinds
+window shades	window shade	blinds
+window shutter	window shutter	objects
+window shutters	window shutters	objects
+window sill	window frame	window
+window valence	window valence	curtain
+window/door	window/door	misc
+windowframe	window frame	window
+windown frame	window frame	window
+windows	window	window
+windows frame	window frame	window
+windowsil	window frame	window
+windowsill	window frame	window
+windw frame	window frame	window
+wine	wine	misc
+wine bottle	wine bottle	objects
+wine cabinet	wine cabinet	cabinet
+wine rack	wine rack	misc
+wine refrigerator	refrigerator	appliances
+wine storage	wine storage	shelving
+winndow	window	window
+winndow  frame	window frame	window
+wire	wire	misc
+wood	wood	misc
+wood burner	fireplace	fireplace
+wood frame	frame	misc
+wooden balk	wood	misc
+wooden panel	panel	board_panel
+wool	cloth	objects
+woor frame	frame	misc
+workout bike	workout bike	misc
+workout weight	weights	gym_equipment
+workstation	workstation	objects
+worktop	worktop	misc
+wreath	wreath	objects
+wrench	wrench	misc
+yoga mat	yoga mat	misc
+~aper	unknown	unlabeled
+łamp	lamp	lighting
+śign	sign	misc

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/preprocessing/hm3d/preprocess_hm3d.py

@@ -0,0 +1,209 @@
+"""
+Preprocessing Script for Habitat-Matterport 3D Dataset
+
+Author: Xiaoyang Wu (xiaoyang.wu.cs@gmail.com)
+Please cite our work if the code is helpful to you.
+"""
+
+import os
+import glob
+import argparse
+import numpy as np
+import trimesh
+from pathlib import Path
+import multiprocessing as mp
+from concurrent.futures import ProcessPoolExecutor
+from itertools import repeat
+from pathlib import Path
+
+from hm3d_constants import CLASS_LABELS_40
+
+MPCAT2INDEX = dict([(CLASS_LABELS_40[i], i) for i in range(40)])
+MPCAT2INDEX["unlabeled"] = -1
+
+CAT2INDEX = dict()
+with open(Path(__file__).parent / "hm3dsem_category_mappings.tsv") as f:
+    f.readline()  # raw_category	category	mpcat40
+    lines = f.readlines()
+for line in lines:
+    line = line.strip().split("\t")
+    if len(line) == 2:
+        # L2164: "\tunknown\tunlabeled"
+        line.insert(0, "")
+    CAT2INDEX[line[1]] = MPCAT2INDEX[line[2]]
+
+
+def uv_to_texture_color(uv, texture):
+    width, height = texture.size
+    u = int(uv[0] * width)
+    v = int((1 - uv[1]) * height)  # Flip y-axis for image coordinates
+    if 0 <= u < width and 0 <= v < height:
+        return texture.getpixel((u, v))
+    else:
+        return 0, 0, 0
+
+
+def load_hex_mapping(mapping_path):
+    hex2label = {}
+    with open(mapping_path) as f:
+        f.readline()  # remove 'HM3D Semantic Annotations\n'
+        lines = f.readlines()  # get the left
+    for line in lines:
+        line = line.strip().split(",")
+        cat = line[2].strip('"')
+        if cat == "trashcan":
+            cat = "trash can"
+        elif cat == "fridge":
+            cat = "refrigerator"
+        hex2label[line[1]] = dict(instance=line[0], segment=CAT2INDEX[cat])
+    return hex2label
+
+
+def handle_process(
+    scene_path,
+    output_root,
+    density=0.02,
+):
+    scene_path = Path(scene_path)
+    scene_label_path = scene_path.with_suffix(".semantic.glb")
+    scene_mapping_path = scene_path.with_suffix(".semantic.txt")
+    scene_name = scene_path.parent.name.replace("-", "_")
+    scene_id = scene_name.split("_")[0]
+    labeled = True if scene_label_path.is_file() else False
+
+    # test split (900-1000) is reserved by official
+    if 0 <= int(scene_id) < 800:
+        split = "train"
+    else:
+        split = "val"
+    print(f"Parsing scene {scene_name} in {split} split...")
+
+    scene = trimesh.load(scene_path)
+    if labeled:
+        labeled_scene_ = trimesh.load(scene_label_path)
+        labeled_scene = trimesh.Scene()
+        for name, mesh in labeled_scene_.geometry.items():
+            # some case, name in labeled scene and scene is not matched, so only use chunk id
+            labeled_scene.add_geometry(mesh, geom_name=name.split("_")[0])
+        del labeled_scene_
+        hex2label = load_hex_mapping(scene_mapping_path)
+
+    room_dict = {}
+    for name, mesh in scene.geometry.items():
+        room_id = "_".join(name.split("_")[1:3]).replace("group", "").replace("sub", "")
+        if room_id not in room_dict.keys():
+            room_dict[room_id] = trimesh.Scene()
+        room_dict[room_id].add_geometry(mesh, geom_name=name.split("_")[0])
+    del scene
+
+    for room_id, scene in room_dict.items():
+        # seed by scene_id and room_id e.g. 00802-000-002 -> 802000002
+        np.random.seed(int(scene_id + room_id.replace("_", "")))
+        room_coord = []
+        room_color = []
+        room_normal = []
+        if labeled:
+            room_label_color = []
+
+        for name in scene.geometry.keys():
+            mesh = scene.geometry[name]
+            num_points = int(np.sum(mesh.area_faces) / density**2)
+            if num_points == 0:
+                continue
+            coords, face_indices = mesh.sample(num_points, return_index=True)
+            faces = mesh.faces[face_indices]
+            triangles = mesh.vertices[faces]
+            bary_coords = trimesh.triangles.points_to_barycentric(triangles, coords)
+            uv_coords = mesh.visual.uv[faces]
+            sampled_uvs = np.einsum("ijk,ij->ik", uv_coords, bary_coords)
+
+            pbr_material = mesh.visual.material
+            texture_image = pbr_material.baseColorTexture
+            if texture_image is None:
+                continue
+            colors = np.array(
+                [uv_to_texture_color(uv, texture_image) for uv in sampled_uvs]
+            )
+            normals = mesh.vertex_normals[faces]
+            normals = np.einsum("ijk,ij->ik", normals, bary_coords)
+            room_coord.append(coords)
+            room_color.append(colors)
+            room_normal.append(normals)
+
+            if labeled:
+                labeled_mash = labeled_scene.geometry[name]
+                label_texture_image = labeled_mash.visual.material.baseColorTexture
+                label_color = np.array(
+                    [uv_to_texture_color(uv, label_texture_image) for uv in sampled_uvs]
+                )
+                room_label_color.append(label_color)
+
+        if len(room_coord) == 0:
+            continue
+
+        room_coord = np.concatenate(room_coord, axis=0).astype("float32")
+        room_color = np.concatenate(room_color, axis=0).astype("uint8")
+        room_normal = np.concatenate(room_normal, axis=0).astype("float32")
+        data_dict = dict(coord=room_coord, color=room_color, normal=room_normal)
+
+        if labeled:
+            room_label_color = np.concatenate(room_label_color, axis=0)
+            instance_label_color = np.unique(room_label_color, axis=0)
+            room_instance = -np.ones(len(room_label_color), dtype="int16")
+            room_segment = -np.ones(len(room_label_color), dtype="int16")
+            for i in range(len(instance_label_color)):
+                label_color = instance_label_color[i]
+                label_hex = "{c[0]:02x}{c[1]:02x}{c[2]:02x}".format(c=label_color)
+                mask = np.all(room_label_color == label_color, axis=-1)
+                room_instance[mask] = i
+                if label_hex.upper() in hex2label.keys():
+                    room_segment[mask] = hex2label[label_hex.upper()]["segment"]
+            data_dict["instance"] = room_instance
+            data_dict["segment"] = room_segment
+        save_path = Path(output_root) / split / "_".join([scene_name, room_id])
+        os.makedirs(save_path, exist_ok=True)
+        for key, value in data_dict.items():
+            np.save(save_path / f"{key}.npy", value)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--dataset_root",
+        required=True,
+        help="Path to the Habitat-Matterport 3D dataset containing scene folders",
+    )
+    parser.add_argument(
+        "--output_root",
+        required=True,
+        help="Output path where train/val folders will be located",
+    )
+    parser.add_argument(
+        "--density",
+        default=0.02,
+        type=float,
+        help="Sampling density on mesh surface (m)",
+    )
+    parser.add_argument(
+        "--num_workers",
+        default=mp.cpu_count(),
+        type=int,
+        help="Num workers for preprocessing.",
+    )
+    args = parser.parse_args()
+
+    scene_list = glob.glob(os.path.join(args.dataset_root, "*", "*.glb"))
+    scene_list = [scene for scene in scene_list if not scene.endswith("semantic.glb")]
+    assert len(scene_list) == 900
+
+    # Preprocess data.
+    print("Processing scenes...")
+    pool = ProcessPoolExecutor(max_workers=args.num_workers)
+    _ = list(
+        pool.map(
+            handle_process,
+            scene_list,
+            repeat(args.output_root),
+            repeat(args.density),
+        )
+    )

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/preprocessing/matterport3d/meta_data/scenes_test.txt

@@ -0,0 +1,18 @@
+2t7WUuJeko7
+5ZKStnWn8Zo
+ARNzJeq3xxb
+fzynW3qQPVF
+jtcxE69GiFV
+pa4otMbVnkk
+q9vSo1VnCiC
+rqfALeAoiTq
+UwV83HsGsw3
+wc2JMjhGNzB
+WYY7iVyf5p8
+YFuZgdQ5vWj
+yqstnuAEVhm
+YVUC4YcDtcY
+gxdoqLR6rwA
+gYvKGZ5eRqb
+RPmz2sHmrrY
+Vt2qJdWjCF2

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/preprocessing/matterport3d/meta_data/scenes_train.txt

@@ -0,0 +1,61 @@
+17DRP5sb8fy
+1LXtFkjw3qL
+1pXnuDYAj8r
+29hnd4uzFmX
+5LpN3gDmAk7
+5q7pvUzZiYa
+759xd9YjKW5
+7y3sRwLe3Va
+82sE5b5pLXE
+8WUmhLawc2A
+aayBHfsNo7d
+ac26ZMwG7aT
+B6ByNegPMKs
+b8cTxDM8gDG
+cV4RVeZvu5T
+D7N2EKCX4Sj
+e9zR4mvMWw7
+EDJbREhghzL
+GdvgFV5R1Z5
+gTV8FGcVJC9
+HxpKQynjfin
+i5noydFURQK
+JeFG25nYj2p
+JF19kD82Mey
+jh4fc5c5qoQ
+kEZ7cmS4wCh
+mJXqzFtmKg4
+p5wJjkQkbXX
+Pm6F8kyY3z2
+pRbA3pwrgk9
+PuKPg4mmafe
+PX4nDJXEHrG
+qoiz87JEwZ2
+rPc6DW4iMge
+s8pcmisQ38h
+S9hNv5qa7GM
+sKLMLpTHeUy
+SN83YJsR3w2
+sT4fr6TAbpF
+ULsKaCPVFJR
+uNb9QFRL6hY
+Uxmj2M2itWa
+V2XKFyX4ASd
+VFuaQ6m2Qom
+VVfe2KiqLaN
+Vvot9Ly1tCj
+vyrNrziPKCB
+VzqfbhrpDEA
+XcA2TqTSSAj
+2n8kARJN3HM
+D7G3Y4RVNrH
+dhjEzFoUFzH
+E9uDoFAP3SH
+gZ6f7yhEvPG
+JmbYfDe2QKZ
+r1Q1Z4BcV1o
+r47D5H71a5s
+ur6pFq6Qu1A
+VLzqgDo317F
+YmJkqBEsHnH
+ZMojNkEp431

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/preprocessing/matterport3d/meta_data/scenes_val.txt

@@ -0,0 +1,11 @@
+2azQ1b91cZZ
+8194nk5LbLH
+EU6Fwq7SyZv
+oLBMNvg9in8
+QUCTc6BB5sX
+TbHJrupSAjP
+X7HyMhZNoso
+pLe4wQe7qrG
+x8F5xyUWy9e
+Z6MFQCViBuw
+zsNo4HB9uLZ

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/preprocessing/matterport3d/preprocess_matterport3d_mesh.py

@@ -0,0 +1,240 @@
+"""
+Preprocessing Script for Matterport3D (Unzipping)
+adatpted from https://github.com/pengsongyou/openscene/blob/main/scripts/preprocess/preprocess_3d_matterport.py
+
+Author: Chongjie Ye (chongjieye@link.cuhk.edu.cn)
+Modified by: Xiaoyang Wu (xiaoyang.wu.cs@gmail.com)
+Please cite our work if the code is helpful to you.
+"""
+
+import os
+import argparse
+import glob
+import plyfile
+import numpy as np
+import pandas as pd
+import multiprocessing as mp
+from concurrent.futures import ProcessPoolExecutor
+from itertools import repeat
+from pathlib import Path
+import torch
+
+MATTERPORT_CLASS_REMAP = np.zeros(41)
+MATTERPORT_CLASS_REMAP[1] = 1
+MATTERPORT_CLASS_REMAP[2] = 2
+MATTERPORT_CLASS_REMAP[3] = 3
+MATTERPORT_CLASS_REMAP[4] = 4
+MATTERPORT_CLASS_REMAP[5] = 5
+MATTERPORT_CLASS_REMAP[6] = 6
+MATTERPORT_CLASS_REMAP[7] = 7
+MATTERPORT_CLASS_REMAP[8] = 8
+MATTERPORT_CLASS_REMAP[9] = 9
+MATTERPORT_CLASS_REMAP[10] = 10
+MATTERPORT_CLASS_REMAP[11] = 11
+MATTERPORT_CLASS_REMAP[12] = 12
+MATTERPORT_CLASS_REMAP[14] = 13
+MATTERPORT_CLASS_REMAP[16] = 14
+MATTERPORT_CLASS_REMAP[22] = 21  # DIFFERENCE TO SCANNET!
+MATTERPORT_CLASS_REMAP[24] = 15
+MATTERPORT_CLASS_REMAP[28] = 16
+MATTERPORT_CLASS_REMAP[33] = 17
+MATTERPORT_CLASS_REMAP[34] = 18
+MATTERPORT_CLASS_REMAP[36] = 19
+MATTERPORT_CLASS_REMAP[39] = 20
+
+MATTERPORT_LABELS_21 = (
+    "wall",
+    "floor",
+    "cabinet",
+    "bed",
+    "chair",
+    "sofa",
+    "table",
+    "door",
+    "window",
+    "bookshelf",
+    "picture",
+    "counter",
+    "desk",
+    "curtain",
+    "refrigerator",
+    "shower curtain",
+    "toilet",
+    "sink",
+    "bathtub",
+    "other",
+    "ceiling",
+)
+MATTERPORT_ALLOWED_NYU_CLASSES = [
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    14,
+    16,
+    22,
+    24,
+    28,
+    33,
+    34,
+    36,
+    39,
+]
+
+
+def handle_process(mesh_path, output_path, mapping, train_scenes, val_scenes):
+    # Get the scene id and region name from the mesh path
+    scene_id = Path(mesh_path).parent.parent.name
+    region_id = Path(mesh_path).stem.removeprefix("region")
+    data_name = f"{scene_id}_{int(region_id):02d}"
+
+    output_path = Path(output_path)
+    # Check which split the scene belongs to (train, val, or test)
+    if scene_id in train_scenes:
+        output_folder = output_path / "train" / data_name
+        split = "train"
+    elif scene_id in val_scenes:
+        output_folder = output_path / "val" / data_name
+        split = "val"
+    else:
+        output_folder = output_path / "test" / data_name
+        split = "test"
+
+    # Create the output directory if it doesn't exist
+    os.makedirs(output_folder, exist_ok=True)
+    print(f"Processing: {data_name} in {split}")
+
+    # Load the vertex data
+    with open(mesh_path, "rb") as f:
+        plydata = plyfile.PlyData.read(f)
+    vertex_data = plydata["vertex"].data
+
+    # Get the coordinates, colors, and normals from the vertex data
+    coords = np.vstack([vertex_data["x"], vertex_data["y"], vertex_data["z"]]).T
+    colors = np.vstack(
+        [vertex_data["red"], vertex_data["green"], vertex_data["blue"]]
+    ).T
+    normals = np.vstack([vertex_data["nx"], vertex_data["ny"], vertex_data["nz"]]).T
+
+    # Load the face data
+    face_data = plydata["face"].data
+    category_id = face_data["category_id"]
+
+    # Replace -1 with 0 in category_id
+    category_id[category_id == -1] = 0
+
+    # Map the labels according to NYU40ID
+    mapped_labels = mapping[category_id]
+
+    # Replace labels not in MATTERPORT_ALLOWED_NYU_CLASSES with 0
+    mapped_labels[
+        np.logical_not(np.isin(mapped_labels, MATTERPORT_ALLOWED_NYU_CLASSES))
+    ] = 0
+
+    # Remap the labels to ScanNet 20 categories + ceiling
+    remapped_labels = MATTERPORT_CLASS_REMAP[mapped_labels].astype(int)
+
+    # Calculate per-vertex labels
+    triangles = face_data["vertex_indices"]
+    vertex_labels = np.zeros((coords.shape[0], 22), dtype=np.int32)
+    # calculate per-vertex labels
+    for row_id in range(triangles.shape[0]):
+        for i in range(3):
+            vertex_labels[triangles[row_id][i], remapped_labels[row_id]] += 1
+
+    # Get the most frequent label for each vertex
+    vertex_labels = np.argmax(vertex_labels, axis=1)
+    vertex_labels -= 1
+
+    # Add the vertex labels to the data to be saved
+    # Prepare the data to be saved
+    data_dict = dict(
+        coord=coords.astype("float32"),
+        color=colors.astype("uint8"),
+        normal=normals.astype("float32"),
+        segment=vertex_labels.astype("int16"),
+    )
+
+    # Save processed data
+    for key in data_dict.keys():
+        np.save(output_folder / f"{key}.npy", data_dict[key])
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--dataset_root",
+        required=True,
+        help="Path to the Matterport3D dataset containing scene folders",
+    )
+    parser.add_argument(
+        "--output_root",
+        required=True,
+        help="Output path where train/val folders will be located",
+    )
+    parser.add_argument(
+        "--num_workers",
+        default=mp.cpu_count(),
+        type=int,
+        help="Num workers for preprocessing.",
+    )
+    opt = parser.parse_args()
+    meta_root = Path(os.path.dirname(__file__)) / "meta_data"
+
+    # Load label map
+    category_mapping = pd.read_csv(
+        meta_root / "category_mapping.tsv",
+        sep="\t",
+        header=0,
+    )
+    mapping = np.insert(
+        category_mapping[["nyu40id"]].to_numpy().astype(int).flatten(), 0, 0, axis=0
+    )
+
+    # Load train/val splits
+    with open(meta_root / "scenes_train.txt") as train_file:
+        train_scenes = train_file.read().splitlines()
+    with open(meta_root / "scenes_val.txt") as val_file:
+        val_scenes = val_file.read().splitlines()
+    with open(meta_root / "scenes_test.txt") as test_file:
+        test_scenes = test_file.read().splitlines()
+
+    # Create output directories
+    os.makedirs(opt.output_root, exist_ok=True)
+    train_output_dir = os.path.join(opt.output_root, "train")
+    os.makedirs(train_output_dir, exist_ok=True)
+    val_output_dir = os.path.join(opt.output_root, "val")
+    os.makedirs(val_output_dir, exist_ok=True)
+    test_output_dir = os.path.join(opt.output_root, "test")
+    os.makedirs(test_output_dir, exist_ok=True)
+
+    # Load scene paths
+    scene_paths = sorted(
+        glob.glob(
+            os.path.join(
+                opt.dataset_root, "v1", "scans", "*", "region_segmentations", "*.ply"
+            )
+        )
+    )
+
+    # Preprocess data.
+    pool = ProcessPoolExecutor(max_workers=opt.num_workers)
+    print("Processing scenes...")
+    _ = list(
+        pool.map(
+            handle_process,
+            scene_paths,
+            repeat(opt.output_root),
+            repeat(mapping),
+            repeat(train_scenes),
+            repeat(val_scenes),
+        )
+    )

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/preprocessing/matterport3d/unzip_matterport3d_region_segmentation.py

@@ -0,0 +1,66 @@
+"""
+Preprocessing Script for Matterport3D (Unzipping)
+modified from official preprocess code.
+
+Author: Chongjie Ye (chongjieye@link.cuhk.edu.cn)
+Modified by: Xiaoyang Wu (xiaoyang.wu.cs@gmail.com)
+Please cite our work if the code is helpful to you.
+"""
+
+import argparse
+import os
+import zipfile
+import glob
+import multiprocessing as mp
+from concurrent.futures import ProcessPoolExecutor
+from itertools import repeat
+
+
+def unzip_file(input_path, output_path):
+    print(f"Unzipping {input_path} ...")
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    with zipfile.ZipFile(input_path, "r") as zip_ref:
+        zip_ref.extractall(output_path)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description='Unzip all "region_segmentations.zip" files in a directory'
+    )
+    parser.add_argument(
+        "--dataset_root",
+        type=str,
+        help="Path to input directory containing ZIP files",
+        required=True,
+    )
+    parser.add_argument(
+        "--output_root",
+        type=str,
+        help="Path to output directory for extracted files",
+        default=None,
+    )
+    parser.add_argument(
+        "--num_workers",
+        default=mp.cpu_count(),
+        type=int,
+        help="Num workers for preprocessing.",
+    )
+    args = parser.parse_args()
+    if args.output_root is None:
+        args.output_root = args.dataset_root
+    args.output_root = os.path.join(args.output_root, "v1", "scans")
+
+    file_list = glob.glob(
+        os.path.join(args.dataset_root, "v1", "scans", "*", "region_segmentations.zip")
+    )
+
+    # Preprocess data.
+    print("Unzipping region_segmentations.zip in Matterport3D...")
+    pool = ProcessPoolExecutor(max_workers=args.num_workers)
+    _ = list(
+        pool.map(
+            unzip_file,
+            file_list,
+            repeat(args.output_root),
+        )
+    )

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/preprocessing/nuscenes/preprocess_nuscenes_info.py

@@ -0,0 +1,607 @@
+"""
+Preprocessing Script for nuScenes Informantion
+modified from OpenPCDet (https://github.com/open-mmlab/OpenPCDet)
+
+Author: Xiaoyang Wu (xiaoyang.wu.cs@gmail.com)
+Please cite our work if the code is helpful to you.
+"""
+
+import os
+from pathlib import Path
+import numpy as np
+import argparse
+import tqdm
+import pickle
+from functools import reduce
+from pyquaternion import Quaternion
+from nuscenes.nuscenes import NuScenes
+from nuscenes.utils import splits
+from nuscenes.utils.geometry_utils import transform_matrix
+
+
+map_name_from_general_to_detection = {
+    "human.pedestrian.adult": "pedestrian",
+    "human.pedestrian.child": "pedestrian",
+    "human.pedestrian.wheelchair": "ignore",
+    "human.pedestrian.stroller": "ignore",
+    "human.pedestrian.personal_mobility": "ignore",
+    "human.pedestrian.police_officer": "pedestrian",
+    "human.pedestrian.construction_worker": "pedestrian",
+    "animal": "ignore",
+    "vehicle.car": "car",
+    "vehicle.motorcycle": "motorcycle",
+    "vehicle.bicycle": "bicycle",
+    "vehicle.bus.bendy": "bus",
+    "vehicle.bus.rigid": "bus",
+    "vehicle.truck": "truck",
+    "vehicle.construction": "construction_vehicle",
+    "vehicle.emergency.ambulance": "ignore",
+    "vehicle.emergency.police": "ignore",
+    "vehicle.trailer": "trailer",
+    "movable_object.barrier": "barrier",
+    "movable_object.trafficcone": "traffic_cone",
+    "movable_object.pushable_pullable": "ignore",
+    "movable_object.debris": "ignore",
+    "static_object.bicycle_rack": "ignore",
+}
+
+
+cls_attr_dist = {
+    "barrier": {
+        "cycle.with_rider": 0,
+        "cycle.without_rider": 0,
+        "pedestrian.moving": 0,
+        "pedestrian.sitting_lying_down": 0,
+        "pedestrian.standing": 0,
+        "vehicle.moving": 0,
+        "vehicle.parked": 0,
+        "vehicle.stopped": 0,
+    },
+    "bicycle": {
+        "cycle.with_rider": 2791,
+        "cycle.without_rider": 8946,
+        "pedestrian.moving": 0,
+        "pedestrian.sitting_lying_down": 0,
+        "pedestrian.standing": 0,
+        "vehicle.moving": 0,
+        "vehicle.parked": 0,
+        "vehicle.stopped": 0,
+    },
+    "bus": {
+        "cycle.with_rider": 0,
+        "cycle.without_rider": 0,
+        "pedestrian.moving": 0,
+        "pedestrian.sitting_lying_down": 0,
+        "pedestrian.standing": 0,
+        "vehicle.moving": 9092,
+        "vehicle.parked": 3294,
+        "vehicle.stopped": 3881,
+    },
+    "car": {
+        "cycle.with_rider": 0,
+        "cycle.without_rider": 0,
+        "pedestrian.moving": 0,
+        "pedestrian.sitting_lying_down": 0,
+        "pedestrian.standing": 0,
+        "vehicle.moving": 114304,
+        "vehicle.parked": 330133,
+        "vehicle.stopped": 46898,
+    },
+    "construction_vehicle": {
+        "cycle.with_rider": 0,
+        "cycle.without_rider": 0,
+        "pedestrian.moving": 0,
+        "pedestrian.sitting_lying_down": 0,
+        "pedestrian.standing": 0,
+        "vehicle.moving": 882,
+        "vehicle.parked": 11549,
+        "vehicle.stopped": 2102,
+    },
+    "ignore": {
+        "cycle.with_rider": 307,
+        "cycle.without_rider": 73,
+        "pedestrian.moving": 0,
+        "pedestrian.sitting_lying_down": 0,
+        "pedestrian.standing": 0,
+        "vehicle.moving": 165,
+        "vehicle.parked": 400,
+        "vehicle.stopped": 102,
+    },
+    "motorcycle": {
+        "cycle.with_rider": 4233,
+        "cycle.without_rider": 8326,
+        "pedestrian.moving": 0,
+        "pedestrian.sitting_lying_down": 0,
+        "pedestrian.standing": 0,
+        "vehicle.moving": 0,
+        "vehicle.parked": 0,
+        "vehicle.stopped": 0,
+    },
+    "pedestrian": {
+        "cycle.with_rider": 0,
+        "cycle.without_rider": 0,
+        "pedestrian.moving": 157444,
+        "pedestrian.sitting_lying_down": 13939,
+        "pedestrian.standing": 46530,
+        "vehicle.moving": 0,
+        "vehicle.parked": 0,
+        "vehicle.stopped": 0,
+    },
+    "traffic_cone": {
+        "cycle.with_rider": 0,
+        "cycle.without_rider": 0,
+        "pedestrian.moving": 0,
+        "pedestrian.sitting_lying_down": 0,
+        "pedestrian.standing": 0,
+        "vehicle.moving": 0,
+        "vehicle.parked": 0,
+        "vehicle.stopped": 0,
+    },
+    "trailer": {
+        "cycle.with_rider": 0,
+        "cycle.without_rider": 0,
+        "pedestrian.moving": 0,
+        "pedestrian.sitting_lying_down": 0,
+        "pedestrian.standing": 0,
+        "vehicle.moving": 3421,
+        "vehicle.parked": 19224,
+        "vehicle.stopped": 1895,
+    },
+    "truck": {
+        "cycle.with_rider": 0,
+        "cycle.without_rider": 0,
+        "pedestrian.moving": 0,
+        "pedestrian.sitting_lying_down": 0,
+        "pedestrian.standing": 0,
+        "vehicle.moving": 21339,
+        "vehicle.parked": 55626,
+        "vehicle.stopped": 11097,
+    },
+}
+
+
+def get_available_scenes(nusc):
+    available_scenes = []
+    for scene in nusc.scene:
+        scene_token = scene["token"]
+        scene_rec = nusc.get("scene", scene_token)
+        sample_rec = nusc.get("sample", scene_rec["first_sample_token"])
+        sd_rec = nusc.get("sample_data", sample_rec["data"]["LIDAR_TOP"])
+        has_more_frames = True
+        scene_not_exist = False
+        while has_more_frames:
+            lidar_path, boxes, _ = nusc.get_sample_data(sd_rec["token"])
+            if not Path(lidar_path).exists():
+                scene_not_exist = True
+                break
+            else:
+                break
+        if scene_not_exist:
+            continue
+        available_scenes.append(scene)
+    return available_scenes
+
+
+def get_sample_data(nusc, sample_data_token, selected_anntokens=None):
+    """
+    Returns the data path as well as all annotations related to that sample_data.
+    Note that the boxes are transformed into the current sensor"s coordinate frame.
+    Args:
+        nusc:
+        sample_data_token: Sample_data token.
+        selected_anntokens: If provided only return the selected annotation.
+
+    Returns:
+
+    """
+    # Retrieve sensor & pose records
+    sd_record = nusc.get("sample_data", sample_data_token)
+    cs_record = nusc.get("calibrated_sensor", sd_record["calibrated_sensor_token"])
+    sensor_record = nusc.get("sensor", cs_record["sensor_token"])
+    pose_record = nusc.get("ego_pose", sd_record["ego_pose_token"])
+
+    data_path = nusc.get_sample_data_path(sample_data_token)
+
+    if sensor_record["modality"] == "camera":
+        cam_intrinsic = np.array(cs_record["camera_intrinsic"])
+    else:
+        cam_intrinsic = None
+
+    # Retrieve all sample annotations and map to sensor coordinate system.
+    if selected_anntokens is not None:
+        boxes = list(map(nusc.get_box, selected_anntokens))
+    else:
+        boxes = nusc.get_boxes(sample_data_token)
+
+    # Make list of Box objects including coord system transforms.
+    box_list = []
+    for box in boxes:
+        box.velocity = nusc.box_velocity(box.token)
+        # Move box to ego vehicle coord system
+        box.translate(-np.array(pose_record["translation"]))
+        box.rotate(Quaternion(pose_record["rotation"]).inverse)
+
+        #  Move box to sensor coord system
+        box.translate(-np.array(cs_record["translation"]))
+        box.rotate(Quaternion(cs_record["rotation"]).inverse)
+
+        box_list.append(box)
+
+    return data_path, box_list, cam_intrinsic
+
+
+def quaternion_yaw(q: Quaternion) -> float:
+    """
+    Calculate the yaw angle from a quaternion.
+    Note that this only works for a quaternion that represents a box in lidar or global coordinate frame.
+    It does not work for a box in the camera frame.
+    :param q: Quaternion of interest.
+    :return: Yaw angle in radians.
+    """
+
+    # Project into xy plane.
+    v = np.dot(q.rotation_matrix, np.array([1, 0, 0]))
+
+    # Measure yaw using arctan.
+    yaw = np.arctan2(v[1], v[0])
+
+    return yaw
+
+
+def obtain_sensor2top(
+    nusc, sensor_token, l2e_t, l2e_r_mat, e2g_t, e2g_r_mat, sensor_type="lidar"
+):
+    """Obtain the info with RT matric from general sensor to Top LiDAR.
+
+    Args:
+        nusc (class): Dataset class in the nuScenes dataset.
+        sensor_token (str): Sample data token corresponding to the
+            specific sensor type.
+        l2e_t (np.ndarray): Translation from lidar to ego in shape (1, 3).
+        l2e_r_mat (np.ndarray): Rotation matrix from lidar to ego
+            in shape (3, 3).
+        e2g_t (np.ndarray): Translation from ego to global in shape (1, 3).
+        e2g_r_mat (np.ndarray): Rotation matrix from ego to global
+            in shape (3, 3).
+        sensor_type (str): Sensor to calibrate. Default: "lidar".
+
+    Returns:
+        sweep (dict): Sweep information after transformation.
+    """
+    sd_rec = nusc.get("sample_data", sensor_token)
+    cs_record = nusc.get("calibrated_sensor", sd_rec["calibrated_sensor_token"])
+    pose_record = nusc.get("ego_pose", sd_rec["ego_pose_token"])
+    data_path = str(nusc.get_sample_data_path(sd_rec["token"]))
+    # if os.getcwd() in data_path:  # path from lyftdataset is absolute path
+    #     data_path = data_path.split(f"{os.getcwd()}/")[-1]  # relative path
+    sweep = {
+        "data_path": data_path,
+        "type": sensor_type,
+        "sample_data_token": sd_rec["token"],
+        "sensor2ego_translation": cs_record["translation"],
+        "sensor2ego_rotation": cs_record["rotation"],
+        "ego2global_translation": pose_record["translation"],
+        "ego2global_rotation": pose_record["rotation"],
+        "timestamp": sd_rec["timestamp"],
+    }
+    l2e_r_s = sweep["sensor2ego_rotation"]
+    l2e_t_s = sweep["sensor2ego_translation"]
+    e2g_r_s = sweep["ego2global_rotation"]
+    e2g_t_s = sweep["ego2global_translation"]
+
+    # obtain the RT from sensor to Top LiDAR
+    # sweep->ego->global->ego'->lidar
+    l2e_r_s_mat = Quaternion(l2e_r_s).rotation_matrix
+    e2g_r_s_mat = Quaternion(e2g_r_s).rotation_matrix
+    R = (l2e_r_s_mat.T @ e2g_r_s_mat.T) @ (
+        np.linalg.inv(e2g_r_mat).T @ np.linalg.inv(l2e_r_mat).T
+    )
+    T = (l2e_t_s @ e2g_r_s_mat.T + e2g_t_s) @ (
+        np.linalg.inv(e2g_r_mat).T @ np.linalg.inv(l2e_r_mat).T
+    )
+    T -= (
+        e2g_t @ (np.linalg.inv(e2g_r_mat).T @ np.linalg.inv(l2e_r_mat).T)
+        + l2e_t @ np.linalg.inv(l2e_r_mat).T
+    ).squeeze(0)
+    sweep["sensor2lidar_rotation"] = R.T  # points @ R.T + T
+    sweep["sensor2lidar_translation"] = T
+    return sweep
+
+
+def fill_trainval_infos(
+    data_path, nusc, train_scenes, test=False, max_sweeps=10, with_camera=False
+):
+    train_nusc_infos = []
+    val_nusc_infos = []
+    progress_bar = tqdm.tqdm(
+        total=len(nusc.sample), desc="create_info", dynamic_ncols=True
+    )
+
+    ref_chan = "LIDAR_TOP"  # The radar channel from which we track back n sweeps to aggregate the point cloud.
+    chan = "LIDAR_TOP"  # The reference channel of the current sample_rec that the point clouds are mapped to.
+
+    for index, sample in enumerate(nusc.sample):
+        progress_bar.update()
+
+        ref_sd_token = sample["data"][ref_chan]
+        ref_sd_rec = nusc.get("sample_data", ref_sd_token)
+        ref_cs_rec = nusc.get(
+            "calibrated_sensor", ref_sd_rec["calibrated_sensor_token"]
+        )
+        ref_pose_rec = nusc.get("ego_pose", ref_sd_rec["ego_pose_token"])
+        ref_time = 1e-6 * ref_sd_rec["timestamp"]
+
+        ref_lidar_path, ref_boxes, _ = get_sample_data(nusc, ref_sd_token)
+
+        ref_cam_front_token = sample["data"]["CAM_FRONT"]
+        ref_cam_path, _, ref_cam_intrinsic = nusc.get_sample_data(ref_cam_front_token)
+
+        # Homogeneous transform from ego car frame to reference frame
+        ref_from_car = transform_matrix(
+            ref_cs_rec["translation"], Quaternion(ref_cs_rec["rotation"]), inverse=True
+        )
+
+        # Homogeneous transformation matrix from global to _current_ ego car frame
+        car_from_global = transform_matrix(
+            ref_pose_rec["translation"],
+            Quaternion(ref_pose_rec["rotation"]),
+            inverse=True,
+        )
+        info = {
+            "lidar_path": Path(ref_lidar_path).relative_to(data_path).__str__(),
+            "lidar_token": ref_sd_token,
+            "cam_front_path": Path(ref_cam_path).relative_to(data_path).__str__(),
+            "cam_intrinsic": ref_cam_intrinsic,
+            "token": sample["token"],
+            "sweeps": [],
+            "ref_from_car": ref_from_car,
+            "car_from_global": car_from_global,
+            "timestamp": ref_time,
+        }
+        if with_camera:
+            info["cams"] = dict()
+            l2e_r = ref_cs_rec["rotation"]
+            l2e_t = (ref_cs_rec["translation"],)
+            e2g_r = ref_pose_rec["rotation"]
+            e2g_t = ref_pose_rec["translation"]
+            l2e_r_mat = Quaternion(l2e_r).rotation_matrix
+            e2g_r_mat = Quaternion(e2g_r).rotation_matrix
+
+            # obtain 6 image's information per frame
+            camera_types = [
+                "CAM_FRONT",
+                "CAM_FRONT_RIGHT",
+                "CAM_FRONT_LEFT",
+                "CAM_BACK",
+                "CAM_BACK_LEFT",
+                "CAM_BACK_RIGHT",
+            ]
+            for cam in camera_types:
+                cam_token = sample["data"][cam]
+                cam_path, _, camera_intrinsics = nusc.get_sample_data(cam_token)
+                cam_info = obtain_sensor2top(
+                    nusc, cam_token, l2e_t, l2e_r_mat, e2g_t, e2g_r_mat, cam
+                )
+                cam_info["data_path"] = (
+                    Path(cam_info["data_path"]).relative_to(data_path).__str__()
+                )
+                cam_info.update(camera_intrinsics=camera_intrinsics)
+                info["cams"].update({cam: cam_info})
+
+        sample_data_token = sample["data"][chan]
+        curr_sd_rec = nusc.get("sample_data", sample_data_token)
+        sweeps = []
+        while len(sweeps) < max_sweeps - 1:
+            if curr_sd_rec["prev"] == "":
+                if len(sweeps) == 0:
+                    sweep = {
+                        "lidar_path": Path(ref_lidar_path)
+                        .relative_to(data_path)
+                        .__str__(),
+                        "sample_data_token": curr_sd_rec["token"],
+                        "transform_matrix": None,
+                        "time_lag": curr_sd_rec["timestamp"] * 0,
+                    }
+                    sweeps.append(sweep)
+                else:
+                    sweeps.append(sweeps[-1])
+            else:
+                curr_sd_rec = nusc.get("sample_data", curr_sd_rec["prev"])
+
+                # Get past pose
+                current_pose_rec = nusc.get("ego_pose", curr_sd_rec["ego_pose_token"])
+                global_from_car = transform_matrix(
+                    current_pose_rec["translation"],
+                    Quaternion(current_pose_rec["rotation"]),
+                    inverse=False,
+                )
+
+                # Homogeneous transformation matrix from sensor coordinate frame to ego car frame.
+                current_cs_rec = nusc.get(
+                    "calibrated_sensor", curr_sd_rec["calibrated_sensor_token"]
+                )
+                car_from_current = transform_matrix(
+                    current_cs_rec["translation"],
+                    Quaternion(current_cs_rec["rotation"]),
+                    inverse=False,
+                )
+
+                tm = reduce(
+                    np.dot,
+                    [ref_from_car, car_from_global, global_from_car, car_from_current],
+                )
+
+                lidar_path = nusc.get_sample_data_path(curr_sd_rec["token"])
+
+                time_lag = ref_time - 1e-6 * curr_sd_rec["timestamp"]
+
+                sweep = {
+                    "lidar_path": Path(lidar_path).relative_to(data_path).__str__(),
+                    "sample_data_token": curr_sd_rec["token"],
+                    "transform_matrix": tm,
+                    "global_from_car": global_from_car,
+                    "car_from_current": car_from_current,
+                    "time_lag": time_lag,
+                }
+                sweeps.append(sweep)
+
+        info["sweeps"] = sweeps
+
+        assert len(info["sweeps"]) == max_sweeps - 1, (
+            f"sweep {curr_sd_rec['token']} only has {len(info['sweeps'])} sweeps, "
+            f"you should duplicate to sweep num {max_sweeps - 1}"
+        )
+
+        if not test:
+            # processing gt bbox
+            annotations = [
+                nusc.get("sample_annotation", token) for token in sample["anns"]
+            ]
+
+            # the filtering gives 0.5~1 map improvement
+            num_lidar_pts = np.array([anno["num_lidar_pts"] for anno in annotations])
+            num_radar_pts = np.array([anno["num_radar_pts"] for anno in annotations])
+            mask = num_lidar_pts + num_radar_pts > 0
+
+            locs = np.array([b.center for b in ref_boxes]).reshape(-1, 3)
+            dims = np.array([b.wlh for b in ref_boxes]).reshape(-1, 3)[
+                :, [1, 0, 2]
+            ]  # wlh == > dxdydz (lwh)
+            velocity = np.array([b.velocity for b in ref_boxes]).reshape(-1, 3)
+            rots = np.array([quaternion_yaw(b.orientation) for b in ref_boxes]).reshape(
+                -1, 1
+            )
+            names = np.array([b.name for b in ref_boxes])
+            tokens = np.array([b.token for b in ref_boxes])
+            gt_boxes = np.concatenate([locs, dims, rots, velocity[:, :2]], axis=1)
+
+            assert len(annotations) == len(gt_boxes) == len(velocity)
+
+            info["gt_boxes"] = gt_boxes[mask, :]
+            info["gt_boxes_velocity"] = velocity[mask, :]
+            info["gt_names"] = np.array(
+                [map_name_from_general_to_detection[name] for name in names]
+            )[mask]
+            info["gt_boxes_token"] = tokens[mask]
+            info["num_lidar_pts"] = num_lidar_pts[mask]
+            info["num_radar_pts"] = num_radar_pts[mask]
+
+            # processing gt segment
+            segment_path = nusc.get("lidarseg", ref_sd_token)["filename"]
+            info["gt_segment_path"] = segment_path
+
+        if sample["scene_token"] in train_scenes:
+            train_nusc_infos.append(info)
+        else:
+            val_nusc_infos.append(info)
+
+    progress_bar.close()
+    return train_nusc_infos, val_nusc_infos
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--dataset_root", required=True, help="Path to the nuScenes dataset."
+    )
+    parser.add_argument(
+        "--output_root",
+        required=True,
+        help="Output path where processed information located.",
+    )
+    parser.add_argument(
+        "--max_sweeps", default=10, type=int, help="Max number of sweeps. Default: 10."
+    )
+    parser.add_argument(
+        "--with_camera",
+        action="store_true",
+        default=False,
+        help="Whether use camera or not.",
+    )
+    config = parser.parse_args()
+
+    print(f"Loading nuScenes tables for version v1.0-trainval...")
+    nusc_trainval = NuScenes(
+        version="v1.0-trainval", dataroot=config.dataset_root, verbose=False
+    )
+    available_scenes_trainval = get_available_scenes(nusc_trainval)
+    available_scene_names_trainval = [s["name"] for s in available_scenes_trainval]
+    print("total scene num:", len(nusc_trainval.scene))
+    print("exist scene num:", len(available_scenes_trainval))
+    assert len(available_scenes_trainval) == len(nusc_trainval.scene) == 850
+
+    print(f"Loading nuScenes tables for version v1.0-test...")
+    nusc_test = NuScenes(
+        version="v1.0-test", dataroot=config.dataset_root, verbose=False
+    )
+    available_scenes_test = get_available_scenes(nusc_test)
+    available_scene_names_test = [s["name"] for s in available_scenes_test]
+    print("total scene num:", len(nusc_test.scene))
+    print("exist scene num:", len(available_scenes_test))
+    assert len(available_scenes_test) == len(nusc_test.scene) == 150
+
+    train_scenes = splits.train
+    train_scenes = set(
+        [
+            available_scenes_trainval[available_scene_names_trainval.index(s)]["token"]
+            for s in train_scenes
+        ]
+    )
+    test_scenes = splits.test
+    test_scenes = set(
+        [
+            available_scenes_test[available_scene_names_test.index(s)]["token"]
+            for s in test_scenes
+        ]
+    )
+    print(f"Filling trainval information...")
+    train_nusc_infos, val_nusc_infos = fill_trainval_infos(
+        config.dataset_root,
+        nusc_trainval,
+        train_scenes,
+        test=False,
+        max_sweeps=config.max_sweeps,
+        with_camera=config.with_camera,
+    )
+    print(f"Filling test information...")
+    test_nusc_infos, _ = fill_trainval_infos(
+        config.dataset_root,
+        nusc_test,
+        test_scenes,
+        test=True,
+        max_sweeps=config.max_sweeps,
+        with_camera=config.with_camera,
+    )
+
+    print(f"Saving nuScenes information...")
+    os.makedirs(os.path.join(config.output_root, "info"), exist_ok=True)
+    print(
+        f"train sample: {len(train_nusc_infos)}, val sample: {len(val_nusc_infos)}, test sample: {len(test_nusc_infos)}"
+    )
+    with open(
+        os.path.join(
+            config.output_root,
+            "info",
+            f"nuscenes_infos_{config.max_sweeps}sweeps_train.pkl",
+        ),
+        "wb",
+    ) as f:
+        pickle.dump(train_nusc_infos, f)
+    with open(
+        os.path.join(
+            config.output_root,
+            "info",
+            f"nuscenes_infos_{config.max_sweeps}sweeps_val.pkl",
+        ),
+        "wb",
+    ) as f:
+        pickle.dump(val_nusc_infos, f)
+    with open(
+        os.path.join(
+            config.output_root,
+            "info",
+            f"nuscenes_infos_{config.max_sweeps}sweeps_test.pkl",
+        ),
+        "wb",
+    ) as f:
+        pickle.dump(test_nusc_infos, f)

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/preprocessing/s3dis/preprocess_s3dis.py

@@ -0,0 +1,233 @@
+"""
+Preprocessing Script for S3DIS
+Parsing normal vectors has a large consumption of memory. Please reduce max_workers if memory is limited.
+
+Author: Xiaoyang Wu (xiaoyang.wu.cs@gmail.com)
+Please cite our work if the code is helpful to you.
+"""
+
+import os
+import argparse
+import glob
+import numpy as np
+
+try:
+    import open3d
+except ImportError:
+    import warnings
+
+    warnings.warn("Please install open3d for parsing normal")
+
+try:
+    import trimesh
+except ImportError:
+    import warnings
+
+    warnings.warn("Please install trimesh for parsing normal")
+
+from concurrent.futures import ProcessPoolExecutor
+from itertools import repeat
+
+area_mesh_dict = {}
+
+
+def parse_room(
+    room, angle, dataset_root, output_root, align_angle=True, parse_normal=False
+):
+    print("Parsing: {}".format(room))
+    classes = [
+        "ceiling",
+        "floor",
+        "wall",
+        "beam",
+        "column",
+        "window",
+        "door",
+        "table",
+        "chair",
+        "sofa",
+        "bookcase",
+        "board",
+        "clutter",
+    ]
+    class2label = {cls: i for i, cls in enumerate(classes)}
+    source_dir = os.path.join(dataset_root, room)
+    save_path = os.path.join(output_root, room)
+    os.makedirs(save_path, exist_ok=True)
+    object_path_list = sorted(glob.glob(os.path.join(source_dir, "Annotations/*.txt")))
+
+    room_coords = []
+    room_colors = []
+    room_normals = []
+    room_semantic_gt = []
+    room_instance_gt = []
+
+    for object_id, object_path in enumerate(object_path_list):
+        object_name = os.path.basename(object_path).split("_")[0]
+        obj = np.loadtxt(object_path)
+        coords = obj[:, :3]
+        colors = obj[:, 3:6]
+        # note: in some room there is 'stairs' class
+        class_name = object_name if object_name in classes else "clutter"
+        semantic_gt = np.repeat(class2label[class_name], coords.shape[0])
+        semantic_gt = semantic_gt.reshape([-1, 1])
+        instance_gt = np.repeat(object_id, coords.shape[0])
+        instance_gt = instance_gt.reshape([-1, 1])
+
+        room_coords.append(coords)
+        room_colors.append(colors)
+        room_semantic_gt.append(semantic_gt)
+        room_instance_gt.append(instance_gt)
+
+    room_coords = np.ascontiguousarray(np.vstack(room_coords))
+
+    if parse_normal:
+        x_min, z_max, y_min = np.min(room_coords, axis=0)
+        x_max, z_min, y_max = np.max(room_coords, axis=0)
+        z_max = -z_max
+        z_min = -z_min
+        max_bound = np.array([x_max, y_max, z_max]) + 0.1
+        min_bound = np.array([x_min, y_min, z_min]) - 0.1
+        bbox = open3d.geometry.AxisAlignedBoundingBox(
+            min_bound=min_bound, max_bound=max_bound
+        )
+        # crop room
+        room_mesh = (
+            area_mesh_dict[os.path.dirname(room)]
+            .crop(bbox)
+            .transform(
+                np.array([[1, 0, 0, 0], [0, 0, -1, 0], [0, 1, 0, 0], [0, 0, 0, 1]])
+            )
+        )
+        vertices = np.array(room_mesh.vertices)
+        faces = np.array(room_mesh.triangles)
+        vertex_normals = np.array(room_mesh.vertex_normals)
+        room_mesh = trimesh.Trimesh(
+            vertices=vertices, faces=faces, vertex_normals=vertex_normals
+        )
+        (closest_points, distances, face_id) = room_mesh.nearest.on_surface(room_coords)
+        room_normals = room_mesh.face_normals[face_id]
+
+    if align_angle:
+        angle = (2 - angle / 180) * np.pi
+        rot_cos, rot_sin = np.cos(angle), np.sin(angle)
+        rot_t = np.array([[rot_cos, -rot_sin, 0], [rot_sin, rot_cos, 0], [0, 0, 1]])
+        room_center = (np.max(room_coords, axis=0) + np.min(room_coords, axis=0)) / 2
+        room_coords = (room_coords - room_center) @ np.transpose(rot_t) + room_center
+        if parse_normal:
+            room_normals = room_normals @ np.transpose(rot_t)
+
+    room_colors = np.ascontiguousarray(np.vstack(room_colors))
+    room_semantic_gt = np.ascontiguousarray(np.vstack(room_semantic_gt))
+    room_instance_gt = np.ascontiguousarray(np.vstack(room_instance_gt))
+    np.save(os.path.join(save_path, "coord.npy"), room_coords.astype(np.float32))
+    np.save(os.path.join(save_path, "color.npy"), room_colors.astype(np.uint8))
+    np.save(os.path.join(save_path, "segment.npy"), room_semantic_gt.astype(np.int16))
+    np.save(os.path.join(save_path, "instance.npy"), room_instance_gt.astype(np.int16))
+
+    if parse_normal:
+        np.save(os.path.join(save_path, "normal.npy"), room_normals.astype(np.float32))
+
+
+def main_process():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--splits",
+        required=True,
+        nargs="+",
+        choices=["Area_1", "Area_2", "Area_3", "Area_4", "Area_5", "Area_6"],
+        help="Splits need to process ([Area_1, Area_2, Area_3, Area_4, Area_5, Area_6]).",
+    )
+    parser.add_argument(
+        "--dataset_root", required=True, help="Path to Stanford3dDataset_v1.2 dataset"
+    )
+    parser.add_argument(
+        "--output_root",
+        required=True,
+        help="Output path where area folders will be located",
+    )
+    parser.add_argument(
+        "--raw_root",
+        default=None,
+        help="Path to Stanford2d3dDataset_noXYZ dataset (optional)",
+    )
+    parser.add_argument(
+        "--align_angle", action="store_true", help="Whether align room angles"
+    )
+    parser.add_argument(
+        "--parse_normal", action="store_true", help="Whether process normal"
+    )
+    parser.add_argument(
+        "--num_workers", default=1, type=int, help="Num workers for preprocessing."
+    )
+    args = parser.parse_args()
+
+    if args.parse_normal:
+        assert args.raw_root is not None
+
+    room_list = []
+    angle_list = []
+
+    # Load room information
+    print("Loading room information ...")
+    for split in args.splits:
+        area_info = np.loadtxt(
+            os.path.join(
+                args.dataset_root,
+                split,
+                f"{split}_alignmentAngle.txt",
+            ),
+            dtype=str,
+        )
+        room_list += [os.path.join(split, room_info[0]) for room_info in area_info]
+        angle_list += [int(room_info[1]) for room_info in area_info]
+
+    if args.parse_normal:
+        # load raw mesh file to extract normal
+        print("Loading raw mesh file ...")
+        for split in args.splits:
+            if split != "Area_5":
+                mesh_dir = os.path.join(args.raw_root, split, "3d", "rgb.obj")
+                mesh = open3d.io.read_triangle_mesh(mesh_dir)
+                mesh.triangle_uvs.clear()
+            else:
+                mesh_a_dir = os.path.join(args.raw_root, f"{split}a", "3d", "rgb.obj")
+                mesh_b_dir = os.path.join(args.raw_root, f"{split}b", "3d", "rgb.obj")
+                mesh_a = open3d.io.read_triangle_mesh(mesh_a_dir)
+                mesh_a.triangle_uvs.clear()
+                mesh_b = open3d.io.read_triangle_mesh(mesh_b_dir)
+                mesh_b.triangle_uvs.clear()
+                mesh_b = mesh_b.transform(
+                    np.array(
+                        [
+                            [0, 0, -1, -4.09703582],
+                            [0, 1, 0, 0],
+                            [1, 0, 0, -6.22617759],
+                            [0, 0, 0, 1],
+                        ]
+                    )
+                )
+                mesh = mesh_a + mesh_b
+            area_mesh_dict[split] = mesh
+            print(f"{split} mesh is loaded")
+
+    # Preprocess data.
+    print("Processing scenes...")
+    pool = ProcessPoolExecutor(
+        max_workers=args.num_workers
+    )  # peak 110G memory when parsing normal.
+    _ = list(
+        pool.map(
+            parse_room,
+            room_list,
+            angle_list,
+            repeat(args.dataset_root),
+            repeat(args.output_root),
+            repeat(args.align_angle),
+            repeat(args.parse_normal),
+        )
+    )
+
+
+if __name__ == "__main__":
+    main_process()

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/preprocessing/sampling_chunking_data.py

@@ -0,0 +1,149 @@
+"""
+Chunking Data
+
+Author: Xiaoyang Wu (xiaoyang.wu.cs@gmail.com)
+Please cite our work if the code is helpful to you.
+"""
+
+import os
+import argparse
+import numpy as np
+import multiprocessing as mp
+from concurrent.futures import ProcessPoolExecutor
+from itertools import repeat
+from pathlib import Path
+
+
+def chunking_scene(
+    name,
+    dataset_root,
+    split,
+    grid_size=None,
+    chunk_range=(6, 6),
+    chunk_stride=(3, 3),
+    chunk_minimum_size=10000,
+):
+    print(f"Chunking scene {name} in {split} split")
+    dataset_root = Path(dataset_root)
+    scene_path = dataset_root / split / name
+    assets = os.listdir(scene_path)
+    data_dict = dict()
+    for asset in assets:
+        if not asset.endswith(".npy"):
+            continue
+        data_dict[asset[:-4]] = np.load(scene_path / asset)
+    coord = data_dict["coord"] - data_dict["coord"].min(axis=0)
+
+    if grid_size is not None:
+        grid_coord = np.floor(coord / grid_size).astype(int)
+        _, idx = np.unique(grid_coord, axis=0, return_index=True)
+        coord = coord[idx]
+        for key in data_dict.keys():
+            data_dict[key] = data_dict[key][idx]
+
+    bev_range = coord.max(axis=0)[:2]
+    x, y = np.meshgrid(
+        np.arange(0, bev_range[0] + chunk_stride[0] - chunk_range[0], chunk_stride[0]),
+        np.arange(0, bev_range[0] + chunk_stride[0] - chunk_range[0], chunk_stride[0]),
+        indexing="ij",
+    )
+    chunks = np.concatenate([x.reshape([-1, 1]), y.reshape([-1, 1])], axis=-1)
+    chunk_idx = 0
+    for chunk in chunks:
+        mask = (
+            (coord[:, 0] >= chunk[0])
+            & (coord[:, 0] < chunk[0] + chunk_range[0])
+            & (coord[:, 1] >= chunk[1])
+            & (coord[:, 1] < chunk[1] + chunk_range[1])
+        )
+        if np.sum(mask) < chunk_minimum_size:
+            continue
+
+        chunk_data_name = f"{name}_{chunk_idx}"
+        if grid_size is not None:
+            chunk_split_name = (
+                f"{split}_"
+                f"grid{grid_size * 100:.0f}mm_"
+                f"chunk{chunk_range[0]}x{chunk_range[1]}_"
+                f"stride{chunk_stride[0]}x{chunk_stride[1]}"
+            )
+        else:
+            chunk_split_name = (
+                f"{split}_"
+                f"chunk{chunk_range[0]}x{chunk_range[1]}_"
+                f"stride{chunk_stride[0]}x{chunk_stride[1]}"
+            )
+
+        chunk_save_path = dataset_root / chunk_split_name / chunk_data_name
+        chunk_save_path.mkdir(parents=True, exist_ok=True)
+        for key in data_dict.keys():
+            np.save(chunk_save_path / f"{key}.npy", data_dict[key][mask])
+        chunk_idx += 1
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--dataset_root",
+        required=True,
+        help="Path to the Pointcept processed ScanNet++ dataset.",
+    )
+    parser.add_argument(
+        "--split",
+        required=True,
+        default="train",
+        type=str,
+        help="Split need to process.",
+    )
+    parser.add_argument(
+        "--grid_size",
+        default=None,
+        type=float,
+        help="Grid size for initial grid sampling",
+    )
+    parser.add_argument(
+        "--chunk_range",
+        default=[6, 6],
+        type=int,
+        nargs="+",
+        help="Range of each chunk, e.g. --chunk_range 6 6",
+    )
+    parser.add_argument(
+        "--chunk_stride",
+        default=[3, 3],
+        type=int,
+        nargs="+",
+        help="Stride of each chunk, e.g. --chunk_stride 3 3",
+    )
+    parser.add_argument(
+        "--chunk_minimum_size",
+        default=10000,
+        type=int,
+        help="Minimum number of points in each chunk",
+    )
+    parser.add_argument(
+        "--num_workers",
+        default=mp.cpu_count(),
+        type=int,
+        help="Num workers for preprocessing.",
+    )
+
+    config = parser.parse_args()
+    config.dataset_root = Path(config.dataset_root)
+    data_list = os.listdir(config.dataset_root / config.split)
+
+    print("Processing scenes...")
+    pool = ProcessPoolExecutor(max_workers=config.num_workers)
+    _ = list(
+        pool.map(
+            chunking_scene,
+            data_list,
+            repeat(config.dataset_root),
+            repeat(config.split),
+            repeat(config.grid_size),
+            repeat(config.chunk_range),
+            repeat(config.chunk_stride),
+            repeat(config.chunk_minimum_size),
+        )
+    )
+    pool.shutdown()

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/preprocessing/scannet/dino/prepare_scene_list.py

@@ -0,0 +1,27 @@
+import os
+import argparse
+from pathlib import Path
+
+import numpy as np
+
+if __name__ == "__main__":
+    num_train_list = 12
+    num_val_list = 3
+    meta_root = Path(os.path.dirname(__file__)).parent / "meta_data"
+
+    # Load train/val splits
+    train_scenes = np.loadtxt(meta_root / "scannetv2_train.txt", dtype=str)
+    val_scenes = np.loadtxt(meta_root / "scannetv2_val.txt", dtype=str)
+
+    for i in range(num_train_list):
+        np.savetxt(
+            meta_root / f"scannetv2_train_{i}.txt",
+            train_scenes[i::num_train_list],
+            fmt="%s",
+        )
+    for i in range(num_val_list):
+        np.savetxt(
+            meta_root / f"scannetv2_val_{i}.txt",
+            val_scenes[i::num_val_list],
+            fmt="%s",
+        )

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/preprocessing/scannet/dino/preprocess_dino_feature.py

@@ -0,0 +1,362 @@
+import os
+import argparse
+import einops
+import torch
+import torch.nn.functional as F
+import torchvision
+import tqdm
+import cv2
+import camtools as ct
+import open3d as o3d
+import zlib
+import imageio
+import struct
+import numpy as np
+import torch_scatter
+from pathlib import Path
+
+
+class RGBDFrame:
+    def __init__(self, file_handle):
+        self.camera_to_world = np.asarray(
+            struct.unpack("f" * 16, file_handle.read(16 * 4)), dtype=np.float32
+        ).reshape(4, 4)
+        self.timestamp_color = struct.unpack("Q", file_handle.read(8))[0]
+        self.timestamp_depth = struct.unpack("Q", file_handle.read(8))[0]
+        self.color_size_bytes = struct.unpack("Q", file_handle.read(8))[0]
+        self.depth_size_bytes = struct.unpack("Q", file_handle.read(8))[0]
+        self.color_data = b"".join(
+            struct.unpack(
+                "c" * self.color_size_bytes, file_handle.read(self.color_size_bytes)
+            )
+        )
+        self.depth_data = b"".join(
+            struct.unpack(
+                "c" * self.depth_size_bytes, file_handle.read(self.depth_size_bytes)
+            )
+        )
+
+    def decompress_depth(self, compression_type):
+        if compression_type == "zlib_ushort":
+            return self.decompress_depth_zlib()
+        else:
+            raise
+
+    def decompress_depth_zlib(self):
+        return zlib.decompress(self.depth_data)
+
+    def decompress_color(self, compression_type):
+        if compression_type == "jpeg":
+            return self.decompress_color_jpeg()
+        else:
+            raise
+
+    def decompress_color_jpeg(self):
+        return imageio.v2.imread(self.color_data)
+
+
+class SensorData:
+    COMPRESSION_TYPE_COLOR = {
+        -1: "unknown",
+        0: "raw",
+        1: "png",
+        2: "jpeg",
+    }
+    COMPRESSION_TYPE_DEPTH = {
+        -1: "unknown",
+        0: "raw_ushort",
+        1: "zlib_ushort",
+        2: "occi_ushort",
+    }
+
+    def __init__(self, filename):
+        self.version = 4
+        f = open(filename, "rb")
+        version = struct.unpack("I", f.read(4))[0]
+        assert self.version == version
+        strlen = struct.unpack("Q", f.read(8))[0]
+        self.sensor_name = b"".join(struct.unpack("c" * strlen, f.read(strlen)))
+        self.intrinsic_color = np.asarray(
+            struct.unpack("f" * 16, f.read(16 * 4)), dtype=np.float32
+        ).reshape(4, 4)
+        self.extrinsic_color = np.asarray(
+            struct.unpack("f" * 16, f.read(16 * 4)), dtype=np.float32
+        ).reshape(4, 4)
+        self.intrinsic_depth = np.asarray(
+            struct.unpack("f" * 16, f.read(16 * 4)), dtype=np.float32
+        ).reshape(4, 4)
+        self.extrinsic_depth = np.asarray(
+            struct.unpack("f" * 16, f.read(16 * 4)), dtype=np.float32
+        ).reshape(4, 4)
+        self.color_compression_type = self.COMPRESSION_TYPE_COLOR[
+            struct.unpack("i", f.read(4))[0]
+        ]
+        self.depth_compression_type = self.COMPRESSION_TYPE_DEPTH[
+            struct.unpack("i", f.read(4))[0]
+        ]
+        self.color_width = struct.unpack("I", f.read(4))[0]
+        self.color_height = struct.unpack("I", f.read(4))[0]
+        self.depth_width = struct.unpack("I", f.read(4))[0]
+        self.depth_height = struct.unpack("I", f.read(4))[0]
+        self.depth_shift = struct.unpack("f", f.read(4))[0]
+        self.num_frames = struct.unpack("Q", f.read(8))[0]
+        self.file_handle = f
+
+    def export(
+        self,
+        frame_skip=20,
+        export_color=True,
+        export_depth=True,
+        export_pose=True,
+    ):
+        for i in range(self.num_frames):
+            if i % frame_skip != 0:
+                self.file_handle.seek(16 * 4 + 8 + 8, 1)  # skip pose, timestamp
+                color_size_bytes = struct.unpack("Q", self.file_handle.read(8))[0]
+                depth_size_bytes = struct.unpack("Q", self.file_handle.read(8))[0]
+                self.file_handle.seek(color_size_bytes + depth_size_bytes, 1)
+                continue
+            else:
+                frame = RGBDFrame(self.file_handle)
+                data_dict = {}
+                if export_color:
+                    color = frame.decompress_color(self.color_compression_type)
+                    data_dict["color"] = color
+                if export_depth:
+                    depth = frame.decompress_depth(self.depth_compression_type)
+                    depth = np.frombuffer(depth, dtype=np.uint16).reshape(
+                        self.depth_height, self.depth_width
+                    )
+                    data_dict["depth"] = depth
+                if export_pose:
+                    pose = frame.camera_to_world
+                    data_dict["pose"] = pose
+                yield data_dict
+
+    def __del__(self):
+        self.file_handle.close()
+
+
+def ray_distance_to_z_depth(ray_depth, K):
+    height, width = ray_depth.shape
+
+    u = np.arange(width)
+    v = np.arange(height)
+    u_grid, v_grid = np.meshgrid(u, v)
+
+    fx = K[0, 0]
+    fy = K[1, 1]
+    cx = K[0, 2]
+    cy = K[1, 2]
+
+    u_norm = (u_grid - cx) / fx
+    v_norm = (v_grid - cy) / fy
+
+    norm_square = u_norm**2 + v_norm**2
+
+    z_depth = ray_depth / np.sqrt(norm_square + 1)
+    return z_depth
+
+
+def center_crop(image, crop_ratio=1.0, patch_size=None):
+    if len(image.shape) == 2:
+        height, width = image.shape
+    elif len(image.shape) == 3:
+        height, width, _ = image.shape
+    else:
+        raise ValueError("Invalid image shape")
+    if patch_size is not None:
+        crop_h = int(height * crop_ratio // patch_size * patch_size)
+        crop_w = int(width * crop_ratio // patch_size * patch_size)
+    else:
+        crop_h = int(height * crop_ratio)
+        crop_w = int(width * crop_ratio)
+
+    # Calculate the cropping box
+    start_h = (height - crop_h) // 2
+    start_w = (width - crop_w) // 2
+
+    # Perform the center crop
+    cropped_image = image[start_h : start_h + crop_h, start_w : start_w + crop_w]
+
+    return cropped_image
+
+
+def parsing_scene(
+    scene_path,
+    output_root,
+    split,
+    model,
+    frame_skip=20,
+    grid_size=0.08,
+    crop_ratio=0.95,
+    device="cuda",
+):
+    print(f"Parsing scene: {scene_path.name}")
+    device = torch.device(device)
+    scene_path = Path(scene_path)
+    sensor_reader = SensorData(scene_path / f"{scene_path.name}.sens")
+    mesh = o3d.io.read_triangle_mesh(
+        str(scene_path / f"{scene_path.name}_vh_clean_2.ply")
+    )
+    transform = torchvision.transforms.Compose(
+        [
+            torchvision.transforms.ToTensor(),
+            torchvision.transforms.Normalize(
+                mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)
+            ),
+        ]
+    )
+    scene_coord = []
+    scene_feat = []
+    scene_count = []
+    for data in tqdm.tqdm(
+        sensor_reader.export(frame_skip=frame_skip),
+        total=sensor_reader.num_frames // frame_skip,
+    ):
+        height, width = data["depth"].shape
+        K = sensor_reader.intrinsic_depth[:3, :3]
+        T = data["pose"]
+        if np.isnan(T).any() or np.isinf(T).any():
+            continue
+        depth = ct.raycast.mesh_to_depth(
+            mesh=mesh, K=K, T=np.linalg.inv(T), height=height, width=width
+        )
+        depth = ray_distance_to_z_depth(depth, K)
+        depth = center_crop(depth, crop_ratio, model.patch_size)
+        height_, width_ = depth.shape
+        pixel = np.transpose(np.indices((width_, height_)), (2, 1, 0))
+        pixel = pixel.reshape((-1, 2))
+        pixel = np.hstack((pixel, np.ones((pixel.shape[0], 1))))
+        depth = depth.reshape((-1, 1))
+        valid = ~np.isinf(depth).squeeze(-1)
+        coord = depth[valid] * (np.linalg.inv(K) @ pixel[valid].T).T  # coord_camera
+        coord = coord @ T[:3, :3].T + T[:3, 3]
+
+        color = cv2.resize(
+            data["color"], (width, height), interpolation=cv2.INTER_LINEAR
+        )
+        color = center_crop(color, crop_ratio, model.patch_size)
+        with torch.inference_mode():
+            color_t = transform(color).unsqueeze(0).to(device)
+            feat_t = model.forward_features(color_t)["x_norm_patchtokens"]
+            feat_t = einops.rearrange(
+                feat_t, "1 (h w) c -> 1 c h w", w=width_ // model.patch_size
+            )
+            feat_t = F.interpolate(feat_t, (height_, width_), mode="bilinear")
+            feat_t = einops.rearrange(feat_t, "1 c h w -> (h w) c")[valid]
+            coord_t = torch.tensor(coord, dtype=torch.float32).to(device)
+            scene_coord.append(coord_t)
+            scene_feat.append(feat_t)
+            scene_count.append(
+                torch.ones(coord_t.shape[0], dtype=torch.long, device=device)
+            )
+            scene_coord = torch.concatenate(scene_coord, dim=0)
+            scene_feat = torch.concatenate(scene_feat, dim=0)
+            scene_count = torch.concatenate(scene_count, dim=0)
+
+            # grid sampling
+            grid_coord = torch.floor_divide(scene_coord, grid_size).to(torch.int32)
+            grid_coord, cluster = torch.unique(
+                grid_coord, sorted=True, return_inverse=True, dim=0
+            )
+            scene_coord = [
+                torch_scatter.scatter(scene_coord, cluster, reduce="mean", dim=0)
+            ]
+            scene_feat = [
+                torch_scatter.scatter(scene_feat, cluster, reduce="sum", dim=0)
+            ]
+            scene_count = [
+                torch_scatter.scatter(scene_count, cluster, reduce="sum", dim=0)
+            ]
+
+        # color = color.reshape((-1, 3))[valid]
+        # pcd = o3d.geometry.PointCloud()
+        # pcd.points = o3d.utility.Vector3dVector(coord)
+        # pcd.colors = o3d.utility.Vector3dVector(color / 255)
+        # o3d.visualization.draw_geometries([pcd])
+
+    scene_coord = scene_coord[0]
+    scene_feat = scene_feat[0] / scene_count[0].unsqueeze(-1)
+
+    scene_coord = scene_coord.half().cpu().numpy()
+    scene_feat = scene_feat.half().cpu().numpy()
+    np.savez(
+        Path(output_root) / split / f"{scene_path.name}.npz",
+        coord=scene_coord,
+        feat=scene_feat,
+    )
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--dataset_root",
+        required=True,
+        help="Path to the ScanNet dataset containing scene folders",
+    )
+    parser.add_argument(
+        "--output_root",
+        required=True,
+        help="Output path where train/val folders will be located",
+    )
+    parser.add_argument(
+        "--scene_list",
+        required=True,
+        help="Path to scene list need to process",
+    )
+    parser.add_argument(
+        "--frame_skip",
+        default=10,
+        help="Frame skip for processing",
+    )
+    parser.add_argument(
+        "--grid_size",
+        default=0.08,
+        help="Grid size for sampling",
+    )
+    parser.add_argument(
+        "--crop_ratio",
+        default=0.95,
+        help="Crop ratio for center crop",
+    )
+
+    args = parser.parse_args()
+    scene_list = np.loadtxt(args.scene_list, dtype=str)
+    if "train" in args.scene_list:
+        split = "train"
+        folder = "scans"
+    elif "val" in args.scene_list:
+        split = "val"
+        folder = "scans"
+    else:
+        split = "test"
+        folder = "scans_test"
+
+    os.makedirs(Path(args.output_root) / split, exist_ok=True)
+
+    device = torch.device("cuda")
+    model = torch.hub.load("facebookresearch/dinov2", "dinov2_vitg14").to(device)
+    model.eval()
+    for scene in scene_list:
+        parsing_scene(
+            scene_path=Path(args.dataset_root) / folder / scene,
+            output_root=args.output_root,
+            split=split,
+            frame_skip=args.frame_skip,
+            grid_size=args.grid_size,
+            crop_ratio=args.crop_ratio,
+            model=model,
+            device="cuda",
+        )
+
+    # parsing_scene(
+    #     scene_path=Path("/mnt/e/datasets/raw/scannet/scans/scene0230_00"),
+    #     output_root=args.output_root,
+    #     split=split,
+    #     frame_skip=args.frame_skip,
+    #     grid_size=args.grid_size,
+    #     crop_ratio=args.crop_ratio,
+    #     model=model,
+    #     device="cuda",
+    # )

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/preprocessing/scannet/extract_partition.py

@@ -0,0 +1,71 @@
+import json
+import shutil
+import argparse
+import torch
+import glob
+import os.path
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--dataset_root",
+        required=True,
+        help="Path to the ScanNet dataset containing scene folders",
+    )
+    parser.add_argument(
+        "--processed_root",
+        required=True,
+        help="Path to the processed ScanNet dataset, add partition to test data dict",
+    )
+    parser.add_argument(
+        "--segmentor_root",
+        required=True,
+        help="Path to Felzenswalb and Huttenlocher's Graph Based Image Segmentation binary",
+    )
+    parser.add_argument(
+        "--split",
+        default="test",
+        choices=["test", "val"],
+        help="Split to process. [test / val]",
+    )
+    config = parser.parse_args()
+    if config.split == "test":
+        raw_split = "scans_test"
+    else:
+        raw_split = "scans"
+
+    scene_list = glob.glob(os.path.join(config.processed_root, config.split, "*.pth"))
+    os.makedirs(os.path.join(config.processed_root, "tmp"), exist_ok=True)
+
+    for scene in scene_list:
+        scene_name = os.path.basename(scene).split(".")[0]
+        raw_scene = os.path.join(
+            config.dataset_root,
+            raw_split,
+            scene_name,
+            f"{scene_name}_vh_clean_2.ply",
+        )
+        tmp_scene = os.path.join(
+            config.processed_root,
+            "tmp",
+            f"{scene_name}_vh_clean_2.ply",
+        )
+        # copy original scene to tmp folder
+        shutil.copy(raw_scene, tmp_scene)
+        # run segmentor
+        process = os.popen(f"{config.segmentor_root} {tmp_scene}")
+        print(process.read())
+        process.close()
+        # load partition file
+        partition_file = tmp_scene.replace(".ply", ".0.010000.segs.json")
+        with open(partition_file) as f:
+            partition = json.load(f)["segIndices"]
+        data_dict = torch.load(scene)
+        data_dict["partition"] = partition
+        torch.save(data_dict, scene)
+        # clean tmp
+        os.remove(partition_file)
+        os.remove(tmp_scene)
+        print(f"Adding partition information to {scene_name}")
+
+    os.rmdir(os.path.join(config.processed_root, "tmp"))

gf_s3dis_ss_0.05/latent-fusion-r-0.5/code/pointcept/datasets/preprocessing/scannet/meta_data/classes_ObjClassification-ShapeNetCore55.txt

@@ -0,0 +1,17 @@
+1	trash
+3 	basket
+4	bathtub
+5	bed
+9	shelf
+13	cabinet
+18	chair
+20	keyboard
+22	tv
+30	lamp
+31	laptop
+35	microwave
+39	pillow
+42	printer
+47	sofa
+48	stove
+49	table