Add files using upload-large-folder tool

Orient_Anything/render/__init__.py

@@ -0,0 +1,3 @@
+# flake8: noqa
+from .core import render
+from .model import Model

Orient_Anything/render/core.py

@@ -0,0 +1,370 @@
+import typing as t
+from functools import partial
+
+import numpy as np
+from copy import deepcopy
+from .canvas import Canvas
+
+from . import speedup
+
+
+# 2D part
+
+
+class Vec2d:
+    __slots__ = "x", "y", "arr"
+
+    def __init__(self, *args):
+        if len(args) == 1 and isinstance(args[0], Vec3d):
+            self.arr = Vec3d.narr
+        else:
+            assert len(args) == 2
+            self.arr = list(args)
+
+        self.x, self.y = [d if isinstance(d, int) else int(d + 0.5) for d in self.arr]
+
+    def __repr__(self):
+        return f"Vec2d({self.x}, {self.y})"
+
+    def __truediv__(self, other):
+        return (self.y - other.y) / (self.x - other.x)
+
+    def __eq__(self, other):
+        return self.x == other.x and self.y == other.y
+
+
+def draw_line(
+    v1: Vec2d, v2: Vec2d, canvas: Canvas, color: t.Union[tuple, str] = "white"
+):
+    """
+    Draw a line with a specified color
+
+    https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm
+    """
+    v1, v2 = deepcopy(v1), deepcopy(v2)
+    if v1 == v2:
+        canvas.draw((v1.x, v1.y), color=color)
+        return
+
+    steep = abs(v1.y - v2.y) > abs(v1.x - v2.x)
+    if steep:
+        v1.x, v1.y = v1.y, v1.x
+        v2.x, v2.y = v2.y, v2.x
+    v1, v2 = (v1, v2) if v1.x < v2.x else (v2, v1)
+    slope = abs((v1.y - v2.y) / (v1.x - v2.x))
+    y = v1.y
+    error: float = 0
+    incr = 1 if v1.y < v2.y else -1
+    dots = []
+    for x in range(int(v1.x), int(v2.x + 0.5)):
+        dots.append((int(y), x) if steep else (x, int(y)))
+        error += slope
+        if abs(error) >= 0.5:
+            y += incr
+            error -= 1
+
+    canvas.draw(dots, color=color)
+
+
+def draw_triangle(v1, v2, v3, canvas, color, wireframe=False):
+    """
+    Draw a triangle with 3 ordered vertices
+
+    http://www.sunshine2k.de/coding/java/TriangleRasterization/TriangleRasterization.html
+    """
+    _draw_line = partial(draw_line, canvas=canvas, color=color)
+
+    if wireframe:
+        _draw_line(v1, v2)
+        _draw_line(v2, v3)
+        _draw_line(v1, v3)
+        return
+
+    def sort_vertices_asc_by_y(vertices):
+        return sorted(vertices, key=lambda v: v.y)
+
+    def fill_bottom_flat_triangle(v1, v2, v3):
+        invslope1 = (v2.x - v1.x) / (v2.y - v1.y)
+        invslope2 = (v3.x - v1.x) / (v3.y - v1.y)
+
+        x1 = x2 = v1.x
+        y = v1.y
+
+        while y <= v2.y:
+            _draw_line(Vec2d(x1, y), Vec2d(x2, y))
+            x1 += invslope1
+            x2 += invslope2
+            y += 1
+
+    def fill_top_flat_triangle(v1, v2, v3):
+        invslope1 = (v3.x - v1.x) / (v3.y - v1.y)
+        invslope2 = (v3.x - v2.x) / (v3.y - v2.y)
+
+        x1 = x2 = v3.x
+        y = v3.y
+
+        while y > v2.y:
+            _draw_line(Vec2d(x1, y), Vec2d(x2, y))
+            x1 -= invslope1
+            x2 -= invslope2
+            y -= 1
+
+    v1, v2, v3 = sort_vertices_asc_by_y((v1, v2, v3))
+
+    # 填充
+    if v1.y == v2.y == v3.y:
+        pass
+    elif v2.y == v3.y:
+        fill_bottom_flat_triangle(v1, v2, v3)
+    elif v1.y == v2.y:
+        fill_top_flat_triangle(v1, v2, v3)
+    else:
+        v4 = Vec2d(int(v1.x + (v2.y - v1.y) / (v3.y - v1.y) * (v3.x - v1.x)), v2.y)
+        fill_bottom_flat_triangle(v1, v2, v4)
+        fill_top_flat_triangle(v2, v4, v3)
+
+
+# 3D part
+
+
+class Vec3d:
+    __slots__ = "x", "y", "z", "arr"
+
+    def __init__(self, *args):
+        # for Vec4d cast
+        if len(args) == 1 and isinstance(args[0], Vec4d):
+            vec4 = args[0]
+            arr_value = (vec4.x, vec4.y, vec4.z)
+        else:
+            assert len(args) == 3
+            arr_value = args
+        self.arr = np.array(arr_value, dtype=np.float64)
+        self.x, self.y, self.z = self.arr
+
+    def __repr__(self):
+        return repr(f"Vec3d({','.join([repr(d) for d in self.arr])})")
+
+    def __sub__(self, other):
+        return self.__class__(*[ds - do for ds, do in zip(self.arr, other.arr)])
+
+    def __bool__(self):
+        """ False for zero vector (0, 0, 0)
+        """
+        return any(self.arr)
+
+
+class Mat4d:
+    def __init__(self, narr=None, value=None):
+        self.value = np.matrix(narr) if value is None else value
+
+    def __repr__(self):
+        return repr(self.value)
+
+    def __mul__(self, other):
+        return self.__class__(value=self.value * other.value)
+
+
+class Vec4d(Mat4d):
+    def __init__(self, *narr, value=None):
+        if value is not None:
+            self.value = value
+        elif len(narr) == 1 and isinstance(narr[0], Mat4d):
+            self.value = narr[0].value
+        else:
+            assert len(narr) == 4
+            self.value = np.matrix([[d] for d in narr])
+
+        self.x, self.y, self.z, self.w = (
+            self.value[0, 0],
+            self.value[1, 0],
+            self.value[2, 0],
+            self.value[3, 0],
+        )
+        self.arr = self.value.reshape((1, 4))
+
+
+# Math util
+def normalize(v: Vec3d):
+    return Vec3d(*speedup.normalize(*v.arr))
+
+
+def dot_product(a: Vec3d, b: Vec3d):
+    return speedup.dot_product(*a.arr, *b.arr)
+
+
+def cross_product(a: Vec3d, b: Vec3d):
+    return Vec3d(*speedup.cross_product(*a.arr, *b.arr))
+
+BASE_LIGHT = 0.9
+def get_light_intensity(face) -> float:
+    # lights = [Vec3d(-2, 4, -10), Vec3d(10, 4, -2), Vec3d(8, 8, -8), Vec3d(0, 0, -8)]
+    lights = [Vec3d(-2, 4, -10)]
+    # lights = []
+
+    v1, v2, v3 = face
+    up = normalize(cross_product(v2 - v1, v3 - v1))
+    intensity = BASE_LIGHT
+    for light in lights:
+        intensity += dot_product(up, normalize(light))*0.2
+    return intensity
+
+
+def look_at(eye: Vec3d, target: Vec3d, up: Vec3d = Vec3d(0, -1, 0)) -> Mat4d:
+    """
+    http://www.songho.ca/opengl/gl_camera.html#lookat
+
+    Args:
+        eye: 摄像机的世界坐标位置
+        target: 观察点的位置
+        up: 就是你想让摄像机立在哪个方向
+            https://stackoverflow.com/questions/10635947/what-exactly-is-the-up-vector-in-opengls-lookat-function
+            这里默认使用了 0, -1, 0， 因为 blender 导出来的模型数据似乎有问题，导致y轴总是反的，于是把摄像机的up也翻一下得了。
+    """
+    f = normalize(eye - target)
+    l = normalize(cross_product(up, f))  # noqa: E741
+    u = cross_product(f, l)
+
+    rotate_matrix = Mat4d(
+        [[l.x, l.y, l.z, 0], [u.x, u.y, u.z, 0], [f.x, f.y, f.z, 0], [0, 0, 0, 1.0]]
+    )
+    translate_matrix = Mat4d(
+        [[1, 0, 0, -eye.x], [0, 1, 0, -eye.y], [0, 0, 1, -eye.z], [0, 0, 0, 1.0]]
+    )
+
+    return Mat4d(value=(rotate_matrix * translate_matrix).value)
+
+
+def perspective_project(r, t, n, f, b=None, l=None):  # noqa: E741
+    """
+    目的：
+        把相机坐标转换成投影在视网膜的范围在(-1, 1)的笛卡尔坐标
+
+    原理：
+        对于x，y坐标，相似三角形可以算出投影点的x，y
+        对于z坐标，是假设了near是-1，far是1，然后带进去算的
+        http://www.songho.ca/opengl/gl_projectionmatrix.html
+        https://www.scratchapixel.com/lessons/3d-basic-rendering/perspective-and-orthographic-projection-matrix/opengl-perspective-projection-matrix
+
+    推导出来的矩阵：
+        [
+            2n/(r-l) 0        (r+l/r-l)   0
+            0        2n/(t-b) (t+b)/(t-b) 0
+            0        0        -(f+n)/f-n  (-2*f*n)/(f-n)
+            0        0        -1          0
+        ]
+
+    实际上由于我们用的视网膜(near pane)是个关于远点对称的矩形，所以矩阵简化为：
+        [
+            n/r      0        0           0
+            0        n/t      0           0
+            0        0        -(f+n)/f-n  (-2*f*n)/(f-n)
+            0        0        -1          0
+        ]
+
+    Args:
+        r: right, t: top, n: near, f: far, b: bottom, l: left
+    """
+    return Mat4d(
+        [
+            [n / r, 0, 0, 0],
+            [0, n / t, 0, 0],
+            [0, 0, -(f + n) / (f - n), (-2 * f * n) / (f - n)],
+            [0, 0, -1, 0],
+        ]
+    )
+
+
+def draw(screen_vertices, world_vertices, model, canvas, wireframe=True):
+    """standard algorithm
+    """
+    for triangle_indices in model.indices:
+        vertex_group = [screen_vertices[idx - 1] for idx in triangle_indices]
+        face = [Vec3d(world_vertices[idx - 1]) for idx in triangle_indices]
+        if wireframe:
+            draw_triangle(*vertex_group, canvas=canvas, color="black", wireframe=True)
+        else:
+            intensity = get_light_intensity(face)
+            if intensity > 0:
+                draw_triangle(
+                    *vertex_group, canvas=canvas, color=(int(intensity * 255),) * 3
+                )
+
+
+def draw_with_z_buffer(screen_vertices, world_vertices, model, canvas):
+    """ z-buffer algorithm
+    """
+    intensities = []
+    triangles = []
+    for i, triangle_indices in enumerate(model.indices):
+        screen_triangle = [screen_vertices[idx - 1] for idx in triangle_indices]
+        uv_triangle = [model.uv_vertices[idx - 1] for idx in model.uv_indices[i]]
+        world_triangle = [Vec3d(world_vertices[idx - 1]) for idx in triangle_indices]
+        intensities.append(abs(get_light_intensity(world_triangle)))
+        # take off the class to let Cython work
+        triangles.append(
+            [np.append(screen_triangle[i].arr, uv_triangle[i]) for i in range(3)]
+        )
+
+    faces = speedup.generate_faces(
+        np.array(triangles, dtype=np.float64), model.texture_width, model.texture_height
+    )
+    for face_dots in faces:
+        for dot in face_dots:
+            intensity = intensities[dot[0]]
+            u, v = dot[3], dot[4]
+            color = model.texture_array[u, v]
+            canvas.draw((dot[1], dot[2]), tuple(int(c * intensity) for c in color[:3]))
+            # TODO: add object rendering mode (no texture)
+            # canvas.draw((dot[1], dot[2]), (int(255 * intensity),) * 3)
+
+
+def render(model, height, width, filename, cam_loc, wireframe=False):
+    """
+    Args:
+        model: the Model object
+        height: cavas height
+        width: cavas width
+        picname: picture file name
+    """
+    model_matrix = Mat4d([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])
+    # TODO: camera configration
+    view_matrix = look_at(Vec3d(cam_loc[0], cam_loc[1], cam_loc[2]), Vec3d(0, 0, 0))
+    projection_matrix = perspective_project(0.5, 0.5, 3, 1000)
+
+    world_vertices = []
+
+    def mvp(v):
+        world_vertex = model_matrix * v
+        world_vertices.append(Vec4d(world_vertex))
+        return projection_matrix * view_matrix * world_vertex
+
+    def ndc(v):
+        """
+        各个坐标同时除以 w，得到 NDC 坐标
+        """
+        v = v.value
+        w = v[3, 0]
+        x, y, z = v[0, 0] / w, v[1, 0] / w, v[2, 0] / w
+        return Mat4d([[x], [y], [z], [1 / w]])
+
+    def viewport(v):
+        x = y = 0
+        w, h = width, height
+        n, f = 0.3, 1000
+        return Vec3d(
+            w * 0.5 * v.value[0, 0] + x + w * 0.5,
+            h * 0.5 * v.value[1, 0] + y + h * 0.5,
+            0.5 * (f - n) * v.value[2, 0] + 0.5 * (f + n),
+        )
+
+    # the render pipeline
+    screen_vertices = [viewport(ndc(mvp(v))) for v in model.vertices]
+
+    with Canvas(filename, height, width) as canvas:
+        if wireframe:
+            draw(screen_vertices, world_vertices, model, canvas)
+        else:
+            draw_with_z_buffer(screen_vertices, world_vertices, model, canvas)
+        
+        render_img = canvas.add_white_border().copy()
+    return render_img

external/Metric3D/training/mono/configs/RAFTDecoder/vit.raft5.giant2.kitti.py

@@ -0,0 +1,132 @@
+_base_=['../_base_/losses/all_losses.py',
+       '../_base_/models/encoder_decoder/dino_vit_giant2_reg.dpt_raft.py',
+
+       '../_base_/datasets/nyu.py',
+       '../_base_/datasets/kitti.py'
+       ]
+
+import numpy as np
+model=dict(
+    decode_head=dict(
+        type='RAFTDepthNormalDPT5',
+        iters=8,
+        n_downsample=2,
+        detach=False,
+    ),
+)
+
+# loss method
+losses=dict(
+    decoder_losses=[
+        dict(type='VNLoss', sample_ratio=0.2, loss_weight=0.1),   
+        dict(type='GRUSequenceLoss', loss_weight=1.0, loss_gamma=0.9, stereo_sup=0),
+        dict(type='DeNoConsistencyLoss', loss_weight=0.001, loss_fn='CEL', scale=2)
+    ],
+)
+
+data_array = [
+
+     [
+          dict(KITTI='KITTI_dataset'),
+     ],
+]
+
+
+
+# configs of the canonical space
+data_basic=dict(
+    canonical_space = dict(
+        # img_size=(540, 960),
+        focal_length=1000.0,
+    ),
+    depth_range=(0, 1),
+    depth_normalize=(0.1, 200),
+#     crop_size=(544, 1216),
+#     crop_size = (544, 992),
+    crop_size = (616, 1064),  # %28 = 0
+) 
+
+# online evaluation
+# evaluation = dict(online_eval=True, interval=1000, metrics=['abs_rel', 'delta1', 'rmse'], multi_dataset_eval=True)
+#log_interval = 100
+
+interval = 4000
+log_interval = 100
+evaluation = dict(
+    online_eval=False, 
+    interval=interval, 
+    metrics=['abs_rel', 'delta1', 'rmse', 'normal_mean', 'normal_rmse', 'normal_a1'], 
+    multi_dataset_eval=True,
+    exclude=['DIML_indoor', 'GL3D', 'Tourism', 'MegaDepth'],
+)
+
+# save checkpoint during training, with '*_AMP' is employing the automatic mix precision training
+checkpoint_config = dict(by_epoch=False, interval=interval)
+runner = dict(type='IterBasedRunner_AMP', max_iters=20010)
+
+# optimizer
+optimizer = dict(
+    type='AdamW', 
+    encoder=dict(lr=5e-7, betas=(0.9, 0.999), weight_decay=0, eps=1e-10),
+    decoder=dict(lr=1e-5, betas=(0.9, 0.999), weight_decay=0, eps=1e-10),
+    strict_match = True
+)
+# schedule
+lr_config = dict(policy='poly',
+                 warmup='linear',
+                 warmup_iters=20,
+                 warmup_ratio=1e-6,
+                 power=0.9, min_lr=1e-8, by_epoch=False)
+
+acc_batch = 1
+batchsize_per_gpu = 2
+thread_per_gpu = 2
+
+KITTI_dataset=dict(
+    data = dict(
+    train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))

external/Metric3D/training/mono/configs/RAFTDecoder/vit.raft5.giant2.nyu.py

@@ -0,0 +1,136 @@
+_base_=['../_base_/losses/all_losses.py',
+       '../_base_/models/encoder_decoder/dino_vit_giant2_reg.dpt_raft.py',
+
+       '../_base_/datasets/nyu.py',
+       '../_base_/datasets/kitti.py'
+       ]
+
+import numpy as np
+model=dict(
+    decode_head=dict(
+        type='RAFTDepthNormalDPT5',
+        iters=8,
+        n_downsample=2,
+        detach=False,
+    ),
+)
+
+# loss method
+losses=dict(
+    decoder_losses=[
+        dict(type='VNLoss', sample_ratio=0.2, loss_weight=1.0),   
+        dict(type='GRUSequenceLoss', loss_weight=1.0, loss_gamma=0.9, stereo_sup=0),
+        dict(type='NormalBranchLoss', loss_weight=1.5, loss_fn='NLL_ours_GRU'),
+        dict(type='DeNoConsistencyLoss', loss_weight=0.001, loss_fn='CEL', scale=2),
+        dict(type='HDNRandomLoss', loss_weight=0.5, random_num=10),
+        dict(type='HDSNRandomLoss', loss_weight=0.5, random_num=20, batch_limit=4),
+        dict(type='PWNPlanesLoss', loss_weight=1),
+    ],
+)
+
+data_array = [
+
+     [
+          dict(NYU='NYU_dataset'),
+     ],
+]
+
+
+
+# configs of the canonical space
+data_basic=dict(
+    canonical_space = dict(
+        # img_size=(540, 960),
+        focal_length=1000.0,
+    ),
+    depth_range=(0, 1),
+    depth_normalize=(0.1, 200),
+#     crop_size=(544, 1216),
+#     crop_size = (544, 992),
+    crop_size = (616, 1064),  # %28 = 0
+) 
+
+# online evaluation
+# evaluation = dict(online_eval=True, interval=1000, metrics=['abs_rel', 'delta1', 'rmse'], multi_dataset_eval=True)
+#log_interval = 100
+
+interval = 4000
+log_interval = 200
+evaluation = dict(
+    online_eval=False, 
+    interval=interval, 
+    metrics=['abs_rel', 'delta1', 'rmse', 'normal_mean', 'normal_rmse', 'normal_a1'], 
+    multi_dataset_eval=True,
+    exclude=['DIML_indoor', 'GL3D', 'Tourism', 'MegaDepth'],
+)
+
+# save checkpoint during training, with '*_AMP' is employing the automatic mix precision training
+checkpoint_config = dict(by_epoch=False, interval=interval)
+runner = dict(type='IterBasedRunner_AMP', max_iters=20010)
+
+# optimizer
+optimizer = dict(
+    type='AdamW', 
+    encoder=dict(lr=5e-7, betas=(0.9, 0.999), weight_decay=0, eps=1e-10),
+    decoder=dict(lr=1e-5, betas=(0.9, 0.999), weight_decay=0, eps=1e-10),
+    strict_match = True
+)
+# schedule
+lr_config = dict(policy='poly',
+                 warmup='linear',
+                 warmup_iters=20,
+                 warmup_ratio=1e-6,
+                 power=0.9, min_lr=1e-8, by_epoch=False)
+
+acc_batch = 1
+batchsize_per_gpu = 2
+thread_per_gpu = 2
+
+NYU_dataset=dict(
+    data = dict(
+    train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))

external/Metric3D/training/mono/configs/RAFTDecoder/vit.raft5.giant2.py

@@ -0,0 +1,1048 @@
+_base_=['../_base_/losses/all_losses.py',
+       '../_base_/models/encoder_decoder/dino_vit_giant2_reg.dpt_raft.py',
+
+       '../_base_/datasets/ddad.py',
+       '../_base_/datasets/_data_base_.py',
+       '../_base_/datasets/argovers2.py',
+       '../_base_/datasets/cityscapes.py',
+       '../_base_/datasets/drivingstereo.py',
+       '../_base_/datasets/dsec.py',
+       '../_base_/datasets/lyft.py',
+       '../_base_/datasets/mapillary_psd.py',
+       '../_base_/datasets/diml.py',
+       '../_base_/datasets/taskonomy.py',
+       '../_base_/datasets/uasol.py',
+       '../_base_/datasets/pandaset.py',
+       '../_base_/datasets/waymo.py',
+
+       '../_base_/default_runtime.py',
+       '../_base_/schedules/schedule_1m.py',
+       
+       '../_base_/datasets/hm3d.py',
+       '../_base_/datasets/matterport3d.py',
+       '../_base_/datasets/replica.py',
+       '../_base_/datasets/vkitti.py',
+       ]
+
+import numpy as np
+model=dict(
+    decode_head=dict(
+        type='RAFTDepthNormalDPT5',
+        iters=8,
+        n_downsample=2,
+        detach=False,
+    ),
+)
+
+# loss method
+losses=dict(
+    decoder_losses=[
+        dict(type='VNLoss', sample_ratio=0.2, loss_weight=1.0),   
+        dict(type='GRUSequenceLoss', loss_weight=0.5, loss_gamma=0.9, stereo_sup=0.0),     
+        dict(type='SkyRegularizationLoss', loss_weight=0.001, sample_ratio=0.4, regress_value=200, normal_regress=[0, 0, -1]),
+        dict(type='HDNRandomLoss', loss_weight=0.5, random_num=10),
+        dict(type='HDSNRandomLoss', loss_weight=0.5, random_num=20, batch_limit=4),
+        dict(type='PWNPlanesLoss', loss_weight=1),
+        dict(type='NormalBranchLoss', loss_weight=1.5, loss_fn='NLL_ours_GRU'),
+        dict(type='DeNoConsistencyLoss', loss_weight=0.01, loss_fn='CEL', scale=2, depth_detach=True)
+    ],
+    gru_losses=[
+        dict(type='SkyRegularizationLoss', loss_weight=0.001, sample_ratio=0.4, regress_value=200, normal_regress=[0, 0, -1]),
+    ],
+)
+
+data_array = [
+     # Outdoor 1
+    [
+         dict(UASOL='UASOL_dataset'), #13.6w
+        dict(Cityscapes_trainextra='Cityscapes_dataset'), #1.8w
+        dict(Cityscapes_sequence='Cityscapes_dataset'), #13.5w
+          dict(DIML='DIML_dataset'), # 12.2w
+         dict(Waymo='Waymo_dataset'), # 99w
+    ], 
+     # Outdoor 2
+    [
+          dict(DSEC='DSEC_dataset'),
+          dict(Mapillary_PSD='MapillaryPSD_dataset'), # 74.2w 
+         dict(DrivingStereo='DrivingStereo_dataset'), # 17.6w
+         dict(Argovers2='Argovers2_dataset'), # 285.6w
+    ],
+     # Outdoor 3
+    [
+          dict(Lyft='Lyft_dataset'), #15.8w
+        dict(DDAD='DDAD_dataset'), #7.4w
+        dict(Pandaset='Pandaset_dataset'), #3.8w
+        dict(Virtual_KITTI='VKITTI_dataset'), # 3.7w # syn
+    ],
+     #Indoor 1
+    [
+         dict(Replica='Replica_dataset'), # 5.6w # syn
+         dict(Replica_gso='Replica_dataset'), # 10.7w # syn
+         dict(Hypersim='Hypersim_dataset'), # 2.4w
+         dict(ScanNetAll='ScanNetAll_dataset'),
+    ],
+     # Indoor 2
+    [
+          dict(Taskonomy='Taskonomy_dataset'), #447.2w
+        dict(Matterport3D='Matterport3D_dataset'), #14.4w
+        dict(HM3D='HM3D_dataset'), # 200w, very noisy, sampled some data
+    ],
+]
+
+
+
+# configs of the canonical space
+data_basic=dict(
+    canonical_space = dict(
+        # img_size=(540, 960),
+        focal_length=1000.0,
+    ),
+    depth_range=(0, 1),
+    depth_normalize=(0.1, 200),
+#     crop_size=(544, 1216),
+#     crop_size = (544, 992),
+    crop_size = (616, 1064),  # %28 = 0
+) 
+
+log_interval = 100
+acc_batch = 1
+# online evaluation
+# evaluation = dict(online_eval=True, interval=1000, metrics=['abs_rel', 'delta1', 'rmse'], multi_dataset_eval=True)
+interval = 40000
+evaluation = dict(
+    online_eval=False, 
+    interval=interval, 
+    metrics=['abs_rel', 'delta1', 'rmse', 'normal_mean', 'normal_rmse', 'normal_a1'], 
+    multi_dataset_eval=True,
+    exclude=['DIML_indoor', 'GL3D', 'Tourism', 'MegaDepth'],
+)
+
+# save checkpoint during training, with '*_AMP' is employing the automatic mix precision training
+checkpoint_config = dict(by_epoch=False, interval=interval)
+runner = dict(type='IterBasedRunner_AMP', max_iters=800010)
+
+# optimizer
+optimizer = dict(
+    type='AdamW', 
+#     encoder=dict(lr=1e-4, betas=(0.9, 0.999), weight_decay=0.01, eps=1e-6),
+    encoder=dict(lr=8e-6, betas=(0.9, 0.999), weight_decay=1e-3, eps=1e-6),
+    decoder=dict(lr=1e-4, betas=(0.9, 0.999), weight_decay=0.01, eps=1e-6),
+    #strict_match=True
+)
+# schedule
+lr_config = dict(policy='poly',
+                 warmup='linear',
+                 warmup_iters=1000,
+                 warmup_ratio=1e-6,
+                 power=0.9, min_lr=1e-6, by_epoch=False)
+
+batchsize_per_gpu = 3
+thread_per_gpu = 1
+
+Argovers2_dataset=dict(
+    data = dict(
+    train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Cityscapes_dataset=dict(
+    data = dict(
+    train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+DIML_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Lyft_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+DDAD_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+     #    sample_size = 1200,
+    ),
+    ))
+DSEC_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+DrivingStereo_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+MapillaryPSD_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Pandaset_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Taskonomy_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+UASOL_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Waymo_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Matterport3D_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Replica_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+VKITTI_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+HM3D_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.75, 1.3),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+BlendedMVG_omni_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.75, 1.3),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+    ),
+    ))
+ScanNetAll_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Hypersim_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))

external/Metric3D/training/mono/configs/RAFTDecoder/vit.raft5.large.kitti.py

@@ -0,0 +1,132 @@
+_base_=['../_base_/losses/all_losses.py',
+       '../_base_/models/encoder_decoder/dino_vit_large_reg.dpt_raft.py',
+
+       '../_base_/datasets/nyu.py',
+       '../_base_/datasets/kitti.py'
+       ]
+
+import numpy as np
+model=dict(
+    decode_head=dict(
+        type='RAFTDepthNormalDPT5',
+        iters=8,
+        n_downsample=2,
+        detach=False,
+    ),
+)
+
+# loss method
+losses=dict(
+    decoder_losses=[
+        dict(type='VNLoss', sample_ratio=0.2, loss_weight=0.1),   
+        dict(type='GRUSequenceLoss', loss_weight=1.0, loss_gamma=0.9, stereo_sup=0),
+        dict(type='DeNoConsistencyLoss', loss_weight=0.001, loss_fn='CEL', scale=2)
+    ],
+)
+
+data_array = [
+
+     [
+          dict(KITTI='KITTI_dataset'),
+     ],
+]
+
+
+
+# configs of the canonical space
+data_basic=dict(
+    canonical_space = dict(
+        # img_size=(540, 960),
+        focal_length=1000.0,
+    ),
+    depth_range=(0, 1),
+    depth_normalize=(0.1, 200),
+#     crop_size=(544, 1216),
+#     crop_size = (544, 992),
+    crop_size = (616, 1064),  # %28 = 0
+) 
+
+# online evaluation
+# evaluation = dict(online_eval=True, interval=1000, metrics=['abs_rel', 'delta1', 'rmse'], multi_dataset_eval=True)
+#log_interval = 100
+
+interval = 4000
+log_interval = 100
+evaluation = dict(
+    online_eval=False, 
+    interval=interval, 
+    metrics=['abs_rel', 'delta1', 'rmse', 'normal_mean', 'normal_rmse', 'normal_a1'], 
+    multi_dataset_eval=True,
+    exclude=['DIML_indoor', 'GL3D', 'Tourism', 'MegaDepth'],
+)
+
+# save checkpoint during training, with '*_AMP' is employing the automatic mix precision training
+checkpoint_config = dict(by_epoch=False, interval=interval)
+runner = dict(type='IterBasedRunner_AMP', max_iters=20010)
+
+# optimizer
+optimizer = dict(
+    type='AdamW', 
+    encoder=dict(lr=5e-7, betas=(0.9, 0.999), weight_decay=0, eps=1e-10),
+    decoder=dict(lr=1e-5, betas=(0.9, 0.999), weight_decay=0, eps=1e-10),
+    strict_match = True
+)
+# schedule
+lr_config = dict(policy='poly',
+                 warmup='linear',
+                 warmup_iters=20,
+                 warmup_ratio=1e-6,
+                 power=0.9, min_lr=1e-8, by_epoch=False)
+
+acc_batch = 1
+batchsize_per_gpu = 2
+thread_per_gpu = 2
+
+KITTI_dataset=dict(
+    data = dict(
+    train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))

external/Metric3D/training/mono/configs/RAFTDecoder/vit.raft5.large.py

@@ -0,0 +1,1047 @@
+_base_=['../_base_/losses/all_losses.py',
+       '../_base_/models/encoder_decoder/dino_vit_large_reg.dpt_raft.py',
+
+       '../_base_/datasets/ddad.py',
+       '../_base_/datasets/_data_base_.py',
+       '../_base_/datasets/argovers2.py',
+       '../_base_/datasets/cityscapes.py',
+       '../_base_/datasets/drivingstereo.py',
+       '../_base_/datasets/dsec.py',
+       '../_base_/datasets/lyft.py',
+       '../_base_/datasets/mapillary_psd.py',
+       '../_base_/datasets/diml.py',
+       '../_base_/datasets/taskonomy.py',
+       '../_base_/datasets/uasol.py',
+       '../_base_/datasets/pandaset.py',
+       '../_base_/datasets/waymo.py',
+
+       '../_base_/default_runtime.py',
+       '../_base_/schedules/schedule_1m.py',
+       
+       '../_base_/datasets/hm3d.py',
+       '../_base_/datasets/matterport3d.py',
+       '../_base_/datasets/replica.py',
+       '../_base_/datasets/vkitti.py',
+       ]
+
+import numpy as np
+model=dict(
+    decode_head=dict(
+        type='RAFTDepthNormalDPT5',
+        iters=8,
+        n_downsample=2,
+        detach=False,
+    ),
+)
+
+# loss method
+losses=dict(
+    decoder_losses=[
+        dict(type='VNLoss', sample_ratio=0.2, loss_weight=1.0),   
+        dict(type='GRUSequenceLoss', loss_weight=0.5, loss_gamma=0.9, stereo_sup=0.0),     
+        dict(type='SkyRegularizationLoss', loss_weight=0.001, sample_ratio=0.4, regress_value=200, normal_regress=[0, 0, -1]),
+        dict(type='HDNRandomLoss', loss_weight=0.5, random_num=10),
+        dict(type='HDSNRandomLoss', loss_weight=0.5, random_num=20, batch_limit=4),
+        dict(type='PWNPlanesLoss', loss_weight=1),
+        dict(type='NormalBranchLoss', loss_weight=1.0, loss_fn='NLL_ours_GRU'),
+        dict(type='DeNoConsistencyLoss', loss_weight=0.01, loss_fn='CEL', scale=2, depth_detach=True)
+    ],
+    gru_losses=[
+        dict(type='SkyRegularizationLoss', loss_weight=0.001, sample_ratio=0.4, regress_value=200, normal_regress=[0, 0, -1]),
+    ],
+)
+
+data_array = [
+     # Outdoor 1
+    [
+         dict(UASOL='UASOL_dataset'), #13.6w
+        dict(Cityscapes_trainextra='Cityscapes_dataset'), #1.8w
+        dict(Cityscapes_sequence='Cityscapes_dataset'), #13.5w
+          dict(DIML='DIML_dataset'), # 12.2w
+         dict(Waymo='Waymo_dataset'), # 99w
+    ], 
+     # Outdoor 2
+    [
+          dict(DSEC='DSEC_dataset'),
+          dict(Mapillary_PSD='MapillaryPSD_dataset'), # 74.2w 
+         dict(DrivingStereo='DrivingStereo_dataset'), # 17.6w
+         dict(Argovers2='Argovers2_dataset'), # 285.6w
+    ],
+     # Outdoor 3
+    [
+          dict(Lyft='Lyft_dataset'), #15.8w
+        dict(DDAD='DDAD_dataset'), #7.4w
+        dict(Pandaset='Pandaset_dataset'), #3.8w
+        dict(Virtual_KITTI='VKITTI_dataset'), # 3.7w # syn
+    ],
+     #Indoor 1
+    [
+         dict(Replica='Replica_dataset'), # 5.6w # syn
+         dict(Replica_gso='Replica_dataset'), # 10.7w # syn
+         dict(Hypersim='Hypersim_dataset'), # 2.4w
+         dict(ScanNetAll='ScanNetAll_dataset'),
+    ],
+     # Indoor 2
+    [
+          dict(Taskonomy='Taskonomy_dataset'), #447.2w
+        dict(Matterport3D='Matterport3D_dataset'), #14.4w
+        dict(HM3D='HM3D_dataset'), # 200w, very noisy, sampled some data
+    ],
+]
+
+
+
+# configs of the canonical space
+data_basic=dict(
+    canonical_space = dict(
+        # img_size=(540, 960),
+        focal_length=1000.0,
+    ),
+    depth_range=(0, 1),
+    depth_normalize=(0.1, 200),
+#     crop_size=(544, 1216),
+#     crop_size = (544, 992),
+    crop_size = (616, 1064),  # %28 = 0
+) 
+
+log_interval = 100
+# online evaluation
+# evaluation = dict(online_eval=True, interval=1000, metrics=['abs_rel', 'delta1', 'rmse'], multi_dataset_eval=True)
+interval = 20000
+evaluation = dict(
+    #online_eval=True, 
+    online_eval=False, 
+    interval=interval, 
+    metrics=['abs_rel', 'delta1', 'rmse', 'normal_mean', 'normal_rmse', 'normal_a1'], 
+    multi_dataset_eval=True,
+    exclude=['DIML_indoor', 'GL3D', 'Tourism', 'MegaDepth'],
+)
+
+# save checkpoint during training, with '*_AMP' is employing the automatic mix precision training
+checkpoint_config = dict(by_epoch=False, interval=interval)
+runner = dict(type='IterBasedRunner_AMP', max_iters=800010)
+
+# optimizer
+optimizer = dict(
+    type='AdamW', 
+#     encoder=dict(lr=1e-4, betas=(0.9, 0.999), weight_decay=0.01, eps=1e-6),
+    encoder=dict(lr=1e-5, betas=(0.9, 0.999), weight_decay=1e-3, eps=1e-6),
+    decoder=dict(lr=1e-4, betas=(0.9, 0.999), weight_decay=0.01, eps=1e-6),
+)
+# schedule
+lr_config = dict(policy='poly',
+                 warmup='linear',
+                 warmup_iters=500,
+                 warmup_ratio=1e-6,
+                 power=0.9, min_lr=1e-6, by_epoch=False)
+
+batchsize_per_gpu = 4
+thread_per_gpu = 4
+
+Argovers2_dataset=dict(
+    data = dict(
+    train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Cityscapes_dataset=dict(
+    data = dict(
+    train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+DIML_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Lyft_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+DDAD_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+     #    sample_size = 1200,
+    ),
+    ))
+DSEC_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+DrivingStereo_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+MapillaryPSD_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Pandaset_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Taskonomy_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+UASOL_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Waymo_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Matterport3D_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Replica_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+VKITTI_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+HM3D_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.75, 1.3),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+BlendedMVG_omni_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.75, 1.3),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+    ),
+    ))
+ScanNetAll_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Hypersim_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))

external/Metric3D/training/mono/configs/RAFTDecoder/vit.raft5.small.py

@@ -0,0 +1,1047 @@
+_base_=['../_base_/losses/all_losses.py',
+       '../_base_/models/encoder_decoder/dino_vit_small_reg.dpt_raft.py',
+
+       '../_base_/datasets/ddad.py',
+       '../_base_/datasets/_data_base_.py',
+       '../_base_/datasets/argovers2.py',
+       '../_base_/datasets/cityscapes.py',
+       '../_base_/datasets/drivingstereo.py',
+       '../_base_/datasets/dsec.py',
+       '../_base_/datasets/lyft.py',
+       '../_base_/datasets/mapillary_psd.py',
+       '../_base_/datasets/diml.py',
+       '../_base_/datasets/taskonomy.py',
+       '../_base_/datasets/uasol.py',
+       '../_base_/datasets/pandaset.py',
+       '../_base_/datasets/waymo.py',
+
+       '../_base_/default_runtime.py',
+       '../_base_/schedules/schedule_1m.py',
+       
+       '../_base_/datasets/hm3d.py',
+       '../_base_/datasets/matterport3d.py',
+       '../_base_/datasets/replica.py',
+       '../_base_/datasets/vkitti.py',
+       ]
+
+import numpy as np
+model=dict(
+    decode_head=dict(
+        type='RAFTDepthNormalDPT5',
+        iters=4,
+        n_downsample=2,
+        detach=False,
+    ),
+)
+
+# loss method
+losses=dict(
+    decoder_losses=[
+        dict(type='VNLoss', sample_ratio=0.2, loss_weight=1.0),   
+        dict(type='GRUSequenceLoss', loss_weight=0.5, loss_gamma=0.9, stereo_sup=0.0),     
+        dict(type='SkyRegularizationLoss', loss_weight=0.001, sample_ratio=0.4, regress_value=200, normal_regress=[0, 0, -1]),
+        dict(type='HDNRandomLoss', loss_weight=0.5, random_num=10),
+        dict(type='HDSNRandomLoss', loss_weight=0.5, random_num=20, batch_limit=4),
+        dict(type='PWNPlanesLoss', loss_weight=1),
+        dict(type='NormalBranchLoss', loss_weight=1.0, loss_fn='NLL_ours_GRU'),
+        dict(type='DeNoConsistencyLoss', loss_weight=0.01, loss_fn='CEL', scale=2, depth_detach=True)
+    ],
+    gru_losses=[
+        dict(type='SkyRegularizationLoss', loss_weight=0.001, sample_ratio=0.4, regress_value=200, normal_regress=[0, 0, -1]),
+    ],
+)
+
+data_array = [
+     # Outdoor 1
+    [
+         dict(UASOL='UASOL_dataset'), #13.6w
+        dict(Cityscapes_trainextra='Cityscapes_dataset'), #1.8w
+        dict(Cityscapes_sequence='Cityscapes_dataset'), #13.5w
+          dict(DIML='DIML_dataset'), # 12.2w
+         dict(Waymo='Waymo_dataset'), # 99w
+    ], 
+     # Outdoor 2
+    [
+          dict(DSEC='DSEC_dataset'),
+          dict(Mapillary_PSD='MapillaryPSD_dataset'), # 74.2w 
+         dict(DrivingStereo='DrivingStereo_dataset'), # 17.6w
+         dict(Argovers2='Argovers2_dataset'), # 285.6w
+    ],
+     # Outdoor 3
+    [
+          dict(Lyft='Lyft_dataset'), #15.8w
+        dict(DDAD='DDAD_dataset'), #7.4w
+        dict(Pandaset='Pandaset_dataset'), #3.8w
+        dict(Virtual_KITTI='VKITTI_dataset'), # 3.7w # syn
+    ],
+     #Indoor 1
+    [
+         dict(Replica='Replica_dataset'), # 5.6w # syn
+         dict(Replica_gso='Replica_dataset'), # 10.7w # syn
+         dict(Hypersim='Hypersim_dataset'), # 2.4w
+         dict(ScanNetAll='ScanNetAll_dataset'),
+    ],
+     # Indoor 2
+    [
+          dict(Taskonomy='Taskonomy_dataset'), #447.2w
+        dict(Matterport3D='Matterport3D_dataset'), #14.4w
+        dict(HM3D='HM3D_dataset'), # 200w, very noisy, sampled some data
+    ],
+]
+
+
+
+# configs of the canonical space
+data_basic=dict(
+    canonical_space = dict(
+        # img_size=(540, 960),
+        focal_length=1000.0,
+    ),
+    depth_range=(0, 1),
+    depth_normalize=(0.1, 200),
+#     crop_size=(544, 1216),
+#     crop_size = (544, 992),
+    crop_size = (616, 1064),  # %28 = 0
+) 
+
+log_interval = 100
+# online evaluation
+# evaluation = dict(online_eval=True, interval=1000, metrics=['abs_rel', 'delta1', 'rmse'], multi_dataset_eval=True)
+interval = 20000
+evaluation = dict(
+    #online_eval=True, 
+    online_eval=False, 
+    interval=interval, 
+    metrics=['abs_rel', 'delta1', 'rmse', 'normal_mean', 'normal_rmse', 'normal_a1'], 
+    multi_dataset_eval=True,
+    exclude=['DIML_indoor', 'GL3D', 'Tourism', 'MegaDepth'],
+)
+
+# save checkpoint during training, with '*_AMP' is employing the automatic mix precision training
+checkpoint_config = dict(by_epoch=False, interval=interval)
+runner = dict(type='IterBasedRunner_AMP', max_iters=800010)
+
+# optimizer
+optimizer = dict(
+    type='AdamW', 
+#     encoder=dict(lr=1e-4, betas=(0.9, 0.999), weight_decay=0.01, eps=1e-6),
+    encoder=dict(lr=1e-5, betas=(0.9, 0.999), weight_decay=1e-3, eps=1e-6),
+    decoder=dict(lr=1e-4, betas=(0.9, 0.999), weight_decay=0.01, eps=1e-6),
+)
+# schedule
+lr_config = dict(policy='poly',
+                 warmup='linear',
+                 warmup_iters=500,
+                 warmup_ratio=1e-6,
+                 power=0.9, min_lr=1e-6, by_epoch=False)
+
+batchsize_per_gpu = 6
+thread_per_gpu = 4
+
+Argovers2_dataset=dict(
+    data = dict(
+    train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Cityscapes_dataset=dict(
+    data = dict(
+    train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+DIML_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Lyft_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+DDAD_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+     #    sample_size = 1200,
+    ),
+    ))
+DSEC_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+DrivingStereo_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+MapillaryPSD_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Pandaset_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Taskonomy_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+UASOL_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Waymo_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Matterport3D_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Replica_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+VKITTI_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+HM3D_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.75, 1.3),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+BlendedMVG_omni_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.75, 1.3),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+    ),
+    ))
+ScanNetAll_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Hypersim_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))

external/Metric3D/training/mono/configs/RAFTDecoder/vit.raft5.small.sanity_check.py

@@ -0,0 +1,1014 @@
+_base_=['../_base_/losses/all_losses.py',
+       '../_base_/models/encoder_decoder/dino_vit_small_reg.dpt_raft.py',
+
+       '../_base_/datasets/ddad.py',
+       '../_base_/datasets/_data_base_.py',
+       '../_base_/datasets/argovers2.py',
+       '../_base_/datasets/cityscapes.py',
+       '../_base_/datasets/drivingstereo.py',
+       '../_base_/datasets/dsec.py',
+       '../_base_/datasets/lyft.py',
+       '../_base_/datasets/mapillary_psd.py',
+       '../_base_/datasets/diml.py',
+       '../_base_/datasets/taskonomy.py',
+       '../_base_/datasets/uasol.py',
+       '../_base_/datasets/pandaset.py',
+       '../_base_/datasets/waymo.py',
+
+       '../_base_/default_runtime.py',
+       '../_base_/schedules/schedule_1m.py',
+       
+       '../_base_/datasets/hm3d.py',
+       '../_base_/datasets/matterport3d.py',
+       '../_base_/datasets/replica.py',
+       '../_base_/datasets/vkitti.py',
+       ]
+
+import numpy as np
+model=dict(
+    decode_head=dict(
+        type='RAFTDepthNormalDPT5',
+        iters=4,
+        n_downsample=2,
+        detach=False,
+    ),
+)
+
+# loss method
+losses=dict(
+    decoder_losses=[
+        dict(type='VNLoss', sample_ratio=0.2, loss_weight=1.0),   
+        dict(type='GRUSequenceLoss', loss_weight=0.5, loss_gamma=0.9, stereo_sup=0.0),     
+        dict(type='SkyRegularizationLoss', loss_weight=0.001, sample_ratio=0.4, regress_value=200, normal_regress=[0, 0, -1]),
+        dict(type='HDNRandomLoss', loss_weight=0.5, random_num=10),
+        dict(type='HDSNRandomLoss', loss_weight=0.5, random_num=20, batch_limit=4),
+        dict(type='PWNPlanesLoss', loss_weight=1),
+        dict(type='NormalBranchLoss', loss_weight=1.0, loss_fn='NLL_ours_GRU'),
+        dict(type='DeNoConsistencyLoss', loss_weight=0.01, loss_fn='CEL', scale=2, depth_detach=True)
+    ],
+    gru_losses=[
+        dict(type='SkyRegularizationLoss', loss_weight=0.001, sample_ratio=0.4, regress_value=200, normal_regress=[0, 0, -1]),
+    ],
+)
+
+data_array = [
+    [
+        dict(Matterport3D='Matterport3D_dataset'), #14.4w
+    ],
+]
+
+
+
+# configs of the canonical space
+data_basic=dict(
+    canonical_space = dict(
+        # img_size=(540, 960),
+        focal_length=1000.0,
+    ),
+    depth_range=(0, 1),
+    depth_normalize=(0.1, 200),
+#     crop_size=(544, 1216),
+#     crop_size = (544, 992),
+    crop_size = (616, 1064),  # %28 = 0
+) 
+
+log_interval = 100
+# online evaluation
+# evaluation = dict(online_eval=True, interval=1000, metrics=['abs_rel', 'delta1', 'rmse'], multi_dataset_eval=True)
+interval = 20000
+evaluation = dict(
+    #online_eval=True, 
+    online_eval=False, 
+    interval=interval, 
+    metrics=['abs_rel', 'delta1', 'rmse', 'normal_mean', 'normal_rmse', 'normal_a1'], 
+    multi_dataset_eval=True,
+)
+
+# save checkpoint during training, with '*_AMP' is employing the automatic mix precision training
+checkpoint_config = dict(by_epoch=False, interval=interval)
+runner = dict(type='IterBasedRunner_AMP', max_iters=800010)
+
+# optimizer
+optimizer = dict(
+    type='AdamW', 
+#     encoder=dict(lr=1e-4, betas=(0.9, 0.999), weight_decay=0.01, eps=1e-6),
+    encoder=dict(lr=1e-5, betas=(0.9, 0.999), weight_decay=1e-3, eps=1e-6),
+    decoder=dict(lr=1e-4, betas=(0.9, 0.999), weight_decay=0.01, eps=1e-6),
+)
+# schedule
+lr_config = dict(policy='poly',
+                 warmup='linear',
+                 warmup_iters=500,
+                 warmup_ratio=1e-6,
+                 power=0.9, min_lr=1e-6, by_epoch=False)
+
+batchsize_per_gpu = 3
+thread_per_gpu = 4
+
+Argovers2_dataset=dict(
+    data = dict(
+    train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Cityscapes_dataset=dict(
+    data = dict(
+    train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+DIML_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Lyft_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+DDAD_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+     #    sample_size = 1200,
+    ),
+    ))
+DSEC_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+DrivingStereo_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+MapillaryPSD_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Pandaset_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Taskonomy_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+UASOL_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Waymo_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=True),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Matterport3D_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Replica_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+VKITTI_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+HM3D_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.75, 1.3),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+BlendedMVG_omni_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.75, 1.3),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+    ),
+    ))
+ScanNetAll_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))
+Hypersim_dataset=dict(
+    data = dict(
+        train=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomResize',
+                         prob=0.5,
+                         ratio_range=(0.85, 1.15),
+                         is_lidar=False),
+                    dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='rand', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                    dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.05),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        #sample_size = 10000,
+    ),
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='RandomCrop', 
+                         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                         crop_type='center', 
+                         ignore_label=-1, 
+                         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_size = 1200,
+    ),
+    ))

external/Metric3D/training/mono/configs/_base_/datasets/7scenes.py

@@ -0,0 +1,83 @@
+# dataset settings
+# data will resized/cropped to the canonical size, refer to ._data_base_.py
+
+SevenScenes_dataset=dict(
+    lib = 'SevenScenesDataset',
+    data_root = 'data/public_datasets',
+    data_name = '7Scenes',
+    transfer_to_canonical = True,
+    metric_scale = 1000.0,
+    original_focal_length = 500,
+    original_size = (480, 640),
+    data_type='denselidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='ETH3D/annotations/test_annotations_new.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='ETH3D/annotations/test_annotations_new.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='AdjustSize', 
+               #         ignore_label=-1, 
+               #         padding=[123.675, 116.28, 103.53]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='ETH3D/annotations/test_annotations_new.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[123.675, 116.28, 103.53]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+     ),
+)

external/Metric3D/training/mono/configs/_base_/datasets/_data_base_.py

@@ -0,0 +1,12 @@
+# canonical camera setting and basic data setting
+
+data_basic=dict(
+    canonical_space = dict(
+        img_size=(540, 960),
+        focal_length=1196.0,
+    ),
+    depth_range=(0.9, 150),
+    depth_normalize=(0.006, 1.001),
+    crop_size = (512, 960),
+    clip_depth_range=(0.1, 200),
+)    

external/Metric3D/training/mono/configs/_base_/datasets/argovers2.py

@@ -0,0 +1,74 @@
+# dataset settings
+
+Argovers2_dataset=dict(
+    lib = 'Argovers2Dataset',
+    data_root = 'data/public_datasets',
+    data_name = 'Argovers2',
+    transfer_to_canonical = True,    
+    metric_scale = 200.0,
+    original_focal_length = (1688.844624443858, 1776.8498213965734),
+    original_size = (1550, 2048),
+    data_type='lidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='Argovers2/annotations/train_annotations_wneigh.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LiDarResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='Argovers2/annotations/val_annotations_wneigh.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='Argovers2/annotations/test_annotations_wneigh.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 6000,),
+    ),
+)    

external/Metric3D/training/mono/configs/_base_/datasets/blended_mvg.py

@@ -0,0 +1,78 @@
+# dataset settings
+# data will resized/cropped to the canonical size, refer to ._data_base_.py
+
+BlendedMVG_omni_dataset=dict(
+    lib = 'BlendedMVGOmniDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'BlendedMVG_omni',
+    transfer_to_canonical = True,
+    metric_scale = 512.0,
+    original_focal_length = 575.6656,
+    original_size = (576, 768),
+    data_type='denselidar_nometric',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='BlendedMVG/annotations/train.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.05,),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 50)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='BlendedMVG/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[123.675, 116.28, 103.53]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 5,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='BlendedMVG/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[123.675, 116.28, 103.53]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[123.675, 116.28, 103.53]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+     ),
+)

external/Metric3D/training/mono/configs/_base_/datasets/cityscapes.py

@@ -0,0 +1,79 @@
+# dataset settings
+
+Cityscapes_dataset=dict(
+    lib = 'CityscapesDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'Cityscapes',
+    transfer_to_canonical = True,    
+    metric_scale = 200.0,
+    original_focal_length = (2263.9108952994275, 2263.9108952994275),
+    original_size = (1024, 2048),
+    data_type='stereo',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='Cityscapes_sequence/annotations/train.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='Cityscapes_sequence/annotations/val.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='Cityscapes_sequence/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[123.675, 116.28, 103.53]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+    ),
+)    

external/Metric3D/training/mono/configs/_base_/datasets/ddad.py

@@ -0,0 +1,80 @@
+# dataset settings
+
+DDAD_dataset=dict(
+    lib = 'DDADDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'DDAD',
+    transfer_to_canonical = True,    
+    metric_scale = 200.0,
+    original_focal_length = (2181, 1060),
+    original_size = (1216, 1936),
+    data_type='lidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='DDAD/annotations/train_annotations.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LiDarResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='DDAD/annotations/val_annotations.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='DDAD/annotations/test_annotations.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+               #   dict(type='LabelScaleCononical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960), #(1216, 1952), #
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[123.675, 116.28, 103.53]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 800,),
+    ),
+)    

external/Metric3D/training/mono/configs/_base_/datasets/ddad_any.py

@@ -0,0 +1,79 @@
+# dataset settings
+
+DDADAny_dataset=dict(
+    lib = 'AnyDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'DDAD',
+    transfer_to_canonical = True,    
+    metric_scale = 200.0,
+    original_focal_length = (2181, 1060),
+    original_size = (1216, 1936),
+    data_type='lidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='DDAD/annotations/train_annotations.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LiDarResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='DDAD/annotations/val_annotations.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='DDAD/annotations/test_annotations.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 6000,),
+    ),
+)    

external/Metric3D/training/mono/configs/_base_/datasets/diml.py

@@ -0,0 +1,79 @@
+# dataset settings
+
+DIML_dataset=dict(
+    lib = 'DIMLDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'DIML',
+    transfer_to_canonical = True,    
+    metric_scale = 200.0,
+    original_focal_length = (1398.402, ),
+    original_size = (1080, 1920),
+    data_type='stereo',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='DIML/annotations/train.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='DIML/annotations/val.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='DIML/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[123.675, 116.28, 103.53]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+    ),
+)    

external/Metric3D/training/mono/configs/_base_/datasets/diml_indoor.py

@@ -0,0 +1,76 @@
+# dataset settings
+
+DIML_indoor_dataset=dict(
+    lib = 'DIMLDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'DIML_indoor',
+    metric_scale = 1000.0,
+    data_type='stereo_nocamera',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='DIML/annotations/train.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='DIML/annotations/val.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='DIML/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[123.675, 116.28, 103.53]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+    ),
+)    

external/Metric3D/training/mono/configs/_base_/datasets/diode.py

@@ -0,0 +1,80 @@
+# dataset settings
+# data will resized/cropped to the canonical size, refer to ._data_base_.py
+
+DIODE_dataset=dict(
+    lib = 'DIODEDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'DIODE',
+    transfer_to_canonical = True,
+    metric_scale = 1.0,
+    original_focal_length = 886.81,
+    original_size = (764, 1024),
+    data_type='denselidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='DIODE/annotations/train.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='DIODE/annotations/val.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 50,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='DIODE/annotations/test_annotations_new.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[123.675, 116.28, 103.53]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+     ),
+)

external/Metric3D/training/mono/configs/_base_/datasets/drivingstereo.py

@@ -0,0 +1,79 @@
+# dataset settings
+
+DrivingStereo_dataset=dict(
+    lib = 'DrivingStereoDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'DrivingStereo',
+    transfer_to_canonical = True,    
+    metric_scale = 256.0,
+    original_focal_length = (1006.938, 1003.556),
+    original_size = (400, 881),
+    data_type='lidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='DrivingStereo/annotations/train_annotations.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LiDarResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='DrivingStereo/annotations/val_annotations.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='DrivingStereo/annotations/test_annotations.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[123.675, 116.28, 103.53]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+    ),
+)    

external/Metric3D/training/mono/configs/_base_/datasets/dsec.py

@@ -0,0 +1,79 @@
+# dataset settings
+
+DSEC_dataset=dict(
+    lib = 'DSECDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'DSEC',
+    transfer_to_canonical = True,    
+    metric_scale = 200.0,
+    original_focal_length = (1150.8943600390282, ),
+    original_size = (1080, 1440),
+    data_type='lidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='DSEC/annotations/train_annotations_wtmpl.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LiDarResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='DSEC/annotations/val_annotations_wtmpl.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='DSEC/annotations/test_annotations_wtmpl.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[123.675, 116.28, 103.53]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+    ),
+)

external/Metric3D/training/mono/configs/_base_/datasets/eth3d.py

@@ -0,0 +1,80 @@
+# dataset settings
+# data will resized/cropped to the canonical size, refer to ._data_base_.py
+
+ETH3D_dataset=dict(
+    lib = 'ETH3DDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'ETH3D',
+    transfer_to_canonical = True,
+    metric_scale = 1.0,
+    original_focal_length = 886.81,
+    original_size = (764, 1024),
+    data_type='lidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='ETH3D/annotations/test_annotations_new.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='ETH3D/annotations/test_annotations_new.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='ETH3D/annotations/test_annotations_new.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[123.675, 116.28, 103.53]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+     ),
+)

external/Metric3D/training/mono/configs/_base_/datasets/hm3d.py

@@ -0,0 +1,78 @@
+# dataset settings
+# data will resized/cropped to the canonical size, refer to ._data_base_.py
+
+HM3D_dataset=dict(
+    lib = 'HM3DDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'HM3D',
+    transfer_to_canonical = True,
+    metric_scale = 512.0,
+    original_focal_length = 575.6656,
+    original_size = (512, 512),
+    data_type='denselidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='HM3D/annotations/train.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(0.9, 1.2)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.0, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.05,),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 50)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='HM3D/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='HM3D/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[123.675, 116.28, 103.53]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+     ),
+)

external/Metric3D/training/mono/configs/_base_/datasets/hypersim.py

@@ -0,0 +1,71 @@
+# dataset settings
+# data will resized/cropped to the canonical size, refer to ._data_base_.py
+
+Hypersim_dataset=dict(
+    lib = 'HypersimDataset',
+    data_name = 'Hypersim',
+    metric_scale = 1.0,
+    data_type='denselidar_syn',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(0.9, 1.3)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.0, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.05,),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 50)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 200,),
+    # configs for the training pipeline
+    test=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 2000,),
+     ),
+)

external/Metric3D/training/mono/configs/_base_/datasets/ibims.py

@@ -0,0 +1,80 @@
+# dataset settings
+# data will resized/cropped to the canonical size, refer to ._data_base_.py
+
+IBIMS_dataset=dict(
+    lib = 'IBIMSDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'IBIMS',
+    transfer_to_canonical = True,
+    metric_scale = 1000.0,
+    original_focal_length = 518.857,
+    original_size = (480, 640),
+    data_type='lidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='IBIMS/annotations/train.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='IBIMS/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='IBIMS/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[123.675, 116.28, 103.53]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+     ),
+)

external/Metric3D/training/mono/configs/_base_/datasets/kitti.py

@@ -0,0 +1,80 @@
+# dataset settings
+# data will resized/cropped to the canonical size, refer to ._data_base_.py
+
+KITTI_dataset=dict(
+    lib = 'KITTIDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'KITTI',
+    transfer_to_canonical = True,
+    metric_scale = 256.0,
+    original_focal_length = 518.857,
+    original_size = (480, 640),
+    data_type='lidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='KITTI/annotations/train.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='KITTI/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='KITTI/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[123.675, 116.28, 103.53]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+     ),
+)

external/Metric3D/training/mono/configs/_base_/datasets/leddarpixset.py

@@ -0,0 +1,80 @@
+# dataset settings
+
+LeddarPixSet_dataset=dict(
+    lib = 'LeddarPixSetDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'LeddarPixSet',
+    transfer_to_canonical = True,    
+    metric_scale = 200.0,
+    original_focal_length = (2181, 1060),
+    original_size = (1080, 1440),
+    data_type='lidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='LeddarPixSet/annotations/train_annotations.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LiDarResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='LeddarPixSet/annotations/val_annotations.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 50,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='LeddarPixSet/annotations/test_annotations.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+               #   dict(type='LabelScaleCononical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960), #(1216, 1952), #
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[123.675, 116.28, 103.53]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+    ),
+)    

external/Metric3D/training/mono/configs/_base_/datasets/lyft.py

@@ -0,0 +1,79 @@
+# dataset settings
+
+Lyft_dataset=dict(
+    lib = 'LyftDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'Lyft',
+    transfer_to_canonical = True,    
+    metric_scale = 200.0,
+    original_focal_length = (877.406430795, 3416.79, 1108.782, 3986.358, 3427.04, ),
+    original_size = (1024, 1224),
+    data_type='lidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='Lyft/annotations/train_annotations_wtmpl.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LiDarResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='Lyft/annotations/val_annotations_wtmpl.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='Lyft/annotations/test_annotations_wtmpl.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 6000,),
+    ),
+)    

external/Metric3D/training/mono/configs/_base_/datasets/lyft_any.py

@@ -0,0 +1,79 @@
+# dataset settings
+
+LyftAny_dataset=dict(
+    lib = 'AnyDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'Lyft',
+    transfer_to_canonical = True,    
+    metric_scale = 200.0,
+    original_focal_length = (877.406430795, 880.82631362),
+    original_size = (1024, 1224),
+    data_type='lidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='Lyft/annotations/train_annotations_wtmpl.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LiDarResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='Lyft/annotations/val_annotations_wtmpl.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='Lyft/annotations/test_annotations_wtmpl.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[123.675, 116.28, 103.53]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 6000,),
+    ),
+)    

external/Metric3D/training/mono/configs/_base_/datasets/mapillary_psd.py

@@ -0,0 +1,79 @@
+# dataset settings
+
+MapillaryPSD_dataset=dict(
+    lib = 'MapillaryPSDDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'MapillaryPSD',
+    transfer_to_canonical = True,    
+    metric_scale = 256.0,
+    original_focal_length = (1664.38, 1725.494, 1231.4812, 2576.447),
+    original_size = (1536, 2048),
+    data_type='sfm',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='Mapillary_PSD/annotations/train_annotations.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriten by data_basic configs
+                       crop_type='rand',  # center, rand, rand_in_field
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='Mapillary_PSD/annotations/val_annotations.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='Mapillary_PSD/annotations/test_annotations.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+    ),
+)    

external/Metric3D/training/mono/configs/_base_/datasets/matterport3d.py

@@ -0,0 +1,78 @@
+# dataset settings
+# data will resized/cropped to the canonical size, refer to ._data_base_.py
+
+Matterport3D_dataset=dict(
+    lib = 'Matterport3DDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'Matterport3D',
+    transfer_to_canonical = True,
+    metric_scale = 4000.0,
+    original_focal_length = 575.6656,
+    original_size = (1024, 1280),
+    data_type='denselidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='Matterport3D/annotations/test.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.05,),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 50)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='Matterport3D/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='Matterport3D/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+     ),
+)

external/Metric3D/training/mono/configs/_base_/datasets/nuscenes.py

@@ -0,0 +1,79 @@
+# dataset settings
+
+NuScenes_dataset=dict(
+    lib = 'NuScenesDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'NuScenes',
+    transfer_to_canonical = True,    
+    metric_scale = 200.0,
+    original_focal_length = (877.406430795, 1200.82631362),
+    original_size = (1024, 1224),
+    data_type='lidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='NuScenes/annotations/train_annotations_wtmpl.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LiDarResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='NuScenes/annotations/val_annotations_wtmpl.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='NuScenes/annotations/test_annotations_wtmpl.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+    ),
+)    

external/Metric3D/training/mono/configs/_base_/datasets/nuscenes_any.py

@@ -0,0 +1,79 @@
+# dataset settings
+
+NuScenesAny_dataset=dict(
+    lib = 'AnyDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'NuScenes',
+    transfer_to_canonical = True,    
+    metric_scale = 200.0,
+    original_focal_length = (877.406430795, 1200.82631362),
+    original_size = (1024, 1224),
+    data_type='lidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='NuScenes/annotations/train_annotations_wtmpl.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LiDarResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='NuScenes/annotations/val_annotations_wtmpl.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='NuScenes/annotations/test_annotations_wtmpl.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+    ),
+)    

external/Metric3D/training/mono/configs/_base_/datasets/nyu.py

@@ -0,0 +1,80 @@
+# dataset settings
+# data will resized/cropped to the canonical size, refer to ._data_base_.py
+
+NYU_dataset=dict(
+    lib = 'NYUDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'NYU',
+    transfer_to_canonical = True,
+    metric_scale = 6000.0,
+    original_focal_length = 518.857,
+    original_size = (480, 640),
+    data_type='lidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='NYU/annotations/train.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='NYU/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='NYU/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+     ),
+)

external/Metric3D/training/mono/configs/_base_/datasets/pandaset.py

@@ -0,0 +1,79 @@
+# dataset settings
+
+Pandaset_dataset=dict(
+    lib = 'PandasetDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'Pandaset',
+    transfer_to_canonical = True,    
+    metric_scale = 200.0,
+    original_focal_length = (1970.01, 930.45, 929.84),
+    original_size = (1080, 1920),
+    data_type='lidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='Pandaset/annotations/annotations_train.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LiDarResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='Pandaset/annotations/annotations_val.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='Pandaset/annotations/annotations_test.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 800,),
+    ),
+)    

external/Metric3D/training/mono/configs/_base_/datasets/replica.py

@@ -0,0 +1,78 @@
+# dataset settings
+# data will resized/cropped to the canonical size, refer to ._data_base_.py
+
+Replica_dataset=dict(
+    lib = 'ReplicaDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'Replica',
+    transfer_to_canonical = True,
+    metric_scale = 512.0,
+    original_focal_length = 575.6656,
+    original_size = (512, 512),
+    data_type='denselidar_syn',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='Replica/annotations/test.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.05,),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 50)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='Replica/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 50,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='Replica/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 2000,),
+     ),
+)

external/Metric3D/training/mono/configs/_base_/datasets/scannet.py

@@ -0,0 +1,80 @@
+# dataset settings
+# data will resized/cropped to the canonical size, refer to ._data_base_.py
+
+ScanNet_dataset=dict(
+    lib = 'ScanNetDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'ScanNet',
+    transfer_to_canonical = True,
+    metric_scale = 1000.0,
+    original_focal_length = 1165.371094,
+    original_size = (968, 1296),
+    data_type='lidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='ScanNet/annotations/test.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='ScanNet/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='ScanNet/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+     ),
+)

external/Metric3D/training/mono/configs/_base_/datasets/scannet_all.py

@@ -0,0 +1,80 @@
+# dataset settings
+# data will resized/cropped to the canonical size, refer to ._data_base_.py
+
+ScanNetAll_dataset=dict(
+    lib = 'ScanNetDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'ScanNetAll',
+    transfer_to_canonical = True,
+    metric_scale = 1000.0,
+    original_focal_length = 1165.371094,
+    original_size = (968, 1296),
+    data_type='denselidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='ScanNet/annotations/test.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='ScanNet/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='ScanNet/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+     ),
+)

external/Metric3D/training/mono/configs/_base_/datasets/taskonomy.py

@@ -0,0 +1,78 @@
+# dataset settings
+# data will resized/cropped to the canonical size, refer to ._data_base_.py
+
+Taskonomy_dataset=dict(
+    lib = 'TaskonomyDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'Taskonomy',
+    transfer_to_canonical = True,
+    metric_scale = 512.0,
+    original_focal_length = 575.6656,
+    original_size = (512, 512),
+    data_type='denselidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='Taskonomy/annotations/test.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(0.9, 1.3)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.0, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.1,
+                       distortion_prob=0.05,),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 50)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='Taskonomy/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 20,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='Taskonomy/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 2000,),
+     ),
+)

external/Metric3D/training/mono/configs/_base_/datasets/uasol.py

@@ -0,0 +1,74 @@
+# dataset settings
+
+UASOL_dataset=dict(
+    lib = 'UASOLDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'UASOL',
+    transfer_to_canonical = True,    
+    metric_scale = 200.0,
+    original_focal_length = (2263.9108952994275, 2263.9108952994275),
+    original_size = (1024, 2048),
+    data_type='stereo',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='UASOL/annotations/train.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='UASOL/annotations/test_all.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 100,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='UASOL/annotations/test_all.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+    ),
+)    

external/Metric3D/training/mono/configs/_base_/datasets/vkitti.py

@@ -0,0 +1,80 @@
+# dataset settings
+# data will resized/cropped to the canonical size, refer to ._data_base_.py
+
+VKITTI_dataset=dict(
+    lib = 'VKITTIDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'VKITTI',
+    transfer_to_canonical = True,
+    metric_scale = 100.0,
+    original_focal_length = 725.0087,
+    original_size = (375, 1242),
+    data_type='denselidar_syn',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='VKITTI/annotations/train.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='VKITTI/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 50,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='VKITTI/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+     ),
+)

external/Metric3D/training/mono/configs/_base_/datasets/waymo.py

@@ -0,0 +1,80 @@
+# dataset settings
+# data will resized/cropped to the canonical size, refer to ._data_base_.py
+
+Waymo_dataset=dict(
+    lib = 'WaymoDataset',
+    data_root = 'data/public_datasets',
+    data_name = 'Waymo',
+    transfer_to_canonical = True,
+    metric_scale = 200.0,
+    original_focal_length = 2000.8,
+    original_size = (2000, 2000),
+    data_type='lidar',
+    data = dict(
+    # configs for the training pipeline
+    train=dict(
+        anno_path='Waymo/annotations/train.json',
+        sample_ratio = 1.0,
+        sample_size = -1,
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(0.9, 1.4)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='rand', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                 dict(type='RandomEdgeMask',
+                         mask_maxsize=50, 
+                         prob=0.2, 
+                         rgb_invalid=[0,0,0], 
+                         label_invalid=-1,),
+                  dict(type='RandomHorizontalFlip', 
+                       prob=0.4),
+                  dict(type='PhotoMetricDistortion', 
+                       to_gray_prob=0.2,
+                       distortion_prob=0.1,),
+                  dict(type='Weather',
+                       prob=0.1),
+                  dict(type='RandomBlur', 
+                       prob=0.05),
+                  dict(type='RGBCompresion', prob=0.1, compression=(0, 40)),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],),
+
+    # configs for the training pipeline
+    val=dict(
+        anno_path='Waymo/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='ResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='RandomCrop', 
+                       crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+                       crop_type='center', 
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 50,),
+    # configs for the training pipeline
+    test=dict(
+        anno_path='Waymo/annotations/test.json',
+        pipeline=[dict(type='BGR2RGB'),
+               #   dict(type='LiDarResizeCanonical', ratio_range=(1.0, 1.0)),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(512, 960),
+                       ignore_label=-1, 
+                       padding=[0, 0, 0]),
+               #    dict(type='RandomCrop', 
+               #         crop_size=(0,0), # crop_size will be overwriteen by data_basic configs
+               #         crop_type='center', 
+               #         ignore_label=-1, 
+               #         padding=[0, 0, 0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,),
+     ),
+)

external/Metric3D/training/mono/configs/_base_/default_runtime.py

@@ -0,0 +1,23 @@
+# distributed training configs, if  dist_url == 'env://'('tcp://127.0.0.1:6795'), nodes related configs should be set in the shell
+dist_params = dict(port=None, backend='nccl', dist_url='env://')
+
+log_name = 'tbd'
+log_file = 'out.log'
+
+load_from = None
+resume_from = None
+
+#workflow = [('train', 1)]
+cudnn_benchmark = True
+log_interval = 20
+
+use_tensorboard = True
+
+evaluation = dict(online_eval=True, interval=1000, metrics=['abs_rel', 'delta1'])
+checkpoint_config = dict(by_epoch=False, interval=16000)
+
+
+# runtime settings, IterBasedRunner or EpochBasedRunner, e.g. runner = dict(type='EpochBasedRunner', max_epoches=100)
+runner = dict(type='IterBasedRunner', max_iters=160000)
+
+test_metrics = ['abs_rel', 'rmse', 'silog', 'delta1', 'delta2', 'delta3', 'rmse_log', 'log10', 'sq_rel']

external/Metric3D/training/mono/configs/_base_/losses/all_losses.py

@@ -0,0 +1,26 @@
+"""
+There are multiple losses can be applied. 
+
+dict(type='GradientLoss_Li', scale_num=4, loss_weight=1.0),
+dict(type='VNLoss', sample_ratio=0.2, loss_weight=1.0),
+dict(type='SilogLoss', variance_focus=0.5, loss_weight=1.0),
+dict(type='WCELoss', loss_weight=1.0, depth_normalize=(0.1, 1), bins_num=200)
+dict(type='RegularizationLoss', loss_weight=0.1)
+dict(type='EdgeguidedRankingLoss', loss_weight=1.0)
+Note that out_channel and depth_normalize will be overwriten by configs in data_basic. 
+"""
+
+# loss_decode=[dict(type='VNLoss', sample_ratio=0.2, loss_weight=1.0),
+#              #dict(type='SilogLoss', variance_focus=0.5, loss_weight=1.0),
+#              dict(type='WCELoss', loss_weight=1.0, depth_normalize=(0, 0), out_channel=0)]
+
+# loss_auxi = [#dict(type='WCELoss', loss_weight=1.0, depth_normalize=(0.1, 1), out_channel=200),
+#             ]
+losses=dict(
+    decoder_losses=[
+        dict(type='VNLoss', sample_ratio=0.2, loss_weight=1.0),
+        dict(type='WCELoss', loss_weight=1.0, depth_normalize=(0, 0), out_channel=0),
+    ],
+    auxi_losses=[],
+    pose_losses=[],
+)

external/Metric3D/training/mono/configs/_base_/models/backbones/dino_vit_giant2_reg.py

@@ -0,0 +1,7 @@
+model = dict(
+    backbone=dict(
+        type='vit_giant2_reg',
+        prefix='backbones.',
+        out_channels=[1536, 1536, 1536, 1536],
+        drop_path_rate = 0.0),
+    )

external/Metric3D/training/mono/configs/_base_/models/backbones/dino_vit_large_reg.py

@@ -0,0 +1,7 @@
+model = dict(
+    backbone=dict(
+        type='vit_large_reg',
+        prefix='backbones.',
+        out_channels=[1024, 1024, 1024, 1024],
+        drop_path_rate = 0.0),
+    )

external/Metric3D/training/mono/configs/_base_/models/backbones/dino_vit_small_reg.py

@@ -0,0 +1,7 @@
+model = dict(
+    backbone=dict(
+        type='vit_small_reg',
+        prefix='backbones.',
+        out_channels=[384, 384, 384, 384],
+        drop_path_rate = 0.0),
+    )

external/Metric3D/training/mono/configs/_base_/models/encoder_decoder/dino_vit_giant2_reg.dpt_raft.py

@@ -0,0 +1,19 @@
+# model settings
+_base_ = ['../backbones/dino_vit_giant2_reg.py']
+model = dict(
+    type='DensePredModel',
+    decode_head=dict(
+        type='RAFTDepthDPT',
+        in_channels=[1536, 1536, 1536, 1536],
+        use_cls_token=True,
+        feature_channels = [384, 768, 1536, 1536], # [2/7, 1/7, 1/14, 1/14]
+        decoder_channels = [192, 384, 768, 1536, 1536], # [4/7, 2/7, 1/7, 1/14, 1/14]
+        up_scale = 7,
+        hidden_channels=[192, 192, 192, 192], # [x_4, x_8, x_16, x_32] [192, 384, 768, 1536]
+        n_gru_layers=3,
+        n_downsample=2,
+        iters=3,
+        slow_fast_gru=True,
+        num_register_tokens=4,
+        prefix='decode_heads.'),
+)

external/Metric3D/training/mono/configs/_base_/models/encoder_decoder/dino_vit_large_reg.dpt_raft.py

@@ -0,0 +1,19 @@
+# model settings
+_base_ = ['../backbones/dino_vit_large_reg.py']
+model = dict(
+    type='DensePredModel',
+    decode_head=dict(
+        type='RAFTDepthDPT',
+        in_channels=[1024, 1024, 1024, 1024],
+        use_cls_token=True,
+        feature_channels = [256, 512, 1024, 1024], # [2/7, 1/7, 1/14, 1/14]
+        decoder_channels = [128, 256, 512, 1024, 1024], # [4/7, 2/7, 1/7, 1/14, 1/14]
+        up_scale = 7,
+        hidden_channels=[128, 128, 128, 128], # [x_4, x_8, x_16, x_32] [192, 384, 768, 1536]
+        n_gru_layers=3,
+        n_downsample=2,
+        iters=3,
+        slow_fast_gru=True,
+        num_register_tokens=4,
+        prefix='decode_heads.'),
+)

external/Metric3D/training/mono/configs/_base_/models/encoder_decoder/dino_vit_small_reg.dpt_raft.py

@@ -0,0 +1,19 @@
+# model settings
+_base_ = ['../backbones/dino_vit_small_reg.py']
+model = dict(
+    type='DensePredModel',
+    decode_head=dict(
+        type='RAFTDepthDPT',
+        in_channels=[384, 384, 384, 384],
+        use_cls_token=True,
+        feature_channels = [96, 192, 384, 768], # [2/7, 1/7, 1/14, 1/14]
+        decoder_channels = [48, 96, 192, 384, 384], # [-, 1/4, 1/7, 1/14, 1/14]
+        up_scale = 7,
+        hidden_channels=[48, 48, 48, 48], # [x_4, x_8, x_16, x_32] [1/4, 1/7, 1/14, -]
+        n_gru_layers=3,
+        n_downsample=2,
+        iters=3,
+        slow_fast_gru=True,
+        num_register_tokens=4,
+        prefix='decode_heads.'),
+)