File size: 4,145 Bytes
fc16538
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

import os

import numpy as np

import cv2

from vidar.datasets.BaseDataset import BaseDataset
from vidar.datasets.utils.FolderTree import FolderTree
from vidar.datasets.utils.misc import stack_sample
from vidar.utils.read import read_image
from vidar.datasets.BaseDataset import BaseDataset
from vidar.datasets.utils.misc import invert_pose, stack_sample, make_relative_pose
from vidar.utils.read import read_image


class ScanNetTemporalDataset(BaseDataset):
    def __init__(self, tag=None, single_folder=False, split=None, stride=1, **kwargs):
        super().__init__(**kwargs)
        self.tag = 'scannet_temporal' if tag is None else tag
        if split is None or split == '':
            split = ('', )
        self.rgb_tree = FolderTree(
            os.path.join(self.path, split),
            context=self.context, sub_folders=['color'], stride=stride,
            single_folder=single_folder, suffix='.jpg')

    def __len__(self):
        """Dataset length"""
        return len(self.rgb_tree)

    @staticmethod
    def get_intrinsics(rgb):
        """Return dummy intrinsics"""
        return np.array([[rgb.size[0] / 2., 0., rgb.size[0] / 2.],
                         [0., rgb.size[1], rgb.size[1] / 2.],
                         [0., 0., 1.]])

    @staticmethod
    def load_intrinsics(filename):
        filename_intrinsics = {key: '/'.join(val.split('/')[:-2]) + '/intrinsic/intrinsic_depth.txt'
                               for key, val in filename.items()}
        return {key: np.genfromtxt(val).astype(np.float32).reshape((4, 4))[:3, :3]
                for key, val in filename_intrinsics.items()}

    @staticmethod
    def load_depth(filename):
        try:
            filename_depth = {key: val.replace('color', 'depth').replace('.jpg', '.png')
                            for key, val in filename.items()}
            return {key: (cv2.imread(val, cv2.IMREAD_ANYDEPTH).astype(np.float32) / 1000.0)
                    for key, val in filename_depth.items()}
        except:
            filename_depth = {key: val.replace('color', 'depth').replace('.jpg', '.npy')
                            for key, val in filename.items()}
            return {key: (np.load(val) / 1000.0).astype(np.float32)
                    for key, val in filename_depth.items()}

    @staticmethod
    def load_pose(filename):
        filename_pose = {key: val.replace('color', 'pose').replace('.jpg', '.txt')
                          for key, val in filename.items()}
        return {key: invert_pose(np.genfromtxt(val).astype(np.float32).reshape((4, 4)))
                for key, val in filename_pose.items()}

    def __getitem__(self, idx):
        """Get dataset sample given an index."""

        samples = []

        for _ in self.cameras:

            # Filename
            filename = self.rgb_tree.get_item(idx)

            # Base sample
            sample = {
                'idx': idx,
                'tag': self.tag,
                'filename': self.relative_path(filename),
                'splitname': '%010d' % idx
            }

            # Image
            sample['rgb'] = read_image(filename)

            # Intrinsics
            sample['intrinsics'] = self.load_intrinsics(filename)

            if self.with_depth:
                sample['depth'] = self.load_depth(filename)

            if self.with_pose:
                sample['pose'] = self.load_pose(filename)

            # If with context
            if self.with_context:
                filename_context = self.rgb_tree.get_context(idx)
                sample['rgb'].update(read_image(filename_context))
                if self.with_depth:
                    sample['depth'].update(self.load_depth(filename_context))
                if self.with_pose:
                    sample['pose'].update(self.load_pose(filename_context))

            # Stack sample
            samples.append(sample)

        # Make relative poses
        samples = make_relative_pose(samples)

        # Transform data
        if self.data_transform:
            samples = self.data_transform(samples)

        # Return stacked sample
        return stack_sample(samples)